ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim > Class Template Reference

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 23 of file ThermoHydroMechanicsProcess.h.

#include <ThermoHydroMechanicsProcess.h>

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

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

Public Member Functions
THERMOHYDROMECHANICS_EXPORT	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, bool const is_linear)
THERMOHYDROMECHANICS_EXPORT MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override
ODESystem interface
THERMOHYDROMECHANICS_EXPORT 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, 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
MeshLib::Mesh &	getMesh () const
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &	getProcessVariables () 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)
bool	requiresNormalization () const override
Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual	~SubmeshAssemblySupport ()=default

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().
void	initializeBoundaryConditions (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media) override
void	setInitialConditionsConcreteProcess (std::vector< GlobalVector * > &x, double const t, int const process_id) override
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	assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, 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, std::vector< GlobalVector * > const &x_prev, const double t, const double dt, int const process_id) override
std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes) override
THERMOHYDROMECHANICS_EXPORT 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_prev, const int process_id) override
std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const override
bool	hasMechanicalProcess (int const process_id) const
Private Member Functions inherited from ProcessLib::AssemblyMixin< ThermoHydroMechanicsProcess< DisplacementDim > >
void	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names)
void	updateActiveElements ()
void	assemble (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, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	assembleWithJacobian (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	preOutput (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)

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< DisplacementDim > > >	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

Friends
class	AssemblyMixin< ThermoHydroMechanicsProcess< DisplacementDim > >

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::Extrapolator &	getExtrapolator () 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)
void	constructMonolithicProcessDofTable ()
void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override
void	setReleaseNodalForces (GlobalVector const *r_neq, int const process_id) 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

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,
		bool const	is_linear )

Definition at line 23 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),
      AssemblyMixin<ThermoHydroMechanicsProcess<DisplacementDim>>{
          *_jacobian_assembler, is_linear, use_monolithic_scheme},
      _process_data(std::move(process_data))
 
{
    // For numerical Jacobian
    if (this->_jacobian_assembler->isPerturbationEnabled())
    {
        OGS_FATAL(
            "Numerical Jacobian is not supported for the "
            "ThermoHydroMechanicsProcess yet.");
    }
 
    _integration_point_writer.emplace_back(
        std::make_unique<MeshLib::IntegrationPointWriter>(
            "sigma_ip",
            static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
            integration_order, local_assemblers_,
            &LocalAssemblerInterface<DisplacementDim>::getSigma));
 
    _integration_point_writer.emplace_back(
        std::make_unique<MeshLib::IntegrationPointWriter>(
            "sigma_ice_ip",
            static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
            integration_order, local_assemblers_,
            &LocalAssemblerInterface<DisplacementDim>::getSigmaIce));
 
    _integration_point_writer.emplace_back(
        std::make_unique<MeshLib::IntegrationPointWriter>(
            "ice_volume_fraction_ip", 1, integration_order, local_assemblers_,
            &LocalAssemblerInterface<DisplacementDim>::getIceVolumeFraction));
    _integration_point_writer.emplace_back(
        std::make_unique<MeshLib::IntegrationPointWriter>(
            "epsilon_m_ip",
            static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
            integration_order, local_assemblers_,
            &LocalAssemblerInterface<DisplacementDim>::getEpsilonM));
 
    _integration_point_writer.emplace_back(
        std::make_unique<MeshLib::IntegrationPointWriter>(
            "epsilon_ip",
            static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
            integration_order, local_assemblers_,
            &LocalAssemblerInterface<DisplacementDim>::getEpsilon));
}

References ProcessLib::Process::Process(), ThermoHydroMechanicsProcess(), ProcessLib::Process::_jacobian_assembler, and ProcessLib::Process::name.

Referenced by ThermoHydroMechanicsProcess(), AssemblyMixin< ThermoHydroMechanicsProcess< DisplacementDim > >, and isLinear().

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 & x_prev, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 360 of file ThermoHydroMechanicsProcess.cpp.

{
    DBUG("Assemble the equations for ThermoHydroMechanics");
 
    AssemblyMixin<ThermoHydroMechanicsProcess<DisplacementDim>>::assemble(
        t, dt, x, x_prev, process_id, M, K, b);
}

References ProcessLib::Process::assemble(), and DBUG().

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 & x_prev, int const process_id, GlobalVector & b, GlobalMatrix & Jac )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 372 of file ThermoHydroMechanicsProcess.cpp.

{
    // For the monolithic scheme
    if (_use_monolithic_scheme)
    {
        DBUG(
            "Assemble the Jacobian of ThermoHydroMechanics for the monolithic "
            "scheme.");
    }
    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.");
        }
    }
 
    AssemblyMixin<ThermoHydroMechanicsProcess<DisplacementDim>>::
        assembleWithJacobian(t, dt, x, x_prev, process_id, b, Jac);
}

