Detailed Description

template<int DisplacementDim>
class ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >

Thermally induced deformation process in linear kinematics poro-mechanical/biphasic model.

The mixture momentum balance, the mixture mass balance and the mixture energy balance are solved under fully saturated conditions.

Definition at line 29 of file ThermoHydroMechanicsProcess.h.

#include <ThermoHydroMechanicsProcess.h>

Inheritance diagram for ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >:

[legend]

Collaboration diagram for ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >:

[legend]

Public Member Functions
	ThermoHydroMechanicsProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::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, ThermoHydroMechanicsProcessData< DisplacementDim > &&process_data, SecondaryVariableCollection &&secondary_variables, bool const use_monolithic_scheme)

MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override

ODESystem interface
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. More...

void	postTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep. More...

void	postNonLinearSolver (GlobalVector const &x, GlobalVector const &xdot, 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_dot, int const process_id)
	compute secondary variables for the coupled equations or for output. More...

NumLib::IterationResult	postIteration (GlobalVector const &x) final

void	initialize ()

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	setCoupledSolutionsForStaggeredScheme (CoupledSolutionsForStaggeredScheme *const coupled_solutions)

void	updateDeactivatedSubdomains (double const time, const int process_id)

bool	isMonolithicSchemeUsed () const

virtual void	setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int 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 &xdot, 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 &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) final

std::vector< NumLib::IndexValueVector< GlobalIndexType > > const *	getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final

MeshLib::Mesh &	getMesh () const

std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const

SecondaryVariableCollection const &	getSecondaryVariables () const

std::vector< std::unique_ptr< IntegrationPointWriter > > const *	getIntegrationPointWriter (MeshLib::Mesh const &mesh) 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)

Private Member Functions
void	constructDofTable () override

void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
	Process specific initialization called by initialize(). More...

void	initializeBoundaryConditions () override

void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) override

void	assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) override

void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, double const t, double const dt, const int process_id) override

void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, const double t, const double dt, int const process_id) override

void	postNonLinearSolverConcreteProcess (GlobalVector const &x, GlobalVector const &xdot, const double t, double const dt, int const process_id) override

NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int process_id) const override

void	computeSecondaryVariableConcrete (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_dot, const int process_id) override

std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const override

bool	hasMechanicalProcess (int const process_id) const

Private Attributes
std::vector< MeshLib::Node * >	_base_nodes

std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_base_nodes

ThermoHydroMechanicsProcessData< DisplacementDim >	_process_data

std::vector< std::unique_ptr< LocalAssemblerInterface > >	_local_assemblers

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map_single_component

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map_with_base_nodes

GlobalSparsityPattern	_sparsity_pattern_with_linear_element

MeshLib::PropertyVector< double > *	_nodal_forces = nullptr

MeshLib::PropertyVector< double > *	_hydraulic_flow = nullptr

MeshLib::PropertyVector< double > *	_heat_flux = nullptr

Additional Inherited Members
Public Types inherited from ProcessLib::Process
using	NonlinearSolver = NumLib::NonlinearSolverBase

using	TimeDiscretization = NumLib::TimeDiscretization

Public Attributes inherited from ProcessLib::Process
std::string const	name

Protected Member Functions inherited from ProcessLib::Process
NumLib::Extrapolator &	getExtrapolator () const

NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const

void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id)

void	constructMonolithicProcessDofTable ()

void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_prosess_id)

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

VectorMatrixAssembler	_global_assembler

const bool	_use_monolithic_scheme

CoupledSolutionsForStaggeredScheme *	_coupled_solutions

unsigned const	_integration_order

std::vector< std::unique_ptr< 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

◆ ThermoHydroMechanicsProcess()

template<int DisplacementDim>

ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::ThermoHydroMechanicsProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::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,
		ThermoHydroMechanicsProcessData< DisplacementDim > &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		bool const	use_monolithic_scheme
	)

Definition at line 27 of file ThermoHydroMechanicsProcess.cpp.

     : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), use_monolithic_scheme),
       _process_data(std::move(process_data))
 {
     _nodal_forces = MeshLib::getOrCreateMeshProperty<double>(
         mesh, "NodalForces", MeshLib::MeshItemType::Node, DisplacementDim);
  
     _hydraulic_flow = MeshLib::getOrCreateMeshProperty<double>(
         mesh, "HydraulicFlow", MeshLib::MeshItemType::Node, 1);
  
     _heat_flux = MeshLib::getOrCreateMeshProperty<double>(
         mesh, "HeatFlux", MeshLib::MeshItemType::Node, 1);
  
     _integration_point_writer.emplace_back(
         std::make_unique<IntegrationPointWriter>(
             "sigma_ip",
             static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
             integration_order, _local_assemblers,
             &LocalAssemblerInterface::getSigma));
  
     _integration_point_writer.emplace_back(
         std::make_unique<IntegrationPointWriter>(
             "epsilon_ip",
             static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
             integration_order, _local_assemblers,
             &LocalAssemblerInterface::getEpsilon));
 }

References ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_heat_flux, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_hydraulic_flow, ProcessLib::Process::_integration_point_writer, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_local_assemblers, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_nodal_forces, MeshLib::Mesh::getDimension(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface::getEpsilon(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface::getSigma(), and MeshLib::Node.

Member Function Documentation

◆ assembleConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 308 of file ThermoHydroMechanicsProcess.cpp.

 {
     DBUG("Assemble the equations for ThermoHydroMechanics");
  
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_table = {std::ref(*_local_to_global_index_map)};
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
         pv.getActiveElementIDs(), dof_table, t, dt, x, xdot, process_id, M, K,
         b);
 }

References ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::ProcessVariable::getActiveElementIDs().

◆ assembleWithJacobianConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		const double	dxdot_dx,
		const double	dx_dx,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b,
		GlobalMatrix &	Jac
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 327 of file ThermoHydroMechanicsProcess.cpp.

 {
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_tables;
     // For the monolithic scheme
     if (_use_monolithic_scheme)
     {
         DBUG(
             "Assemble the Jacobian of ThermoHydroMechanics for the monolithic "
             "scheme.");
         dof_tables.emplace_back(*_local_to_global_index_map);
     }
     else
     {
         // For the staggered scheme
         if (process_id == 0)
         {
             DBUG(
                 "Assemble the Jacobian equations of heat transport process in "
                 "ThermoHydroMechanics for the staggered scheme.");
         }
         else if (process_id == 1)
         {
             DBUG(
                 "Assemble the Jacobian equations of liquid fluid process in "
                 "ThermoHydroMechanics for the staggered scheme.");
         }
         else
         {
             DBUG(
                 "Assemble the Jacobian equations of mechanical process in "
                 "ThermoHydroMechanics for the staggered scheme.");
         }
         dof_tables.emplace_back(*_local_to_global_index_map_with_base_nodes);
         dof_tables.emplace_back(*_local_to_global_index_map_with_base_nodes);
         dof_tables.emplace_back(*_local_to_global_index_map);
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
         _local_assemblers, pv.getActiveElementIDs(), dof_tables, t, dt, x, xdot,
         dxdot_dx, dx_dx, process_id, M, K, b, Jac);
  
     auto copyRhs = [&](int const variable_id, auto& output_vector)
     {
         if (_use_monolithic_scheme)
         {
             transformVariableFromGlobalVector(b, variable_id, dof_tables[0],
                                               output_vector,
                                               std::negate<double>());
         }
         else
         {
             transformVariableFromGlobalVector(b, 0, dof_tables[process_id],
                                               output_vector,
                                               std::negate<double>());
         }
     };
     if (_use_monolithic_scheme || process_id == 0)
     {
         copyRhs(0, *_heat_flux);
     }
     if (_use_monolithic_scheme || process_id == 1)
     {
         copyRhs(1, *_hydraulic_flow);
     }
     if (_use_monolithic_scheme || process_id == 2)
     {
         copyRhs(2, *_nodal_forces);
     }
 }

References ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and NumLib::transformVariableFromGlobalVector().

◆ computeSecondaryVariableConcrete()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::computeSecondaryVariableConcrete	(	double const	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		GlobalVector const &	x_dot,
		const int	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 474 of file ThermoHydroMechanicsProcess.cpp.

 {
     if (process_id != 0)
     {
         return;
     }
  
     DBUG("Compute the secondary variables for ThermoHydroMechanicsProcess.");
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     auto const n_processes = x.size();
     dof_tables.reserve(n_processes);
     for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
     {
         dof_tables.push_back(&getDOFTable(process_id));
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::computeSecondaryVariable, _local_assemblers,
         pv.getActiveElementIDs(), dof_tables, t, dt, x, x_dot, process_id);
 }

References ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), and ProcessLib::ProcessVariable::getActiveElementIDs().

◆ constructDofTable()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable

overrideprivatevirtual

This function is for general cases, in which all equations of the coupled processes have the same number of unknowns. For the general cases with the staggered scheme, all equations of the coupled processes share one DOF table hold by _local_to_global_index_map. Other cases can be considered by overloading this member function in the derived class.

Reimplemented from ProcessLib::Process.

Definition at line 94 of file ThermoHydroMechanicsProcess.cpp.

 {
     // Create single component dof in every of the mesh's nodes.
     _mesh_subset_all_nodes =
         std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
     // Create single component dof in the mesh's base nodes.
     _base_nodes = MeshLib::getBaseNodes(_mesh.getElements());
     _mesh_subset_base_nodes =
         std::make_unique<MeshLib::MeshSubset>(_mesh, _base_nodes);
  
     // TODO move the two data members somewhere else.
     // for extrapolation of secondary variables of stress or strain
     std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component{
         *_mesh_subset_all_nodes};
     _local_to_global_index_map_single_component =
         std::make_unique<NumLib::LocalToGlobalIndexMap>(
             std::move(all_mesh_subsets_single_component),
             // by location order is needed for output
             NumLib::ComponentOrder::BY_LOCATION);
  
     if (_use_monolithic_scheme)
     {
         // For temperature, which is the first
         std::vector<MeshLib::MeshSubset> all_mesh_subsets{
             *_mesh_subset_base_nodes};
  
         // For pressure, which is the second
         all_mesh_subsets.push_back(*_mesh_subset_base_nodes);
  
         // For displacement.
         const int monolithic_process_id = 0;
         std::generate_n(std::back_inserter(all_mesh_subsets),
                         getProcessVariables(monolithic_process_id)[2]
                             .get()
                             .getNumberOfGlobalComponents(),
                         [&]() { return *_mesh_subset_all_nodes; });
  
         std::vector<int> const vec_n_components{1, 1, DisplacementDim};
         _local_to_global_index_map =
             std::make_unique<NumLib::LocalToGlobalIndexMap>(
                 std::move(all_mesh_subsets), vec_n_components,
                 NumLib::ComponentOrder::BY_LOCATION);
         assert(_local_to_global_index_map);
     }
     else
     {
         // For displacement equation.
         const int process_id = 2;
         std::vector<MeshLib::MeshSubset> all_mesh_subsets;
         std::generate_n(std::back_inserter(all_mesh_subsets),
                         getProcessVariables(process_id)[0]
                             .get()
                             .getNumberOfGlobalComponents(),
                         [&]() { return *_mesh_subset_all_nodes; });
  
         std::vector<int> const vec_n_components{DisplacementDim};
         _local_to_global_index_map =
             std::make_unique<NumLib::LocalToGlobalIndexMap>(
                 std::move(all_mesh_subsets), vec_n_components,
                 NumLib::ComponentOrder::BY_LOCATION);
  
         // For pressure equation or temperature equation.
         // Collect the mesh subsets with base nodes in a vector.
         std::vector<MeshLib::MeshSubset> all_mesh_subsets_base_nodes{
             *_mesh_subset_base_nodes};
         _local_to_global_index_map_with_base_nodes =
             std::make_unique<NumLib::LocalToGlobalIndexMap>(
                 std::move(all_mesh_subsets_base_nodes),
                 // by location order is needed for output
                 NumLib::ComponentOrder::BY_LOCATION);
  
         _sparsity_pattern_with_linear_element = NumLib::computeSparsityPattern(
             *_local_to_global_index_map_with_base_nodes, _mesh);
  
         assert(_local_to_global_index_map);
         assert(_local_to_global_index_map_with_base_nodes);
     }
 }

References NumLib::BY_LOCATION, NumLib::computeSparsityPattern(), and MeshLib::getBaseNodes().

◆ getDOFTable()

template<int DisplacementDim>

NumLib::LocalToGlobalIndexMap const & ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::getDOFTable ( const int process_id ) const

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 511 of file ThermoHydroMechanicsProcess.cpp.

 {
     if (hasMechanicalProcess(process_id))
     {
         return *_local_to_global_index_map;
     }
  
     // For the equation of pressure
     return *_local_to_global_index_map_with_base_nodes;
 }

◆ getDOFTableForExtrapolatorData()

template<int DisplacementDim>

std::tuple< NumLib::LocalToGlobalIndexMap *, bool > ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::getDOFTableForExtrapolatorData

overrideprivatevirtual

Get the address of a LocalToGlobalIndexMap, and the status of its memory. If the LocalToGlobalIndexMap is created as new in this function, the function also returns a true boolean value to let Extrapolator manage the memory by the address returned by this function.

Returns: Address of a LocalToGlobalIndexMap and its memory status.

Reimplemented from ProcessLib::Process.

Definition at line 502 of file ThermoHydroMechanicsProcess.cpp.

 {
     const bool manage_storage = false;
     return std::make_tuple(_local_to_global_index_map_single_component.get(),
                            manage_storage);
 }

◆ getMatrixSpecifications()

template<int DisplacementDim>

MathLib::MatrixSpecifications ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::getMatrixSpecifications ( const int process_id ) const

override

Get the size and the sparse pattern of the global matrix in order to create the global matrices and vectors for the system equations of this process.

Parameters

process_id Process ID. If the monolithic scheme is applied, process_id = 0. For the staggered scheme, process_id = 0 represents the hydraulic (H) process, while process_id = 1 represents the mechanical (M) process.

Returns: Matrix specifications including size and sparse pattern.

Definition at line 75 of file ThermoHydroMechanicsProcess.cpp.

 {
     // For the monolithic scheme or the M process (deformation) in the staggered
     // scheme.
     if (_use_monolithic_scheme || process_id == 2)
     {
         auto const& l = *_local_to_global_index_map;
         return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
                 &l.getGhostIndices(), &this->_sparsity_pattern};
     }
  
     // For staggered scheme and T or H process (pressure).
     auto const& l = *_local_to_global_index_map_with_base_nodes;
     return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
             &l.getGhostIndices(), &_sparsity_pattern_with_linear_element};
 }

