OGS
ProcessLib::TES::TESProcess Class Referencefinal

Detailed Description

Definition at line 30 of file TESProcess.h.

#include <TESProcess.h>

Inheritance diagram for ProcessLib::TES::TESProcess:
[legend]
Collaboration diagram for ProcessLib::TES::TESProcess:
[legend]

Public Member Functions

 TESProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, SecondaryVariableCollection &&secondary_variables, BaseLib::ConfigTree const &config)
 
void preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id) override
 
void preIterationConcreteProcess (const unsigned iter, GlobalVector const &x) override
 
NumLib::IterationResult postIterationConcreteProcess (GlobalVector const &x) override
 
bool isLinear () const override
 
- Public Member Functions inherited from ProcessLib::Process
 Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)
 
void preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
 Preprocessing before starting assembly for new timestep.
 
void postTimestep (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id)
 Postprocessing after a complete timestep.
 
void postNonLinearSolver (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, double const dt, int const process_id)
 
void preIteration (const unsigned iter, GlobalVector const &x) final
 
void computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
 compute secondary variables for the coupled equations or for output.
 
NumLib::IterationResult postIteration (GlobalVector const &x) final
 
void initialize (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
 
void setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)
 
MathLib::MatrixSpecifications getMatrixSpecifications (const int process_id) const override
 
void updateDeactivatedSubdomains (double const time, const int process_id)
 
virtual bool isMonolithicSchemeUsed () const
 
virtual void extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)
 
void preAssemble (const double t, double const dt, GlobalVector const &x) final
 
void assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) final
 
void assembleWithJacobian (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) final
 
void preOutput (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)
 
std::vector< NumLib::IndexValueVector< GlobalIndexType > > const * getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final
 
virtual NumLib::LocalToGlobalIndexMap const & getDOFTable (const int) const
 
MeshLib::MeshgetMesh () const
 
std::vector< std::reference_wrapper< ProcessVariable > > const & getProcessVariables (const int process_id) const
 
std::vector< std::size_t > const & getActiveElementIDs () const
 
SecondaryVariableCollection const & getSecondaryVariables () const
 
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const & getIntegrationPointWriters () const
 
virtual Eigen::Vector3d getFlux (std::size_t, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &) const
 
virtual void solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)
 
- Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::string > initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)
 
virtual ~SubmeshAssemblySupport ()=default
 

Private Member Functions

void initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
 Process specific initialization called by initialize().
 
void assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) override
 
void initializeSecondaryVariables ()
 
void assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) override
 