References ProcessLib::Process::_use_monolithic_scheme, and DBUG().

computeSecondaryVariableConcrete()

template<int DisplacementDim>

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

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 480 of file ThermoHydroMechanicsProcess.cpp.

{
    if (process_id != 0)
    {
        return;
    }
 
    DBUG("Compute the secondary variables for ThermoHydroMechanicsProcess.");
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface<DisplacementDim>::computeSecondaryVariable,
        local_assemblers_, getActiveElementIDs(), getDOFTables(x.size()), t, dt,
        x, x_prev, process_id);
}

References ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), ProcessLib::Process::getDOFTables(), and local_assemblers_.

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 110 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 _base_nodes, ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, _local_to_global_index_map_with_base_nodes, ProcessLib::Process::_mesh, ProcessLib::Process::_mesh_subset_all_nodes, _mesh_subset_base_nodes, _sparsity_pattern_with_linear_element, ProcessLib::Process::_use_monolithic_scheme, NumLib::BY_LOCATION, NumLib::computeSparsityPattern(), MeshLib::getBaseNodes(), and ProcessLib::Process::getProcessVariables().

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 510 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;
}

References ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_with_base_nodes, and hasMechanicalProcess().

getDOFTableForExtrapolatorData()

template<int DisplacementDim>

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

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 501 of file ThermoHydroMechanicsProcess.cpp.

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

References _local_to_global_index_map_single_component, and getDOFTableForExtrapolatorData().

Referenced by getDOFTableForExtrapolatorData().

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 91 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};
}

References ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_with_base_nodes, ProcessLib::Process::_sparsity_pattern, _sparsity_pattern_with_linear_element, and ProcessLib::Process::_use_monolithic_scheme.

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 140 of file ThermoHydroMechanicsProcess.h.

    {
        return _use_monolithic_scheme || process_id == 2;
    }

References ProcessLib::Process::_use_monolithic_scheme.

Referenced by getDOFTable(), and preTimestepConcreteProcess().

initializeAssemblyOnSubmeshes()

template<int DisplacementDim>

std::vector< std::vector< std::string > > ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeAssemblyOnSubmeshes ( std::vector< std::reference_wrapper< MeshLib::Mesh > > const & meshes )

overrideprivatevirtual

Initializes the assembly on submeshes

Parameters

meshes

the submeshes on whom the assembly shall proceed.

Attention

meshes must be a must be a non-overlapping cover of the entire simulation domain (bulk mesh)!

Returns

The names of the residuum vectors that will be assembled for each process: outer vector of size 1 for monolithic schemes and greater for staggered schemes.

Reimplemented from ProcessLib::SubmeshAssemblySupport.

Definition at line 452 of file ThermoHydroMechanicsProcess.cpp.

{
    INFO("ThermoHydroMechanicsProcess process initializeSubmeshOutput().");
    std::vector<std::vector<std::string>> per_process_residuum_names;
 
    std::string const flow_rate_name =
        _process_data.is_volume_balance_equation_type ? "VolumetricFlowRate"
                                                      : "MassFlowRate";
 
    if (_process_variables.size() == 1)  // monolithic
    {
        per_process_residuum_names = {
            {"HeatFlowRate", flow_rate_name, "NodalForces"}};
    }
    else  // staggered
    {
        per_process_residuum_names = {
            {"HeatFlowRate"}, {flow_rate_name}, {"NodalForces"}};
    }
 
    AssemblyMixin<ThermoHydroMechanicsProcess<DisplacementDim>>::
        initializeAssemblyOnSubmeshes(meshes, per_process_residuum_names);
 
    return per_process_residuum_names;
}

References _process_data, ProcessLib::Process::_process_variables, and INFO().

initializeBoundaryConditions()

template<int DisplacementDim>

void ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeBoundaryConditions ( std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & media )

overrideprivatevirtual

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

Reimplemented from ProcessLib::Process.

Definition at line 316 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,
            media);
        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, media);
 
    // for the equations of mass balance
    const int hydraulic_process_id = 1;
    initializeProcessBoundaryConditionsAndSourceTerms(
        *_local_to_global_index_map_with_base_nodes, hydraulic_process_id,
        media);
 
    // for the equations of deformation.
    const int mechanical_process_id = 2;
    initializeProcessBoundaryConditionsAndSourceTerms(
        *_local_to_global_index_map, mechanical_process_id, media);
}

References ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_with_base_nodes, ProcessLib::Process::_use_monolithic_scheme, and ProcessLib::Process::initializeProcessBoundaryConditionsAndSourceTerms().

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 190 of file ThermoHydroMechanicsProcess.cpp.