◆ hasMechanicalProcess()

template<int DisplacementDim>

bool ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::hasMechanicalProcess ( int const process_id ) const

inlineprivate

Check whether the process represented by process_id is/has mechanical process. In the present implementation, the mechanical process has process_id == 1 in the staggered scheme.

Definition at line 137 of file ThermoHydroMechanicsProcess.h.

     {
         return _use_monolithic_scheme || process_id == 2;
     }

References ProcessLib::Process::_use_monolithic_scheme.

◆ initializeBoundaryConditions()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeBoundaryConditions

overrideprivatevirtual

Member function to initialize the boundary conditions for all coupled processes. It is called by initialize().

Reimplemented from ProcessLib::Process.

Definition at line 280 of file ThermoHydroMechanicsProcess.cpp.

 {
     if (_use_monolithic_scheme)
     {
         const int process_id_of_thermohydromechancs = 0;
         initializeProcessBoundaryConditionsAndSourceTerms(
             *_local_to_global_index_map, process_id_of_thermohydromechancs);
         return;
     }
  
     // Staggered scheme:
     // for the equations of heat transport
     const int thermal_process_id = 0;
     initializeProcessBoundaryConditionsAndSourceTerms(
         *_local_to_global_index_map_with_base_nodes, thermal_process_id);
  
     // for the equations of mass balance
     const int hydraulic_process_id = 1;
     initializeProcessBoundaryConditionsAndSourceTerms(
         *_local_to_global_index_map_with_base_nodes, hydraulic_process_id);
  
     // for the equations of deformation.
     const int mechanical_process_id = 2;
     initializeProcessBoundaryConditionsAndSourceTerms(
         *_local_to_global_index_map, mechanical_process_id);
 }

