ProcessLib::HT::HTProcess Class Reference

Detailed Description

HT process

The implementation uses a monolithic approach, i.e., both processes are assembled within one global system of equations.

Process Coupling

The advective term of the heat conduction equation is given by the confined groundwater flow process, i.e., the heat conduction depends on darcy velocity of the groundwater flow process. On the other hand the temperature dependencies of the viscosity and density in the groundwater flow couples the H process to the T process.

Note

• At the moment there is no coupling by source or sink terms, i.e., the coupling is implemented only through density changes due to temperature changes in the buoyancy term of the groundwater flow. This coupling scheme is referred to as the Boussinesq approximation.
• The fluid phase contribution to the storage coefficient is computed from the fluid compressibility, i.e. \(\phi\frac{\partial \varrho_f}{\partial p}/\varrho_f\) with \(\phi\) the porosity, \(p\) the pore pressure, and \(\varrho_f\) the fluid density.
• The storage input parameter is for the solid phase only, and can be computed from the Biot coefficient \(\alpha_B\) and the drained bulk modulus \(K\) as \((\alpha_B-\phi)(1-\alpha_B)/K\). Equivalently, it is \((\alpha_B-\phi)/K_s\) with \(K_s=K/(1-\alpha_B)\) the intrinsic bulk modulus of the solid phase. Therefore, if the Biot coefficient is defined as one, the storage input parameter must be zero. This is enforced whenever \(\alpha_T^s\) is defined, since that is when \(\alpha_B\) is read at all: checkBiotStorageRelation() compares the evaluated values at the integration points of every element once during initialisation, at \(t=0\), which covers all properties independent of the primary variables and of the time, and evalEffectiveThermalExpansivity() compares them again at each integration point during assembly, which covers the remaining property types.
• The input parameters of the Biot coefficient \(\alpha_B\) and the solid thermal expansivity (linear) \(\alpha_T^s\) are optional. Only one direction is enforced: if \(\alpha_T^s\) is given, then \(\alpha_B\) must be given too, see checkThermalExpansivitySetting(). The reverse is not enforced, because \(\alpha_B\) is never read without \(\alpha_T^s\); it is then silently ignored. They are only used to compute the effective thermal expansivity, which is defined as:

  \[ 3(\alpha_B-\phi)\alpha_T^s - \phi \frac{\partial \varrho_f} {\partial T}/\varrho_f \]

  If they are not defined, the effective thermal expansivity is computed as \(-\phi \frac{\partial \varrho_f}{\partial T}/\varrho_f\).
• The storage term of the pressure equation is \(\phi\frac{\partial \varrho_f}{\partial p}/\varrho_f + S_s\) with \(S_s\) the storage input parameter. It does not contain the thermal expansivity, and therefore it vanishes exactly when the liquid density does not depend on the pressure and \(S_s\) is zero – for instance for a temperature-only density model combined with \(\alpha_B=1\), which forces \(S_s=0\). Such a setup is physically inconsistent and numerical instability can occur.
• The governing equation can be set to either a volume balance or a mass balance. The default is a volume balance. If the governing equation is set to a mass balance, the input of the fluid phase boundary and source/sink terms changes from a volume rate to a mass rate: the unit of the Neumann boundary condition is changed from \([m/s]\) to \([kg/(m^2\,s)]\), and the unit of the source/sink term from \([m^3/s]\) to \([kg/s]\).

Definition at line 95 of file HTProcess.h.

#include <HTProcess.h>

Inheritance diagram for ProcessLib::HT::HTProcess:

Collaboration diagram for ProcessLib::HT::HTProcess:

Public Member Functions
	HTProcess (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, HTProcessData &&process_data, SecondaryVariableCollection &&secondary_variables, bool const use_monolithic_scheme, std::unique_ptr< ProcessLib::SurfaceFluxData > &&surfaceflux)
Eigen::Vector3d	getFlux (std::size_t element_id, MathLib::Point3d const &p, double const t, std::vector< GlobalVector * > const &x) const override
void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id) 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.
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
virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const
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 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 std::vector< 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	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
std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const override

