Detailed Description

Definition at line 22 of file HeatConductionProcess.h.

#include <HeatConductionProcess.h>

Inheritance diagram for ProcessLib::HeatConduction::HeatConductionProcess:

Collaboration diagram for ProcessLib::HeatConduction::HeatConductionProcess:

Public Member Functions
	HeatConductionProcess (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, HeatConductionProcessData &&process_data, SecondaryVariableCollection &&secondary_variables, bool const is_linear, bool const ls_compute_only_upon_timestep_change)

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

bool	shouldLinearSolverComputeOnlyUponTimestepChange () 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.

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 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 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, 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, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) override

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

Private Attributes
HeatConductionProcessData	_process_data

std::vector< std::unique_ptr< HeatConductionLocalAssemblerInterface > >	_local_assemblers

MeshLib::PropertyVector< double > *	_heat_flux = nullptr

AssembledMatrixCache	_asm_mat_cache

bool const	_ls_compute_only_upon_timestep_change

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)

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

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

◆ HeatConductionProcess()

ProcessLib::HeatConduction::HeatConductionProcess::HeatConductionProcess	(	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,
		HeatConductionProcessData &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		bool const	is_linear,
		bool const	ls_compute_only_upon_timestep_change )

Definition at line 26 of file HeatConductionProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables)),
      _process_data(std::move(process_data)),
      _asm_mat_cache{is_linear, true /*use_monolithic_scheme*/},
      _ls_compute_only_upon_timestep_change{
          ls_compute_only_upon_timestep_change}
{
    if (ls_compute_only_upon_timestep_change)
    {
        // TODO move this feature to some common location for all processes.
        if (!is_linear)
        {
            OGS_FATAL(
                "Using the linear solver compute() method only upon timestep "
                "change only makes sense for linear model equations.");
        }
 
        WARN(
            "You specified that the HeatConduction linear solver will do "
            "the compute() step only upon timestep change. This is an expert "
            "option. It is your responsibility to ensure that "
            "the conditions for the correct use of this feature are met! "
            "Otherwise OGS might compute garbage without being recognized. "
            "There is no safety net!");
 
        WARN(
            "You specified that the HeatConduction linear solver will do "
            "the compute() step only upon timestep change. This option will "
            "only be used by the Picard non-linear solver. The Newton-Raphson "
            "non-linear solver will silently ignore this setting, i.e., it "
            "won't do any harm, there, but you won't observe the speedup you "
            "probably expect.");
    }
 
    _heat_flux = MeshLib::getOrCreateMeshProperty<double>(
        mesh, "HeatFlowRate", MeshLib::MeshItemType::Node, 1);
}

References _heat_flux, MeshLib::getOrCreateMeshProperty(), MeshLib::Node, OGS_FATAL, and WARN().

Member Function Documentation

◆ assembleConcreteProcess()

void ProcessLib::HeatConduction::HeatConductionProcess::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 96 of file HeatConductionProcess.cpp.

{
    DBUG("Assemble HeatConductionProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    _asm_mat_cache.assemble(t, dt, x, x_prev, process_id, &M, &K, &b, dof_table,
                            _global_assembler, _local_assemblers,
                            getActiveElementIDs());
}

References _asm_mat_cache, ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::AssembledMatrixCache::assemble(), DBUG(), and ProcessLib::Process::getActiveElementIDs().

Referenced by preOutputConcreteProcess().

◆ assembleWithJacobianConcreteProcess()

void ProcessLib::HeatConduction::HeatConductionProcess::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 111 of file HeatConductionProcess.cpp.

{
    DBUG("AssembleWithJacobian HeatConductionProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_table, t, dt, x, x_prev,
        process_id, &b, &Jac);
 
    transformVariableFromGlobalVector(b, 0 /*variable id*/,
                                      *_local_to_global_index_map, *_heat_flux,
                                      std::negate<double>());
}

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

◆ computeSecondaryVariableConcrete()

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

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 131 of file HeatConductionProcess.cpp.

{
    DBUG("Compute heat flux for HeatConductionProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &HeatConductionLocalAssemblerInterface::computeSecondaryVariable,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id);
}

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

◆ initializeConcreteProcess()

void ProcessLib::HeatConduction::HeatConductionProcess::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 77 of file HeatConductionProcess.cpp.

{
    int const mesh_space_dimension = _process_data.mesh_space_dimension;
 
    ProcessLib::createLocalAssemblers<LocalAssemblerData>(
        mesh_space_dimension, mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _process_data);
 
    _secondary_variables.addSecondaryVariable(
        "heat_flux",
        makeExtrapolator(
            mesh_space_dimension, getExtrapolator(), _local_assemblers,
            &HeatConductionLocalAssemblerInterface::getIntPtHeatFlux));
}

References _local_assemblers, _process_data, ProcessLib::Process::_secondary_variables, ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), ProcessLib::createLocalAssemblers(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::HeatConduction::HeatConductionLocalAssemblerInterface::getIntPtHeatFlux(), MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), and ProcessLib::HeatConduction::HeatConductionProcessData::mesh_space_dimension.