GlobalVector const & computeVapourPartialPressure (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
 
GlobalVector const & computeRelativeHumidity (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
 
GlobalVector const & computeEquilibriumLoading (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
 

Private Attributes

std::vector< std::unique_ptr< TESLocalAssemblerInterface > > _local_assemblers
 
AssemblyParams _assembly_params
 
std::unique_ptr< GlobalVector_x_previous_timestep
 

Additional Inherited Members

- Public Attributes inherited from ProcessLib::Process
std::string const name
 
- Static Public Attributes inherited from ProcessLib::Process
static PROCESSLIB_EXPORT const std::string constant_one_parameter_name = "constant_one"
 
- Protected Member Functions inherited from ProcessLib::Process
std::vector< NumLib::LocalToGlobalIndexMap const * > getDOFTables (int const number_of_processes) const
 
NumLib::ExtrapolatorgetExtrapolator () const
 
NumLib::LocalToGlobalIndexMap const & getSingleComponentDOFTable () const
 
void initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
 
virtual void constructDofTable ()
 
void constructMonolithicProcessDofTable ()
 
void constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
 
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool > getDOFTableForExtrapolatorData () const
 
std::vector< GlobalIndexTypegetIndicesOfResiduumWithoutInitialCompensation () const override
 
- Protected Attributes inherited from ProcessLib::Process
MeshLib::Mesh_mesh
 
std::unique_ptr< MeshLib::MeshSubset const > _mesh_subset_all_nodes
 
std::unique_ptr< NumLib::LocalToGlobalIndexMap_local_to_global_index_map
 
SecondaryVariableCollection _secondary_variables
 
CellAverageData cell_average_data_
 
std::unique_ptr< ProcessLib::AbstractJacobianAssembler_jacobian_assembler
 
VectorMatrixAssembler _global_assembler
 
const bool _use_monolithic_scheme
 
unsigned const _integration_order
 
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > _integration_point_writer
 
GlobalSparsityPattern _sparsity_pattern
 
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > _process_variables
 
std::vector< BoundaryConditionCollection_boundary_conditions
 

Constructor & Destructor Documentation

◆ TESProcess()

ProcessLib::TES::TESProcess::TESProcess ( std::string name,
MeshLib::Mesh & mesh,
std::unique_ptr< AbstractJacobianAssembler > && jacobian_assembler,
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const & parameters,
unsigned const integration_order,
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > && process_variables,
SecondaryVariableCollection && secondary_variables,
BaseLib::ConfigTree const & config )
Input File Parameter
prj__processes__process__TES__fluid_specific_heat_source
Input File Parameter
prj__processes__process__TES__fluid_specific_isobaric_heat_capacity
Input File Parameter
prj__processes__process__TES__solid_specific_heat_source
Input File Parameter
prj__processes__process__TES__solid_heat_conductivity
Input File Parameter
prj__processes__process__TES__solid_specific_isobaric_heat_capacity
Input File Parameter
prj__processes__process__TES__tortuosity
Input File Parameter
prj__processes__process__TES__diffusion_coefficient
Input File Parameter
prj__processes__process__TES__porosity
Input File Parameter
prj__processes__process__TES__solid_density_dry
Input File Parameter
prj__processes__process__TES__solid_density_initial
Input File Parameter
special OGS input file parameter
Input File Parameter
prj__processes__process__TES__characteristic_pressure
Input File Parameter
prj__processes__process__TES__characteristic_temperature
Input File Parameter
prj__processes__process__TES__characteristic_vapour_mass_fraction
Input File Parameter
special OGS input file parameter
Input File Parameter
prj__processes__process__TES__solid_hydraulic_permeability
Input File Parameter
prj__processes__process__TES__reactive_system
Input File Parameter
prj__processes__process__TES__output_element_matrices

Definition at line 20 of file TESProcess.cpp.

30 : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
31 integration_order, std::move(process_variables),
32 std::move(secondary_variables))
33{
34 DBUG("Create TESProcess.");
35
36 // physical parameters for local assembly
37 {
38 std::vector<std::pair<std::string, double*>> params{
40 {"fluid_specific_heat_source",
43 {"fluid_specific_isobaric_heat_capacity", &_assembly_params.cpG},
45 {"solid_specific_heat_source",
48 {"solid_heat_conductivity", &_assembly_params.solid_heat_cond},
50 {"solid_specific_isobaric_heat_capacity", &_assembly_params.cpS},
52 {"tortuosity", &_assembly_params.tortuosity},
54 {"diffusion_coefficient",
57 {"porosity", &_assembly_params.poro},
59 {"solid_density_dry", &_assembly_params.rho_SR_dry},
61 {"solid_density_initial", &_assembly_params.initial_solid_density}};
62
63 for (auto const& p : params)
64 {
65 if (auto const par =
67 config.getConfigParameterOptional<double>(p.first))
68 {
69 DBUG("setting parameter `{:s}' to value `{:g}'", p.first, *par);
70 *p.second = *par;
71 }
72 }
73 }
74
75 // characteristic values of primary variables
76 {
77 std::vector<std::pair<std::string, Trafo*>> const params{
79 {"characteristic_pressure", &_assembly_params.trafo_p},
81 {"characteristic_temperature", &_assembly_params.trafo_T},
83 {"characteristic_vapour_mass_fraction", &_assembly_params.trafo_x}};
84
85 for (auto const& p : params)
86 {
87 if (auto const par =
89 config.getConfigParameterOptional<double>(p.first))
90 {
91 INFO("setting parameter `{:s}' to value `{:g}'", p.first, *par);
92 *p.second = Trafo{*par};
93 }
94 }
95 }
96
97 // permeability
98 if (auto par =
100 config.getConfigParameterOptional<double>(
101 "solid_hydraulic_permeability"))
102 {
103 DBUG(
104 "setting parameter `solid_hydraulic_permeability' to isotropic "
105 "value `{:g}'",
106 *par);
107 const auto dim = mesh.getDimension();
109 Eigen::MatrixXd::Identity(dim, dim) * (*par);
110 }
111
112 // reactive system
115 config.getConfigSubtree("reactive_system"));
116
117 // debug output
118 if (auto const param =
120 config.getConfigParameterOptional<bool>("output_element_matrices"))
121 {
122 DBUG("output_element_matrices: {:s}", (*param) ? "true" : "false");
123
125 }
126
127 // TODO somewhere else
128 /*
129 if (auto const param =
131 config.getConfigParameterOptional<bool>("output_global_matrix"))
132 {
133 DBUG("output_global_matrix: {:s}", (*param) ? "true" : "false");
134
135 this->_process_output.output_global_matrix = *param;
136 }
137 */
138}
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
static std::unique_ptr< Reaction > newInstance(BaseLib::ConfigTree const &conf)
Definition Reaction.cpp:27
unsigned getDimension() const
Returns the dimension of the mesh (determined by the maximum dimension over all elements).
Definition Mesh.h:88
std::string const name
Definition Process.h:355
Process(std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)
Definition Process.cpp:44
AssemblyParams _assembly_params
Definition TESProcess.h:94
ProcessLib::TrafoScale Trafo
std::unique_ptr< Adsorption::Reaction > react_sys

References _assembly_params, ProcessLib::TES::AssemblyParams::cpG, ProcessLib::TES::AssemblyParams::cpS, DBUG(), ProcessLib::TES::AssemblyParams::diffusion_coefficient_component, ProcessLib::TES::AssemblyParams::fluid_specific_heat_source, BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), MeshLib::Mesh::getDimension(), INFO(), ProcessLib::TES::AssemblyParams::initial_solid_density, Adsorption::Reaction::newInstance(), ProcessLib::TES::AssemblyParams::output_element_matrices, ProcessLib::TES::AssemblyParams::poro, ProcessLib::TES::AssemblyParams::react_sys, ProcessLib::TES::AssemblyParams::rho_SR_dry, ProcessLib::TES::AssemblyParams::solid_heat_cond, ProcessLib::TES::AssemblyParams::solid_perm_tensor, ProcessLib::TES::AssemblyParams::solid_specific_heat_source, ProcessLib::TES::AssemblyParams::tortuosity, ProcessLib::TES::AssemblyParams::trafo_p, ProcessLib::TES::AssemblyParams::trafo_T, and ProcessLib::TES::AssemblyParams::trafo_x.

Member Function Documentation

◆ assembleConcreteProcess()

void ProcessLib::TES::TESProcess::assembleConcreteProcess ( const double t,
double const dt,
std::vector< GlobalVector * > const & x,
std::vector< GlobalVector * > const & x_prev,
int const process_id,
GlobalMatrix & M,
GlobalMatrix & K,
GlobalVector & b )
overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 206 of file TESProcess.cpp.

210{
211 DBUG("Assemble TESProcess.");
212
213 std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
215
216 // Call global assembler for each local assembly item.
219 getActiveElementIDs(), dof_table, t, dt, x, x_prev, process_id, M, K,
220 b);
221}
std::vector< std::size_t > const & getActiveElementIDs() const
Definition Process.h:161
VectorMatrixAssembler _global_assembler
Definition Process.h:370
std::unique_ptr< NumLib::LocalToGlobalIndexMap > _local_to_global_index_map
Definition Process.h:361
std::vector< std::unique_ptr< TESLocalAssemblerInterface > > _local_assemblers
Definition TESProcess.h:92
void assemble(std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)
static void executeSelectedMemberDereferenced(Object &object, Method method, Container const &container, std::vector< std::size_t > const &active_container_ids, Args &&... args)

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::Process::getActiveElementIDs().

◆ assembleWithJacobianConcreteProcess()

void ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess ( const double t,
double const dt,
std::vector< GlobalVector * > const & x,
std::vector< GlobalVector * > const & x_prev,
int const process_id,
GlobalMatrix & M,
GlobalMatrix & K,
GlobalVector & b,
GlobalMatrix & Jac )
overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 223 of file TESProcess.cpp.

227{
228 std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
230
231 // Call global assembler for each local assembly item.
234 _local_assemblers, getActiveElementIDs(), dof_table, t, dt, x, x_prev,
235 process_id, M, K, b, Jac);
236}
void assembleWithJacobian(std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac)

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::Process::getActiveElementIDs().

◆ computeEquilibriumLoading()

GlobalVector const & ProcessLib::TES::TESProcess::computeEquilibriumLoading ( const double t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table,
std::unique_ptr< GlobalVector > & result_cache )
private

Definition at line 386 of file TESProcess.cpp.

391{
392 constexpr int process_id = 0; // monolithic scheme.
393 assert(dof_table[process_id] == _local_to_global_index_map.get());
394
395 auto const& dof_table_single = getSingleComponentDOFTable();
397 {dof_table_single.dofSizeWithoutGhosts(),
398 dof_table_single.dofSizeWithoutGhosts(),
399 &dof_table_single.getGhostIndices(), nullptr});
400
401 GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
402
403 auto const& x = *xs[0]; // monolithic process
404 for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
405 {
406 auto const p = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
407 node_id, COMPONENT_ID_PRESSURE);
408 auto const T = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
409 node_id, COMPONENT_ID_TEMPERATURE);
410 auto const x_mV =
411 NumLib::getNodalValue(x, _mesh, *dof_table[process_id], node_id,
413
416
417 auto const p_V = p * x_nV;
418 auto const C_eq =
419 (p_V <= 0.0) ? 0.0
420 : _assembly_params.react_sys->getEquilibriumLoading(
422
423 result_cache->set(node_id, C_eq);
424 }
425
426 return *result_cache;
427}
GlobalMatrix::IndexType GlobalIndexType
static double getMolarFraction(double xm, double M_this, double M_other)
std::size_t getNumberOfNodes() const
Get the number of nodes.
Definition Mesh.h:100
MeshLib::Mesh & _mesh
Definition Process.h:358
NumLib::LocalToGlobalIndexMap const & getSingleComponentDOFTable() const
Definition Process.h:205
constexpr double M_react
reactive component molar mass
double getNodalValue(GlobalVector const &x, MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const node_id, std::size_t const global_component_id)
const unsigned COMPONENT_ID_MASS_FRACTION
const unsigned COMPONENT_ID_TEMPERATURE
const unsigned COMPONENT_ID_PRESSURE

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, ProcessLib::TES::COMPONENT_ID_TEMPERATURE, Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, ProcessLib::TES::AssemblyParams::M_react, and ProcessLib::TES::AssemblyParams::react_sys.