{
    ProcessLib::createLocalAssemblersHM<DisplacementDim,
                                        ThermoHydroMechanicsLocalAssembler>(
        mesh.getElements(), dof_table, local_assemblers_,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _process_data);
 
    auto add_secondary_variable = [&](std::string const& name,
                                      int const num_components,
                                      auto get_ip_values_function)
    {
        _secondary_variables.addSecondaryVariable(
            name,
            makeExtrapolator(num_components, getExtrapolator(),
                             local_assemblers_,
                             std::move(get_ip_values_function)));
    };
 
    add_secondary_variable(
        "sigma",
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtSigma);
 
    add_secondary_variable(
        "sigma_ice",
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtSigmaIce);
 
    add_secondary_variable(
        "epsilon_0",
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtEpsilon0);
 
    add_secondary_variable(
        "epsilon_m",
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtEpsilonM);
 
    add_secondary_variable(
        "epsilon",
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtEpsilon);
 
    add_secondary_variable(
        "ice_volume_fraction", 1,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtIceVolume);
 
    add_secondary_variable(
        "velocity", mesh.getDimension(),
        &LocalAssemblerInterface<DisplacementDim>::getIntPtDarcyVelocity);
 
    add_secondary_variable(
        "fluid_density", 1,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtFluidDensity);
 
    add_secondary_variable(
        "viscosity", 1,
        &LocalAssemblerInterface<DisplacementDim>::getIntPtViscosity);
 
    _process_data.element_phi_fr = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(mesh), "ice_volume_fraction_avg",
        MeshLib::MeshItemType::Cell, 1);
 
    _process_data.element_fluid_density =
        MeshLib::getOrCreateMeshProperty<double>(
            const_cast<MeshLib::Mesh&>(mesh), "fluid_density_avg",
            MeshLib::MeshItemType::Cell, 1);
 
    _process_data.element_viscosity = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(mesh), "viscosity_avg",
        MeshLib::MeshItemType::Cell, 1);
 
    _process_data.element_stresses = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(mesh), "stress_avg",
        MeshLib::MeshItemType::Cell,
        MathLib::KelvinVector::KelvinVectorType<
            DisplacementDim>::RowsAtCompileTime);
 
    _process_data.element_ice_stresses =
        MeshLib::getOrCreateMeshProperty<double>(
            const_cast<MeshLib::Mesh&>(mesh), "sigma_ice_avg",
            MeshLib::MeshItemType::Cell,
            MathLib::KelvinVector::KelvinVectorType<
                DisplacementDim>::RowsAtCompileTime);
 
    _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);
 
    //
    // enable output of internal variables defined by material models
    //
    ProcessLib::Deformation::solidMaterialInternalToSecondaryVariables<
        LocalAssemblerInterface<DisplacementDim>>(_process_data.solid_materials,
                                                  add_secondary_variable);
 
    ProcessLib::Deformation::
        solidMaterialInternalVariablesToIntegrationPointWriter(
            _process_data.solid_materials, local_assemblers_,
            _integration_point_writer, integration_order);
 
    setIPDataInitialConditions(_integration_point_writer, mesh.getProperties(),
                               local_assemblers_);
 
    // Initialize local assemblers after all variables have been set.
    GlobalExecutor::executeMemberOnDereferenced(
        &LocalAssemblerInterface<DisplacementDim>::initialize,
        local_assemblers_, *_local_to_global_index_map);
}

