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 not any coupling by source or sink terms, i.e., the coupling is implemented only by density changes due to temperature changes in the buoyance term in the groundwater flow. This coupling schema is referred to as the Boussinesq approximation.

Definition at line 52 of file HTProcess.h.

#include <HTProcess.h>

Inheritance diagram for ProcessLib::HT::HTProcess:

[legend]

Collaboration diagram for ProcessLib::HT::HTProcess:

[legend]

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	setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int const process_id) override

void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, 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. 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	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

virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const

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 void	solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)

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(). More...

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

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

virtual void	constructDofTable ()

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

◆ 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 26 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))
 {
 }

Member Function Documentation

◆ assembleConcreteProcess()

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

 {
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_tables;
     if (_use_monolithic_scheme)
     {
         DBUG("Assemble HTProcess.");
         dof_tables.emplace_back(*_local_to_global_index_map);
     }
     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);
         dof_tables.emplace_back(*_local_to_global_index_map);
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
         pv.getActiveElementIDs(), dof_tables, t, dt, x, xdot, process_id, M, K,
         b);
 }

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _process_data, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), ProcessLib::Process::getProcessVariables(), and ProcessLib::HT::HTProcessData::heat_transport_process_id.

◆ assembleWithJacobianConcreteProcess()

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

 {
     DBUG("AssembleWithJacobian HTProcess.");
  
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_tables;
     if (!_use_monolithic_scheme)
     {
         dof_tables.emplace_back(std::ref(*_local_to_global_index_map));
     }
     else
     {
         dof_tables.emplace_back(std::ref(*_local_to_global_index_map));
         dof_tables.emplace_back(std::ref(*_local_to_global_index_map));
     }
  
     // Call global assembler for each local assembly item.
     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);
 }

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(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::Process::getProcessVariables().

◆ 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 159 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 182 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 46 of file HTProcess.cpp.

 {
     // For the staggered scheme, both processes are assumed to use the same
     // element order. Therefore the order of shape function can be fetched from
     // any set of the sets of process variables of the coupled processes. Here,
     // we take the one from the first process by setting process_id = 0.
     const int process_id = 0;
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     if (_use_monolithic_scheme)
     {
         ProcessLib::createLocalAssemblers<MonolithicHTFEM>(
             mesh.getDimension(), mesh.getElements(), dof_table,
             pv.getShapeFunctionOrder(), _local_assemblers,
             mesh.isAxiallySymmetric(), integration_order, _process_data);
     }
     else
     {
         ProcessLib::createLocalAssemblers<StaggeredHTFEM>(
             mesh.getDimension(), mesh.getElements(), dof_table,
             pv.getShapeFunctionOrder(), _local_assemblers,
             mesh.isAxiallySymmetric(), integration_order, _process_data);
     }
  
     _secondary_variables.addSecondaryVariable(
         "darcy_velocity",
         makeExtrapolator(mesh.getDimension(), getExtrapolator(),
                          _local_assemblers,
                          &HTLocalAssemblerInterface::getIntPtDarcyVelocity));
 }

References _local_assemblers, _process_data, ProcessLib::Process::_secondary_variables, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::HT::HTLocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::Process::getProcessVariables(), ProcessLib::ProcessVariable::getShapeFunctionOrder(), MeshLib::Mesh::isAxiallySymmetric(), and ProcessLib::makeExtrapolator().

◆ isLinear()

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

inlineoverride

Definition at line 72 of file HTProcess.h.

72 { return false; }

◆ postTimestepConcreteProcess()

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

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 200 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;
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     _surfaceflux->integrate(x, t, *this, process_id, _integration_order, _mesh,
                             pv.getActiveElementIDs());
 }

References ProcessLib::Process::_integration_order, ProcessLib::Process::_mesh, _process_data, _surfaceflux, ProcessLib::Process::_use_monolithic_scheme, DBUG(), ProcessLib::ProcessVariable::getActiveElementIDs(), ProcessLib::Process::getProcessVariables(), ProcessLib::HT::HTProcessData::hydraulic_process_id, and OGS_FATAL.

◆ setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

void ProcessLib::HT::HTProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers ( int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 147 of file HTProcess.cpp.

 {
     DBUG("Set the coupled term for the staggered scheme to local assembers.");
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &HTLocalAssemblerInterface::setStaggeredCoupledSolutions,
         _local_assemblers, pv.getActiveElementIDs(), _coupled_solutions);
 }

References ProcessLib::Process::_coupled_solutions, _local_assemblers, DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), ProcessLib::Process::getProcessVariables(), and ProcessLib::HT::HTLocalAssemblerInterface::setStaggeredCoupledSolutions().

Member Data Documentation

◆ _local_assemblers

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

private

Definition at line 115 of file HTProcess.h.

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

◆ _process_data

HTProcessData ProcessLib::HT::HTProcess::_process_data

private

Definition at line 113 of file HTProcess.h.

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

◆ _surfaceflux

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

private

Definition at line 117 of file HTProcess.h.

Referenced by postTimestepConcreteProcess().

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

ProcessLib/HT/HTProcess.h
ProcessLib/HT/HTProcess.cpp

Detailed Description

HT process

Process Coupling

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ HTProcess()

Member Function Documentation

◆ assembleConcreteProcess()

◆ assembleWithJacobianConcreteProcess()

◆ getDOFTableForExtrapolatorData()

◆ getFlux()

◆ initializeConcreteProcess()

◆ isLinear()

◆ postTimestepConcreteProcess()

◆ setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

Member Data Documentation

◆ _local_assemblers

◆ _process_data

◆ _surfaceflux