◆ isLinear()

bool ProcessLib::HeatConduction::HeatConductionProcess::isLinear ( ) const

inlineoverride

Definition at line 43 of file HeatConductionProcess.h.

43{ return _asm_mat_cache.isLinear(); }

ProcessLib::AssembledMatrixCache::isLinear

bool isLinear() const

Definition AssembledMatrixCache.h:42

References _asm_mat_cache, and ProcessLib::AssembledMatrixCache::isLinear().

◆ preOutputConcreteProcess()

void ProcessLib::HeatConduction::HeatConductionProcess::preOutputConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 148 of file HeatConductionProcess.cpp.

{
    auto const matrix_specification = getMatrixSpecifications(process_id);
 
    auto M = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
        matrix_specification);
    auto K = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
        matrix_specification);
    auto b = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
        matrix_specification);
 
    M->setZero();
    K->setZero();
    b->setZero();
 
    assembleConcreteProcess(t, dt, x, x_prev, process_id, *M, *K, *b);
 
    BaseLib::RunTime time_residuum;
    time_residuum.start();
 
    auto const residuum = computeResiduum(dt, *x[0], *x_prev[0], *M, *K, *b);
 
    transformVariableFromGlobalVector(residuum, 0, *_local_to_global_index_map,
                                      *_heat_flux, std::negate<double>());
 
    INFO("[time] Computing residuum flow rates took {:g} s",
         time_residuum.elapsed());
}

References _heat_flux, ProcessLib::Process::_local_to_global_index_map, assembleConcreteProcess(), ProcessLib::computeResiduum(), BaseLib::RunTime::elapsed(), ProcessLib::Process::getMatrixSpecifications(), INFO(), and BaseLib::RunTime::start().

◆ shouldLinearSolverComputeOnlyUponTimestepChange()

bool ProcessLib::HeatConduction::HeatConductionProcess::shouldLinearSolverComputeOnlyUponTimestepChange ( ) const

inlineoverride

Definition at line 51 of file HeatConductionProcess.h.

    {
        // TODO move this feature to some common location for all processes.
        return _ls_compute_only_upon_timestep_change;
    }

References _ls_compute_only_upon_timestep_change.

Member Data Documentation

◆ _asm_mat_cache

AssembledMatrixCache ProcessLib::HeatConduction::HeatConductionProcess::_asm_mat_cache

private

Definition at line 87 of file HeatConductionProcess.h.

Referenced by assembleConcreteProcess(), and isLinear().

◆ _heat_flux

MeshLib::PropertyVector<double>* ProcessLib::HeatConduction::HeatConductionProcess::_heat_flux = nullptr

private

Definition at line 85 of file HeatConductionProcess.h.

Referenced by HeatConductionProcess(), assembleWithJacobianConcreteProcess(), and preOutputConcreteProcess().

◆ _local_assemblers

std::vector<std::unique_ptr<HeatConductionLocalAssemblerInterface> > ProcessLib::HeatConduction::HeatConductionProcess::_local_assemblers

private

Definition at line 83 of file HeatConductionProcess.h.

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

◆ _ls_compute_only_upon_timestep_change

bool const ProcessLib::HeatConduction::HeatConductionProcess::_ls_compute_only_upon_timestep_change

private

Definition at line 89 of file HeatConductionProcess.h.

Referenced by shouldLinearSolverComputeOnlyUponTimestepChange().

◆ _process_data

HeatConductionProcessData ProcessLib::HeatConduction::HeatConductionProcess::_process_data

private

Definition at line 80 of file HeatConductionProcess.h.

Referenced by initializeConcreteProcess().

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

ProcessLib/HeatConduction/HeatConductionProcess.h
ProcessLib/HeatConduction/HeatConductionProcess.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ HeatConductionProcess()

Member Function Documentation

◆ assembleConcreteProcess()

◆ assembleWithJacobianConcreteProcess()

◆ computeSecondaryVariableConcrete()

◆ initializeConcreteProcess()

◆ isLinear()

◆ preOutputConcreteProcess()

◆ shouldLinearSolverComputeOnlyUponTimestepChange()

Member Data Documentation

◆ _asm_mat_cache

◆ _heat_flux

◆ _local_assemblers

◆ _ls_compute_only_upon_timestep_change

◆ _process_data