◆ initializeConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::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 174 of file ThermoHydroMechanicsProcess.cpp.

 {
     const int mechanical_process_id = _use_monolithic_scheme ? 0 : 2;
     const int deformation_variable_id = _use_monolithic_scheme ? 2 : 0;
     ProcessLib::ThermoHydroMechanics::createLocalAssemblers<
         DisplacementDim, ThermoHydroMechanicsLocalAssembler>(
         mesh.getDimension(), mesh.getElements(), dof_table,
         // use displacement process variable to set shape function order
         getProcessVariables(mechanical_process_id)[deformation_variable_id]
             .get()
             .getShapeFunctionOrder(),
         _local_assemblers, mesh.isAxiallySymmetric(), integration_order,
         _process_data);
  
     _secondary_variables.addSecondaryVariable(
         "sigma",
         makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                              DisplacementDim>::RowsAtCompileTime,
                          getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtSigma));
  
     _secondary_variables.addSecondaryVariable(
         "epsilon",
         makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                              DisplacementDim>::RowsAtCompileTime,
                          getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtEpsilon));
  
     _secondary_variables.addSecondaryVariable(
         "velocity",
         makeExtrapolator(mesh.getDimension(), getExtrapolator(),
                          _local_assemblers,
                          &LocalAssemblerInterface::getIntPtDarcyVelocity));
  
     _process_data.pressure_interpolated =
         MeshLib::getOrCreateMeshProperty<double>(
             const_cast<MeshLib::Mesh&>(mesh), "pressure_interpolated",
             MeshLib::MeshItemType::Node, 1);
  
     _process_data.temperature_interpolated =
         MeshLib::getOrCreateMeshProperty<double>(
             const_cast<MeshLib::Mesh&>(mesh), "temperature_interpolated",
             MeshLib::MeshItemType::Node, 1);
  
     // Set initial conditions for integration point data.
     for (auto const& ip_writer : _integration_point_writer)
     {
         // Find the mesh property with integration point writer's name.
         auto const& name = ip_writer->name();
         if (!mesh.getProperties().existsPropertyVector<double>(name))
         {
             continue;
         }
         auto const& mesh_property =
             *mesh.getProperties().template getPropertyVector<double>(name);
  
         // The mesh property must be defined on integration points.
         if (mesh_property.getMeshItemType() !=
             MeshLib::MeshItemType::IntegrationPoint)
         {
             continue;
         }
  
         auto const ip_meta_data = getIntegrationPointMetaData(mesh, name);
  
         // Check the number of components.
         if (ip_meta_data.n_components !=
             mesh_property.getNumberOfGlobalComponents())
         {
             OGS_FATAL(
                 "Different number of components in meta data ({:d}) than in "
                 "the integration point field data for '{:s}': {:d}.",
                 ip_meta_data.n_components, name,
                 mesh_property.getNumberOfGlobalComponents());
         }
  
         // Now we have a properly named vtk's field data array and the
         // corresponding meta data.
         std::size_t position = 0;
         for (auto& local_asm : _local_assemblers)
         {
             std::size_t const integration_points_read =
                 local_asm->setIPDataInitialConditions(
                     name, &mesh_property[position],
                     ip_meta_data.integration_order);
             if (integration_points_read == 0)
             {
                 OGS_FATAL(
                     "No integration points read in the integration point "
                     "initial conditions set function.");
             }
             position += integration_points_read * ip_meta_data.n_components;
         }
     }
  
     // Initialize local assemblers after all variables have been set.
     GlobalExecutor::executeMemberOnDereferenced(
         &LocalAssemblerInterface::initialize, _local_assemblers,
         *_local_to_global_index_map);
 }