Referenced by initializeSecondaryVariables().

◆ computeRelativeHumidity()

GlobalVector const & ProcessLib::TES::TESProcess::computeRelativeHumidity ( const double t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table,
std::unique_ptr< GlobalVector > & result_cache )
private

Definition at line 346 of file TESProcess.cpp.

351{
352 constexpr int process_id = 0; // monolithic scheme.
353 assert(dof_table[process_id] == _local_to_global_index_map.get());
354
355 auto const& dof_table_single = getSingleComponentDOFTable();
357 {dof_table_single.dofSizeWithoutGhosts(),
358 dof_table_single.dofSizeWithoutGhosts(),
359 &dof_table_single.getGhostIndices(), nullptr});
360
361 GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
362
363 auto const& x = *xs[0]; // monolithic process
364 for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
365 {
366 auto const p = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
367 node_id, COMPONENT_ID_PRESSURE);
368 auto const T = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
369 node_id, COMPONENT_ID_TEMPERATURE);
370 auto const x_mV =
371 NumLib::getNodalValue(x, _mesh, *dof_table[process_id], node_id,
373
376
377 auto const p_S =
379
380 result_cache->set(node_id, p * x_nV / p_S);
381 }
382
383 return *result_cache;
384}
static double getEquilibriumVapourPressure(const double T_Ads)

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, ProcessLib::TES::COMPONENT_ID_TEMPERATURE, Adsorption::AdsorptionReaction::getEquilibriumVapourPressure(), Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, and ProcessLib::TES::AssemblyParams::M_react.