References ProcessLib::Process::_integration_point_writer, ProcessLib::Process::_local_to_global_index_map, _process_data, ProcessLib::Process::_secondary_variables, MeshLib::Cell, ProcessLib::createLocalAssemblersHM(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtDarcyVelocity(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtEpsilon(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtEpsilon0(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtEpsilonM(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtFluidDensity(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtIceVolume(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtSigma(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtSigmaIce(), ProcessLib::ThermoHydroMechanics::LocalAssemblerInterface< DisplacementDim >::getIntPtViscosity(), MeshLib::getOrCreateMeshProperty(), MeshLib::Mesh::getProperties(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::Mesh::isAxiallySymmetric(), local_assemblers_, ProcessLib::makeExtrapolator(), ProcessLib::Process::name, MeshLib::Node, ProcessLib::setIPDataInitialConditions(), ProcessLib::Deformation::solidMaterialInternalToSecondaryVariables(), and ProcessLib::Deformation::solidMaterialInternalVariablesToIntegrationPointWriter().

isLinear()

template<int DisplacementDim>

bool ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::isLinear ( ) const

override

Definition at line 83 of file ThermoHydroMechanicsProcess.cpp.

{
    return AssemblyMixin<
        ThermoHydroMechanicsProcess<DisplacementDim>>::isLinear();
}

References ThermoHydroMechanicsProcess(), and isLinear().

Referenced by isLinear().

postTimestepConcreteProcess()

template<int DisplacementDim>

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

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 432 of file ThermoHydroMechanicsProcess.cpp.

{
    if (process_id != 0)
    {
        return;
    }
 
    DBUG("PostTimestep ThermoHydroMechanicsProcess.");
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface<DisplacementDim>::postTimestep,
        local_assemblers_, getActiveElementIDs(), getDOFTables(x.size()), x,
        x_prev, t, dt, process_id);
}

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), ProcessLib::Process::getDOFTables(), local_assemblers_, 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 413 of file ThermoHydroMechanicsProcess.cpp.

{
    DBUG("PreTimestep ThermoHydroMechanicsProcess.");
 
    if (hasMechanicalProcess(process_id))
    {
        GlobalExecutor::executeMemberOnDereferenced(
            &LocalAssemblerInterface<DisplacementDim>::preTimestep,
            local_assemblers_, *_local_to_global_index_map, *x[process_id], t,
            dt);
 
        AssemblyMixin<ThermoHydroMechanicsProcess<DisplacementDim>>::
            updateActiveElements();
    }
}

References ProcessLib::Process::_local_to_global_index_map, DBUG(), NumLib::SerialExecutor::executeMemberOnDereferenced(), hasMechanicalProcess(), local_assemblers_, and ProcessLib::LocalAssemblerInterface::preTimestep().

setInitialConditionsConcreteProcess()

template<int DisplacementDim>

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

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 347 of file ThermoHydroMechanicsProcess.cpp.

{
    DBUG("SetInitialConditions ThermoHydroMechanicsProcess.");
 
    GlobalExecutor::executeMemberOnDereferenced(
        &LocalAssemblerInterface<DisplacementDim>::setInitialConditions,
        local_assemblers_, getDOFTables(x.size()), x, t, process_id);
}

References DBUG(), NumLib::SerialExecutor::executeMemberOnDereferenced(), ProcessLib::Process::getDOFTables(), local_assemblers_, and ProcessLib::LocalAssemblerInterface::setInitialConditions().

Friends And Related Symbol Documentation

AssemblyMixin< ThermoHydroMechanicsProcess< DisplacementDim > >

template<int DisplacementDim>

friend class AssemblyMixin< ThermoHydroMechanicsProcess< DisplacementDim > >

friend

Definition at line 147 of file ThermoHydroMechanicsProcess.h.

References ThermoHydroMechanicsProcess().

Member Data Documentation

_base_nodes

template<int DisplacementDim>

std::vector<MeshLib::Node*> ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_base_nodes

private

Definition at line 108 of file ThermoHydroMechanicsProcess.h.

Referenced by constructDofTable().

_local_to_global_index_map_single_component

template<int DisplacementDim>

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_local_to_global_index_map_single_component

private

Definition at line 116 of file ThermoHydroMechanicsProcess.h.

Referenced by constructDofTable(), and getDOFTableForExtrapolatorData().

_local_to_global_index_map_with_base_nodes

template<int DisplacementDim>

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_local_to_global_index_map_with_base_nodes

private

Local to global index mapping for base nodes, which is used for linear interpolation for pressure in the staggered scheme.

Definition at line 121 of file ThermoHydroMechanicsProcess.h.

Referenced by constructDofTable(), getDOFTable(), getMatrixSpecifications(), and initializeBoundaryConditions().

_mesh_subset_base_nodes

template<int DisplacementDim>

std::unique_ptr<MeshLib::MeshSubset const> ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_mesh_subset_base_nodes

private

Definition at line 109 of file ThermoHydroMechanicsProcess.h.

Referenced by constructDofTable().

_process_data

template<int DisplacementDim>

ThermoHydroMechanicsProcessData<DisplacementDim> ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_process_data

private

Definition at line 110 of file ThermoHydroMechanicsProcess.h.

Referenced by initializeAssemblyOnSubmeshes(), and initializeConcreteProcess().

_sparsity_pattern_with_linear_element

template<int DisplacementDim>

GlobalSparsityPattern ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::_sparsity_pattern_with_linear_element

private

Sparsity pattern for the flow equation, and it is initialized only if the staggered scheme is used.

Definition at line 125 of file ThermoHydroMechanicsProcess.h.

Referenced by constructDofTable(), and getMatrixSpecifications().

local_assemblers_

template<int DisplacementDim>

std::vector<std::unique_ptr<LocalAssemblerInterface<DisplacementDim> > > ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::local_assemblers_

private

Definition at line 113 of file ThermoHydroMechanicsProcess.h.

Referenced by computeSecondaryVariableConcrete(), initializeConcreteProcess(), postTimestepConcreteProcess(), preTimestepConcreteProcess(), and setInitialConditionsConcreteProcess().

---

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

• ThermoHydroMechanicsProcess.h
• ThermoHydroMechanicsProcess.cpp