References ProcessLib::ThermoHydroMechanics::createLocalAssemblers(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), ProcessLib::getIntegrationPointMetaData(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface::getIntPtEpsilon(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface::getIntPtSigma(), MeshLib::Mesh::getProperties(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::IntegrationPoint, MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), MaterialPropertyLib::name, MeshLib::Node, and OGS_FATAL.

◆ isLinear()

template<int DisplacementDim>

bool ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::isLinear

override

Definition at line 68 of file ThermoHydroMechanicsProcess.cpp.

 {
     return false;
 }

◆ postNonLinearSolverConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::postNonLinearSolverConcreteProcess	(	GlobalVector const &	x,
		GlobalVector const &	xdot,
		const double	t,
		double const	dt,
		int const	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 452 of file ThermoHydroMechanicsProcess.cpp.

 {
     if (!hasMechanicalProcess(process_id))
     {
         return;
     }
  
     DBUG("PostNonLinearSolver ThermoHydroMechanicsProcess.");
     // Calculate strain, stress or other internal variables of mechanics.
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::postNonLinearSolver, _local_assemblers,
         pv.getActiveElementIDs(), getDOFTable(process_id), x, xdot, t, dt,
         _use_monolithic_scheme, process_id);
 }

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::LocalAssemblerInterface::postNonLinearSolver().

◆ postTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	x,
		const double	t,
		const double	dt,
		int const	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 426 of file ThermoHydroMechanicsProcess.cpp.

 {
     if (process_id != 0)
     {
         return;
     }
  
     DBUG("PostTimestep ThermoHydroMechanicsProcess.");
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     auto const n_processes = x.size();
     dof_tables.reserve(n_processes);
     for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
     {
         dof_tables.push_back(&getDOFTable(process_id));
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::postTimestep, _local_assemblers,
         pv.getActiveElementIDs(), dof_tables, x, t, dt);
 }

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::LocalAssemblerInterface::postTimestep().

◆ preTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::preTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	x,
		double const	t,
		double const	dt,
		const int	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 407 of file ThermoHydroMechanicsProcess.cpp.

 {
     DBUG("PreTimestep ThermoHydroMechanicsProcess.");
  
     if (hasMechanicalProcess(process_id))
     {
         ProcessLib::ProcessVariable const& pv =
             getProcessVariables(process_id)[0];
  
         GlobalExecutor::executeSelectedMemberOnDereferenced(
             &LocalAssemblerInterface::preTimestep, _local_assemblers,
             pv.getActiveElementIDs(), *_local_to_global_index_map,
             *x[process_id], t, dt);
     }
 }