Referenced by initializeSecondaryVariables().

◆ computeVapourPartialPressure()

GlobalVector const & ProcessLib::TES::TESProcess::computeVapourPartialPressure ( const double t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table,
std::unique_ptr< GlobalVector > & result_cache )
private

Definition at line 311 of file TESProcess.cpp.

316{
317 constexpr int process_id = 0; // monolithic scheme.
318 assert(dof_table[process_id] == _local_to_global_index_map.get());
319
320 auto const& dof_table_single = getSingleComponentDOFTable();
322 {dof_table_single.dofSizeWithoutGhosts(),
323 dof_table_single.dofSizeWithoutGhosts(),
324 &dof_table_single.getGhostIndices(), nullptr});
325
326 GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
327
328 for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
329 {
330 auto const p =
331 NumLib::getNodalValue(*x[process_id], _mesh, *dof_table[process_id],
332 node_id, COMPONENT_ID_PRESSURE);
333 auto const x_mV =
334 NumLib::getNodalValue(*x[process_id], _mesh, *dof_table[process_id],
336
339
340 result_cache->set(node_id, p * x_nV);
341 }
342
343 return *result_cache;
344}

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, and ProcessLib::TES::AssemblyParams::M_react.

Referenced by initializeSecondaryVariables().

◆ initializeConcreteProcess()