Private Attributes
HTProcessData	_process_data
std::vector< std::unique_ptr< HTLocalAssemblerInterface > >	_local_assemblers
std::unique_ptr< ProcessLib::SurfaceFluxData >	_surfaceflux

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)
virtual void	constructDofTable ()
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

HTProcess()

ProcessLib::HT::HTProcess::HTProcess	(	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,
		HTProcessData &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		bool const	use_monolithic_scheme,
		std::unique_ptr< ProcessLib::SurfaceFluxData > &&	surfaceflux )

Definition at line 21 of file HTProcess.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)),
      _surfaceflux(std::move(surfaceflux))
{
    this->_jacobian_assembler->checkPerturbationSize(2);
    if (_use_monolithic_scheme)
    {
        this->_jacobian_assembler->setNonDeformationComponentIDsNoSizeCheck(
            {0, 1} /* two variables: pressure and temperature */);
    }
}

References ProcessLib::Process::Process(), ProcessLib::Process::_jacobian_assembler, _process_data, _surfaceflux, ProcessLib::Process::_use_monolithic_scheme, and ProcessLib::Process::name.

Member Function Documentation

assembleConcreteProcess()

void ProcessLib::HT::HTProcess::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 79 of file HTProcess.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    if (_use_monolithic_scheme)
    {
        DBUG("Assemble HTProcess.");
        dof_tables.emplace_back(_local_to_global_index_map.get());
    }
    else
    {
        if (process_id == _process_data.heat_transport_process_id)
        {
            DBUG(
                "Assemble the equations of heat transport process within "
                "HTProcess.");
        }
        else
        {
            DBUG(
                "Assemble the equations of single phase fully saturated "
                "fluid flow process within HTProcess.");
        }
        dof_tables.emplace_back(_local_to_global_index_map.get());
        dof_tables.emplace_back(_local_to_global_index_map.get());
 
        // For numerical Jacobian assembler
        // (only one variable per process in staggered scheme);
        this->_jacobian_assembler->setNonDeformationComponentIDsNoSizeCheck(
            {process_id});
    }
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        getActiveElementIDs(), dof_tables, t, dt, x, x_prev, process_id, &M, &K,
        &b);
}

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

assembleWithJacobianConcreteProcess()

void ProcessLib::HT::HTProcess::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 120 of file HTProcess.cpp.

{
    DBUG("AssembleWithJacobian HTProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    if (!_use_monolithic_scheme)
    {
        dof_tables.emplace_back(_local_to_global_index_map.get());
    }
    else
    {
        dof_tables.emplace_back(_local_to_global_index_map.get());
        dof_tables.emplace_back(_local_to_global_index_map.get());
    }
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id, &b, &Jac);
}

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

getDOFTableForExtrapolatorData()

std::tuple< NumLib::LocalToGlobalIndexMap *, bool > ProcessLib::HT::HTProcess::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 146 of file HTProcess.cpp.

{
    if (!_use_monolithic_scheme)
    {
        // For single-variable-single-component processes reuse the existing DOF
        // table.
        const bool manage_storage = false;
        return std::make_tuple(_local_to_global_index_map.get(),
                               manage_storage);
    }
 
    // Otherwise construct a new DOF table.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component{
        *_mesh_subset_all_nodes};
 
    const bool manage_storage = true;
    return std::make_tuple(new NumLib::LocalToGlobalIndexMap(
                               std::move(all_mesh_subsets_single_component),
                               // by location order is needed for output
                               NumLib::ComponentOrder::BY_LOCATION),
                           manage_storage);
}

References ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh_subset_all_nodes, ProcessLib::Process::_use_monolithic_scheme, and NumLib::BY_LOCATION.

getFlux()

Eigen::Vector3d ProcessLib::HT::HTProcess::getFlux ( std::size_t element_id, MathLib::Point3d const & p, double const t, std::vector< GlobalVector * > const & x ) const

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 169 of file HTProcess.cpp.

{
    // fetch local_x from primary variable
    std::vector<GlobalIndexType> indices_cache;
    auto const r_c_indices = NumLib::getRowColumnIndices(
        element_id, *_local_to_global_index_map, indices_cache);
    std::vector<std::vector<GlobalIndexType>> indices_of_all_coupled_processes{
        x.size(), r_c_indices.rows};
    auto const local_x =
        getCoupledLocalSolutions(x, indices_of_all_coupled_processes);
 
    return _local_assemblers[element_id]->getFlux(p, t, local_x);
}

References _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::getCoupledLocalSolutions(), and NumLib::getRowColumnIndices().

initializeConcreteProcess()

void ProcessLib::HT::HTProcess::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 47 of file HTProcess.cpp.

{
    int const mesh_space_dimension = _process_data.mesh_space_dimension;
 
    if (_use_monolithic_scheme)
    {
        ProcessLib::createLocalAssemblers<MonolithicHTFEM>(
            mesh_space_dimension, mesh.getElements(), dof_table,
            _local_assemblers, NumLib::IntegrationOrder{integration_order},
            mesh.isAxiallySymmetric(), _process_data);
    }
    else
    {
        ProcessLib::createLocalAssemblers<StaggeredHTFEM>(
            mesh_space_dimension, mesh.getElements(), dof_table,
            _local_assemblers, NumLib::IntegrationOrder{integration_order},
            mesh.isAxiallySymmetric(), _process_data);
    }
 
    GlobalExecutor::executeMemberOnDereferenced(
        &HTLocalAssemblerInterface::initialize, _local_assemblers, dof_table);
 
    _secondary_variables.addSecondaryVariable(
        "darcy_velocity",
        makeExtrapolator(mesh_space_dimension, getExtrapolator(),
                         _local_assemblers,
                         &HTLocalAssemblerInterface::getIntPtDarcyVelocity));
}

References _local_assemblers, _process_data, ProcessLib::Process::_secondary_variables, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::createLocalAssemblers(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::HT::HTLocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::Mesh::isAxiallySymmetric(), and ProcessLib::makeExtrapolator().

isLinear()

bool ProcessLib::HT::HTProcess::isLinear ( ) const

inlineoverride

Definition at line 115 of file HTProcess.h.

{ return false; }

postTimestepConcreteProcess()

void ProcessLib::HT::HTProcess::postTimestepConcreteProcess ( std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, const double t, const double delta_t, int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 187 of file HTProcess.cpp.

{
    // For the monolithic scheme, process_id is always zero.
    if (_use_monolithic_scheme && process_id != 0)
    {
        OGS_FATAL(
            "The condition of process_id = 0 must be satisfied for monolithic "
            "HTProcess, which is a single process.");
    }
    if (!_use_monolithic_scheme &&
        process_id != _process_data.hydraulic_process_id)
    {
        DBUG("This is the thermal part of the staggered HTProcess.");
        return;
    }
    if (!_surfaceflux)  // computing the surfaceflux is optional
    {
        return;
    }
 
    _surfaceflux->integrate(x, t, *this, process_id, _integration_order, _mesh,
                            getActiveElementIDs());
}

References ProcessLib::Process::_integration_order, ProcessLib::Process::_mesh, _process_data, _surfaceflux, ProcessLib::Process::_use_monolithic_scheme, DBUG(), ProcessLib::Process::getActiveElementIDs(), and OGS_FATAL.

Member Data Documentation

_local_assemblers

std::vector<std::unique_ptr<HTLocalAssemblerInterface> > ProcessLib::HT::HTProcess::_local_assemblers

private

Definition at line 154 of file HTProcess.h.

Referenced by assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), getFlux(), and initializeConcreteProcess().

_process_data

HTProcessData ProcessLib::HT::HTProcess::_process_data

private

Definition at line 152 of file HTProcess.h.

Referenced by HTProcess(), assembleConcreteProcess(), initializeConcreteProcess(), and postTimestepConcreteProcess().

_surfaceflux

std::unique_ptr<ProcessLib::SurfaceFluxData> ProcessLib::HT::HTProcess::_surfaceflux

private

Definition at line 156 of file HTProcess.h.

Referenced by HTProcess(), and postTimestepConcreteProcess().

---

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

• HTProcess.h
• HTProcess.cpp