void ProcessLib::TES::TESProcess::initializeConcreteProcess ( NumLib::LocalToGlobalIndexMap const & dof_table,
MeshLib::Mesh const & mesh,
unsigned const integration_order )
overrideprivatevirtual

Process specific initialization called by initialize().

Implements ProcessLib::Process.

Definition at line 140 of file TESProcess.cpp.

143{
144 ProcessLib::createLocalAssemblers<TESLocalAssembler>(
145 mesh.getDimension(), mesh.getElements(), dof_table, _local_assemblers,
146 NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
148
150}

References _assembly_params, _local_assemblers, MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), initializeSecondaryVariables(), and MeshLib::Mesh::isAxiallySymmetric().

◆ initializeSecondaryVariables()

void ProcessLib::TES::TESProcess::initializeSecondaryVariables ( )
private

Definition at line 152 of file TESProcess.cpp.

153{
154 // adds a secondary variables to the collection of all secondary variables.
155 auto add2nd =
156 [&](std::string const& var_name, SecondaryVariableFunctions&& fcts)
157 { _secondary_variables.addSecondaryVariable(var_name, std::move(fcts)); };
158
159 // creates an extrapolator
160 auto makeEx =
161 [&](unsigned const n_components,
162 std::vector<double> const& (TESLocalAssemblerInterface::*method)(
163 const double /*t*/,
164 std::vector<GlobalVector*> const& /*x*/,
165 std::vector<
166 NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
167 std::vector<double>& /*cache*/)
168 const) -> SecondaryVariableFunctions
169 {
170 return ProcessLib::makeExtrapolator(n_components, getExtrapolator(),
171 _local_assemblers, method);
172 };
173
174 add2nd("solid_density",
176
177 add2nd("reaction_rate",
179
180 add2nd("darcy_velocity",
181 makeEx(_mesh.getDimension(),
183
184 add2nd("loading", makeEx(1, &TESLocalAssemblerInterface::getIntPtLoading));
185 add2nd(
186 "reaction_damping_factor",
188
189 add2nd("vapour_partial_pressure",
190 {1,
191 [&](auto&&... args) -> GlobalVector const&
192 { return computeVapourPartialPressure(args...); },
193 nullptr});
194 add2nd("relative_humidity",
195 {1,
196 [&](auto&&... args) -> GlobalVector const&
197 { return computeRelativeHumidity(args...); },
198 nullptr});
199 add2nd("equilibrium_loading",
200 {1,
201 [&](auto&&... args) -> GlobalVector const&
202 { return computeEquilibriumLoading(args...); },
203 nullptr});
204}
Global vector based on Eigen vector.
Definition EigenVector.h:25
SecondaryVariableCollection _secondary_variables
Definition Process.h:363
NumLib::Extrapolator & getExtrapolator() const
Definition Process.h:200
void addSecondaryVariable(std::string const &internal_name, SecondaryVariableFunctions &&fcts)
virtual std::vector< double > const & getIntPtSolidDensity(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const =0
virtual std::vector< double > const & getIntPtLoading(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const =0
virtual std::vector< double > const & getIntPtReactionDampingFactor(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const =0
virtual std::vector< double > const & getIntPtDarcyVelocity(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const =0
virtual std::vector< double > const & getIntPtReactionRate(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const =0
GlobalVector const & computeRelativeHumidity(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
GlobalVector const & computeEquilibriumLoading(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
GlobalVector const & computeVapourPartialPressure(const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)
SecondaryVariableFunctions makeExtrapolator(const unsigned num_components, NumLib::Extrapolator &extrapolator, LocalAssemblerCollection const &local_assemblers, typename NumLib::ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection >::IntegrationPointValuesMethod integration_point_values_method)

References _local_assemblers, ProcessLib::Process::_mesh, ProcessLib::Process::_secondary_variables, ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), computeEquilibriumLoading(), computeRelativeHumidity(), computeVapourPartialPressure(), MeshLib::Mesh::getDimension(), ProcessLib::Process::getExtrapolator(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtLoading(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtReactionDampingFactor(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtReactionRate(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtSolidDensity(), and ProcessLib::makeExtrapolator().

Referenced by initializeConcreteProcess().

◆ isLinear()

bool ProcessLib::TES::TESProcess::isLinear ( ) const
inlineoverride

Definition at line 53 of file TESProcess.h.

53{ return false; }

◆ postIterationConcreteProcess()

NumLib::IterationResult ProcessLib::TES::TESProcess::postIterationConcreteProcess ( GlobalVector const & x)
overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 261 of file TESProcess.cpp.

263{
264 bool check_passed = true;
265
267 {
268 // bounds checking only has to happen if the vapour mass fraction is
269 // non-logarithmic.
270
271 std::vector<GlobalIndexType> indices_cache;
272 std::vector<double> local_x_cache;
273 std::vector<double> local_x_prev_ts_cache;
274
276
277 auto check_variable_bounds =
278 [&](std::size_t id, TESLocalAssemblerInterface& loc_asm)
279 {
280 auto const r_c_indices = NumLib::getRowColumnIndices(
281 id, *this->_local_to_global_index_map, indices_cache);
282 local_x_cache = x.get(r_c_indices.rows);
283 local_x_prev_ts_cache = _x_previous_timestep->get(r_c_indices.rows);
284
285 if (!loc_asm.checkBounds(local_x_cache, local_x_prev_ts_cache))
286 {
287 check_passed = false;
288 }
289 };
290
291 GlobalExecutor::executeDereferenced(check_variable_bounds,
293 }
294
295 if (!check_passed)
296 {
298 }
299
300 // TODO remove
301 DBUG("ts {:d} iteration {:d} (in current ts: {:d}) try {:d} accepted",
305
307
309}
std::unique_ptr< GlobalVector > _x_previous_timestep
Definition TESProcess.h:97
void setLocalAccessibleVector(PETScVector const &x)
Definition LinAlg.cpp:27
NumLib::LocalToGlobalIndexMap::RowColumnIndices getRowColumnIndices(std::size_t const id, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< GlobalIndexType > &indices)
static void executeDereferenced(F const &f, C const &c, Args_ &&... args)
std::size_t timestep
Output global matrix/rhs after first iteration.

References _assembly_params, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _x_previous_timestep, ProcessLib::TrafoScale::constrained, DBUG(), NumLib::SerialExecutor::executeDereferenced(), MathLib::EigenVector::get(), NumLib::getRowColumnIndices(), ProcessLib::TES::AssemblyParams::iteration_in_current_timestep, ProcessLib::TES::AssemblyParams::number_of_try_of_iteration, NumLib::REPEAT_ITERATION, MathLib::LinAlg::setLocalAccessibleVector(), NumLib::SUCCESS, ProcessLib::TES::AssemblyParams::timestep, and ProcessLib::TES::AssemblyParams::total_iteration.

◆ preIterationConcreteProcess()

◆ preTimestepConcreteProcess()

void ProcessLib::TES::TESProcess::preTimestepConcreteProcess ( std::vector< GlobalVector * > const & x,
const double t,
const double delta_t,
const int process_id )
overridevirtual

Member Data Documentation

◆ _assembly_params

◆ _local_assemblers

std::vector<std::unique_ptr<TESLocalAssemblerInterface> > ProcessLib::TES::TESProcess::_local_assemblers
private

◆ _x_previous_timestep

std::unique_ptr<GlobalVector> ProcessLib::TES::TESProcess::_x_previous_timestep
private

Definition at line 97 of file TESProcess.h.

Referenced by postIterationConcreteProcess(), and preTimestepConcreteProcess().


The documentation for this class was generated from the following files: