Detailed Description

Definition at line 40 of file Process.h.

#include <Process.h>

Inheritance diagram for ProcessLib::Process:

Collaboration diagram for ProcessLib::Process:

Public Member Functions
	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

Public Attributes
std::string const	name

Static Public Attributes
static PROCESSLIB_EXPORT const std::string	constant_one_parameter_name = "constant_one"

Protected Member Functions
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

Protected Attributes
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

Private Member Functions
virtual void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order)=0
	Process specific initialization called by initialize().

virtual void	initializeBoundaryConditions (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)

virtual void	setInitialConditionsConcreteProcess (std::vector< GlobalVector * > &, double const, int const)

virtual void	preAssembleConcreteProcess (const double, double const, GlobalVector const &)

virtual 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)=0

virtual 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)=0

virtual void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, const int)

virtual void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, const double, int const)

virtual void	postNonLinearSolverConcreteProcess (std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, double const, int const)

virtual void	preIterationConcreteProcess (const unsigned, GlobalVector const &)

virtual void	computeSecondaryVariableConcrete (double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)

virtual NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &)

virtual void	preOutputConcreteProcess (const double, double const, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, int const)

void	initializeExtrapolator ()

void	computeSparsityPattern ()

Private Attributes
std::vector< SourceTermCollection >	_source_term_collections

ExtrapolatorData	_extrapolator_data

std::vector< std::size_t >	_ids_of_active_elements
	Union of active element ids per process variable.

Constructor & Destructor Documentation

◆ Process()

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 )

Definition at line 44 of file Process.cpp.

    : name(std::move(name_)),
      _mesh(mesh),
      _secondary_variables(std::move(secondary_variables)),
      cell_average_data_(mesh),
      _jacobian_assembler(std::move(jacobian_assembler)),
      _global_assembler(*_jacobian_assembler),
      _use_monolithic_scheme(use_monolithic_scheme),
      _integration_order(integration_order),
      _process_variables(std::move(process_variables)),
      _boundary_conditions(
          [&](const std::size_t number_of_process_variables)
              -> std::vector<BoundaryConditionCollection>
          {
              std::vector<BoundaryConditionCollection> pcs_BCs;
              pcs_BCs.reserve(number_of_process_variables);
              for (std::size_t i = 0; i < number_of_process_variables; i++)
              {
                  pcs_BCs.emplace_back(BoundaryConditionCollection(parameters));
              }
              return pcs_BCs;
          }(_process_variables.size())),
      _source_term_collections(
          [&](const std::size_t number_of_processes)
              -> std::vector<SourceTermCollection>
          {
              std::vector<SourceTermCollection> pcs_sts;
              pcs_sts.reserve(number_of_processes);
              for (std::size_t i = 0; i < number_of_processes; i++)
              {
                  pcs_sts.emplace_back(SourceTermCollection(parameters));
              }
              return pcs_sts;
          }(_process_variables.size()))
{
}

Member Function Documentation

◆ assemble()

void ProcessLib::Process::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

Definition at line 266 of file Process.cpp.

{
    assert(x.size() == x_prev.size());
 
    setLocalAccessibleVectors(x, x_prev);
 
    assembleConcreteProcess(t, dt, x, x_prev, process_id, M, K, b);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, &K, b,
                                                    nullptr);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _source_term_collections[process_id].integrate(t, *x[process_id], b,
                                                   nullptr);
}

References _boundary_conditions, _source_term_collections, and assembleConcreteProcess().

◆ assembleConcreteProcess()

virtual void ProcessLib::Process::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 )

privatepure virtual

Referenced by assemble().

◆ assembleWithJacobian()

void ProcessLib::Process::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

Definition at line 287 of file Process.cpp.

{
    assert(x.size() == x_prev.size());
 
    setLocalAccessibleVectors(x, x_prev);
 
    assembleWithJacobianConcreteProcess(t, dt, x, x_prev, process_id, b, Jac);
 
    // TODO: apply BCs to Jacobian.
    _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, nullptr,
                                                    b, &Jac);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _source_term_collections[process_id].integrate(t, *x[process_id], b, &Jac);
}

References _boundary_conditions, _source_term_collections, and assembleWithJacobianConcreteProcess().

◆ assembleWithJacobianConcreteProcess()

virtual void ProcessLib::Process::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 )

privatepure virtual

Referenced by assembleWithJacobian().

◆ computeSecondaryVariable()

void ProcessLib::Process::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.

Definition at line 475 of file Process.cpp.

{
    for (auto const* solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
    MathLib::LinAlg::setLocalAccessibleVector(x_prev);
 
    computeSecondaryVariableConcrete(t, dt, x, x_prev, process_id);
}

References computeSecondaryVariableConcrete(), and MathLib::LinAlg::setLocalAccessibleVector().

◆ computeSecondaryVariableConcrete()

virtual void ProcessLib::Process::computeSecondaryVariableConcrete	(	double const	,
		double const	,
		std::vector< GlobalVector * > const &	,
		GlobalVector const &	,
		int const	)

inlineprivatevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, and ProcessLib::WellboreSimulator::WellboreSimulatorProcess.

Definition at line 293 of file Process.h.

299 {

300 }

Referenced by computeSecondaryVariable().

◆ computeSparsityPattern()

void ProcessLib::Process::computeSparsityPattern ( )

private

Computes and stores global matrix' sparsity pattern from given DOF-table.

Definition at line 437 of file Process.cpp.

{
    _sparsity_pattern =
        NumLib::computeSparsityPattern(*_local_to_global_index_map, _mesh);
}

References _local_to_global_index_map, _mesh, _sparsity_pattern, and NumLib::computeSparsityPattern().

Referenced by initialize().

◆ constructDofTable()

void ProcessLib::Process::constructDofTable ( )

protectedvirtual

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.

Definition at line 307 of file Process.cpp.

{
    if (_use_monolithic_scheme)
    {
        constructMonolithicProcessDofTable();
 
        return;
    }
 
    // For staggered scheme:
    const int specified_process_id = 0;
    constructDofTableOfSpecifiedProcessStaggeredScheme(specified_process_id);
}

References _use_monolithic_scheme, constructDofTableOfSpecifiedProcessStaggeredScheme(), and constructMonolithicProcessDofTable().

Referenced by initialize().

◆ constructDofTableOfSpecifiedProcessStaggeredScheme()

void ProcessLib::Process::constructDofTableOfSpecifiedProcessStaggeredScheme ( const int specified_process_id )

protected

Construct the DOF table for a specified process in the staggered scheme, which is stored in the member of this class, _local_to_global_index_map.

Definition at line 354 of file Process.cpp.

{
    // Create single component dof in every of the mesh nodes.
    _mesh_subset_all_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
 
    // Vector of mesh subsets.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
 
    // Vector of the number of variable components
    std::vector<int> vec_var_n_components;
    // Collect the mesh subsets in a vector for each variables' components.
    std::generate_n(std::back_inserter(all_mesh_subsets),
                    _process_variables[specified_process_id][0]
                        .get()
                        .getNumberOfGlobalComponents(),
                    [&]() { return *_mesh_subset_all_nodes; });
 
    // Create a vector of the number of variable components.
    vec_var_n_components.push_back(_process_variables[specified_process_id][0]
                                       .get()
                                       .getNumberOfGlobalComponents());
    _local_to_global_index_map =
        std::make_unique<NumLib::LocalToGlobalIndexMap>(
            std::move(all_mesh_subsets), vec_var_n_components,
            NumLib::ComponentOrder::BY_LOCATION);
 
    assert(_local_to_global_index_map);
}

References _local_to_global_index_map, _mesh, _mesh_subset_all_nodes, _process_variables, NumLib::BY_LOCATION, and MeshLib::Mesh::getNodes().

Referenced by constructDofTable().

◆ constructMonolithicProcessDofTable()

void ProcessLib::Process::constructMonolithicProcessDofTable ( )

protected

Construct the DOF table for the monolithic scheme, which is stored in the member of this class, _local_to_global_index_map.

Definition at line 321 of file Process.cpp.

{
    // Create single component dof in every of the mesh nodes.
    _mesh_subset_all_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
 
    // Vector of mesh subsets.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
 
    // Collect the mesh subsets in a vector for the components of each
    // variables.
    for (ProcessVariable const& pv : _process_variables[0])
    {
        std::generate_n(std::back_inserter(all_mesh_subsets),
                        pv.getNumberOfGlobalComponents(),
                        [&]() { return *_mesh_subset_all_nodes; });
    }
 
    // Create a vector of the number of variable components
    std::vector<int> vec_var_n_components;
    transform(cbegin(_process_variables[0]), cend(_process_variables[0]),
              back_inserter(vec_var_n_components),
              [](ProcessVariable const& pv)
              { return pv.getNumberOfGlobalComponents(); });
 
    _local_to_global_index_map =
        std::make_unique<NumLib::LocalToGlobalIndexMap>(
            std::move(all_mesh_subsets), vec_var_n_components,
            NumLib::ComponentOrder::BY_LOCATION);
 
    assert(_local_to_global_index_map);
}

References _local_to_global_index_map, _mesh, _mesh_subset_all_nodes, _process_variables, NumLib::BY_LOCATION, MeshLib::Mesh::getNodes(), and ProcessLib::ProcessVariable::getNumberOfGlobalComponents().

Referenced by constructDofTable().

◆ extrapolateIntegrationPointValuesToNodes()

virtual void ProcessLib::Process::extrapolateIntegrationPointValuesToNodes	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< GlobalVector * > &	)

inlinevirtual

Definition at line 107 of file Process.h.

111 {

112 }

◆ getActiveElementIDs()

std::vector< std::size_t > const & ProcessLib::Process::getActiveElementIDs ( ) const

inline

Definition at line 167 of file Process.h.

    {
        return _ids_of_active_elements;
    }

References _ids_of_active_elements.

◆ getDOFTable()

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

inlinevirtual

Reimplemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >.

Definition at line 147 of file Process.h.

    {
        return *_local_to_global_index_map;
    }

References _local_to_global_index_map.

Referenced by anonymous_namespace{ProcessOutputData.cpp}::computeDofTablesForSubmesh(), getDOFTables(), anonymous_namespace{ProcessOutputData.cpp}::getDofTablesOfAllProcesses(), getIndicesOfResiduumWithoutInitialCompensation(), and setInitialConditions().

◆ getDOFTableForExtrapolatorData()

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

protectedvirtual

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 in ProcessLib::HT::HTProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >.

Definition at line 396 of file Process.cpp.

{
    if (_local_to_global_index_map->getNumberOfGlobalComponents() == 1)
    {
        // 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;
    all_mesh_subsets_single_component.emplace_back(*_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 _local_to_global_index_map, _mesh_subset_all_nodes, and NumLib::BY_LOCATION.

Referenced by initializeExtrapolator().

◆ getDOFTables()

std::vector< NumLib::LocalToGlobalIndexMap const * > ProcessLib::Process::getDOFTables ( int const number_of_processes ) const

protected

Definition at line 385 of file Process.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(number_of_processes);
    std::generate_n(std::back_inserter(dof_tables), number_of_processes,
                    [&]() { return &getDOFTable(dof_tables.size()); });
    return dof_tables;
}

References getDOFTable().

Referenced by ProcessLib::AssemblyMixin< Process >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::setInitialConditionsConcreteProcess().

◆ getExtrapolator()

NumLib::Extrapolator & ProcessLib::Process::getExtrapolator ( ) const

inlineprotected

Definition at line 208 of file Process.h.

    {
        return _extrapolator_data.getExtrapolator();
    }

References _extrapolator_data, and ProcessLib::ExtrapolatorData::getExtrapolator().

◆ getFlux()

virtual Eigen::Vector3d ProcessLib::Process::getFlux	(	std::size_t	,
		MathLib::Point3d const &	,
		double const	,
		std::vector< GlobalVector * > const &	) const

inlinevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HT::HTProcess, ProcessLib::LiquidFlow::LiquidFlowProcess, and ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion.

Definition at line 185 of file Process.h.

    {
        return Eigen::Vector3d{};
    }

Referenced by ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble().

◆ getIndicesOfResiduumWithoutInitialCompensation()

std::vector< GlobalIndexType > ProcessLib::Process::getIndicesOfResiduumWithoutInitialCompensation ( ) const

overrideprotected

Returns: The global indices for the entries of the global residuum vector that do not need initial non-equilibrium compensation.

Definition at line 512 of file Process.cpp.

{
    std::vector<GlobalIndexType> indices;
 
    for (std::size_t process_id = 0; process_id < _process_variables.size();
         process_id++)
    {
        auto const& dof_table_of_process = getDOFTable(process_id);
 
        auto const& per_process_variables = _process_variables[process_id];
        for (std::size_t variable_id = 0;
             variable_id < per_process_variables.size();
             variable_id++)
        {
            auto const& pv = per_process_variables[variable_id];
            DBUG("Set the initial condition of variable {:s} of process {:d}.",
                 pv.get().getName().data(), process_id);
 
            if ((pv.get().compensateNonEquilibriumInitialResiduum()))
            {
                continue;
            }
 
            auto const num_comp = pv.get().getNumberOfGlobalComponents();
 
            for (int component_id = 0; component_id < num_comp; ++component_id)
            {
                auto const& mesh_subset = dof_table_of_process.getMeshSubset(
                    variable_id, component_id);
                auto const mesh_id = mesh_subset.getMeshID();
                for (auto const* node : mesh_subset.getNodes())
                {
                    MeshLib::Location const l(
                        mesh_id, MeshLib::MeshItemType::Node, node->getID());
 
                    auto global_index =
                        std::abs(dof_table_of_process.getGlobalIndex(
                            l, variable_id, component_id));
 
                    indices.push_back(global_index);
                }
            }
        }
    }
 
    return indices;
}

References _process_variables, DBUG(), getDOFTable(), and MeshLib::Node.

◆ getIntegrationPointWriters()

std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const & ProcessLib::Process::getIntegrationPointWriters ( ) const

inline

Definition at line 178 of file Process.h.

    {
        return _integration_point_writer;
    }

References _integration_point_writer.

Referenced by anonymous_namespace{ProcessOutputData.cpp}::getIntegrationPointWriters().

◆ getKnownSolutions()

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

inlinefinal

Definition at line 141 of file Process.h.

    {
        return _boundary_conditions[process_id].getKnownSolutions(t, x);
    }

References _boundary_conditions.

◆ getMatrixSpecifications()

MathLib::MatrixSpecifications ProcessLib::Process::getMatrixSpecifications ( const int process_id ) const

override

Definition at line 211 of file Process.cpp.

{
    auto const& l = *_local_to_global_index_map;
    return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
            &l.getGhostIndices(), &_sparsity_pattern};
}

References _local_to_global_index_map, and _sparsity_pattern.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::preOutputConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::preOutputConcreteProcess(), and ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation().

◆ getMesh()

MeshLib::Mesh & ProcessLib::Process::getMesh ( ) const

inline

Definition at line 153 of file Process.h.

153{ return _mesh; }

References _mesh.

Referenced by ProcessLib::Output::addProcess(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::createConstraintDirichletBoundaryCondition(), ProcessLib::Output::doOutput(), ProcessLib::Output::doOutputAlways(), ProcessLib::Output::doOutputLastTimestep(), ProcessLib::Output::doOutputNonlinearIteration(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::getOrientedSurfaceNormal(), anonymous_namespace{ProcessOutputData.cpp}::isSimulationDomain(), and ProcessLib::Output::prepareSubmesh().

◆ getProcessVariables() [1/2]

std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const & ProcessLib::Process::getProcessVariables ( ) const

inline

Definition at line 156 of file Process.h.

    {
        return _process_variables;
    }

References _process_variables.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), ProcessLib::createConstraintDirichletBoundaryCondition(), anonymous_namespace{ProcessOutputData.cpp}::getProcessVariablesOfAllProcesses(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::initializeConcreteProcess(), and updateDeactivatedSubdomains().

◆ getProcessVariables() [2/2]

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

inline

Definition at line 162 of file Process.h.

    {
        return _process_variables[process_id];
    }

References _process_variables.

◆ getSecondaryVariables()

SecondaryVariableCollection const & ProcessLib::Process::getSecondaryVariables ( ) const

inline

Definition at line 172 of file Process.h.

    {
        return _secondary_variables;
    }

References _secondary_variables.

Referenced by ProcessLib::createProcessOutputData().

◆ getSingleComponentDOFTable()

NumLib::LocalToGlobalIndexMap const & ProcessLib::Process::getSingleComponentDOFTable ( ) const

inlineprotected

Definition at line 213 of file Process.h.

    {
        return _extrapolator_data.getDOFTable();
    }

References _extrapolator_data, and ProcessLib::ExtrapolatorData::getDOFTable().

Referenced by ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), and ProcessLib::TES::TESProcess::computeVapourPartialPressure().

◆ initialize()

void ProcessLib::Process::initialize ( std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & media )

Definition at line 119 of file Process.cpp.

{
    DBUG("Initialize process.");
 
    DBUG("Construct dof mappings.");
    constructDofTable();
 
    DBUG("Compute sparsity pattern");
    computeSparsityPattern();
 
    DBUG("Initialize the extrapolator");
    initializeExtrapolator();
 
    initializeConcreteProcess(*_local_to_global_index_map, _mesh,
                              _integration_order);
 
    DBUG("Initialize boundary conditions.");
    initializeBoundaryConditions(media);
}

References _integration_order, _local_to_global_index_map, _mesh, computeSparsityPattern(), constructDofTable(), DBUG(), initializeBoundaryConditions(), initializeConcreteProcess(), and initializeExtrapolator().

◆ initializeBoundaryConditions()

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

privatevirtual

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

Reimplemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >.

Definition at line 105 of file Process.cpp.

{
    // The number of processes is identical to the size of _process_variables,
    // the vector contains variables for different processes. See the
    // documentation of _process_variables.
    const std::size_t number_of_processes = _process_variables.size();
    for (std::size_t pcs_id = 0; pcs_id < number_of_processes; pcs_id++)
    {
        initializeProcessBoundaryConditionsAndSourceTerms(
            *_local_to_global_index_map, pcs_id, media);
    }
}

References _local_to_global_index_map, _process_variables, and initializeProcessBoundaryConditionsAndSourceTerms().

Referenced by initialize().

◆ initializeConcreteProcess()

virtual void ProcessLib::Process::initializeConcreteProcess	(	NumLib::LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh,
		unsigned const	integration_order )

privatepure virtual

Process specific initialization called by initialize().

Referenced by initialize().

◆ initializeExtrapolator()

void ProcessLib::Process::initializeExtrapolator ( )

private

Definition at line 420 of file Process.cpp.

{
    NumLib::LocalToGlobalIndexMap* dof_table_single_component;
    bool manage_storage;
 
    std::tie(dof_table_single_component, manage_storage) =
        getDOFTableForExtrapolatorData();
 
    std::unique_ptr<NumLib::Extrapolator> extrapolator(
        new NumLib::LocalLinearLeastSquaresExtrapolator(
            *dof_table_single_component));
 
    // TODO: Later on the DOF table can change during the simulation!
    _extrapolator_data = ExtrapolatorData(
        std::move(extrapolator), dof_table_single_component, manage_storage);
}

References _extrapolator_data, and getDOFTableForExtrapolatorData().

Referenced by initialize().

◆ initializeProcessBoundaryConditionsAndSourceTerms()

void ProcessLib::Process::initializeProcessBoundaryConditionsAndSourceTerms	(	const NumLib::LocalToGlobalIndexMap &	dof_table,
		const int	process_id,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

protected

Initialize the boundary conditions for a single process or coupled processes modelled by the monolithic scheme. It is called by initializeBoundaryConditions().

Definition at line 90 of file Process.cpp.

{
    auto const& per_process_variables = _process_variables[process_id];
    auto& per_process_BCs = _boundary_conditions[process_id];
 
    per_process_BCs.addBCsForProcessVariables(per_process_variables, dof_table,
                                              _integration_order, *this, media);
 
    auto& per_process_sts = _source_term_collections[process_id];
    per_process_sts.addSourceTermsForProcessVariables(
        per_process_variables, dof_table, _integration_order);
}

References _boundary_conditions, _integration_order, _process_variables, and _source_term_collections.

Referenced by initializeBoundaryConditions().

◆ isMonolithicSchemeUsed()

virtual bool ProcessLib::Process::isMonolithicSchemeUsed ( ) const

inlinevirtual

Reimplemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

Definition at line 102 of file Process.h.

    {
        return _use_monolithic_scheme;
    }

References _use_monolithic_scheme.

Referenced by ProcessLib::createConstraintDirichletBoundaryCondition(), and ProcessLib::Output::isOutputProcess().

◆ postIteration()

NumLib::IterationResult ProcessLib::Process::postIteration ( GlobalVector const & x )

final

Definition at line 494 of file Process.cpp.

{
    MathLib::LinAlg::setLocalAccessibleVector(x);
    return postIterationConcreteProcess(x);
}

References postIterationConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

◆ postIterationConcreteProcess()

virtual NumLib::IterationResult ProcessLib::Process::postIterationConcreteProcess ( GlobalVector const & )

inlineprivatevirtual

Reimplemented in ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, and ProcessLib::TES::TESProcess.

Definition at line 302 of file Process.h.

    {
        return NumLib::IterationResult::SUCCESS;
    }

References NumLib::SUCCESS.

Referenced by postIteration().

◆ postNonLinearSolver()

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

Calculates secondary variables, e.g. stress and strain for deformation analysis, only after nonlinear solver being successfully conducted.

Definition at line 465 of file Process.cpp.

{
    setLocalAccessibleVectors(x, x_prev);
 
    postNonLinearSolverConcreteProcess(x, x_prev, t, dt, process_id);
}

References postNonLinearSolverConcreteProcess().

◆ postNonLinearSolverConcreteProcess()

virtual void ProcessLib::Process::postNonLinearSolverConcreteProcess	(	std::vector< GlobalVector * > const &	,
		std::vector< GlobalVector * > const &	,
		const double	,
		double const	,
		int const	)

inlineprivatevirtual

Reimplemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, and ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >.

Definition at line 281 of file Process.h.

285 {

286 }

Referenced by postNonLinearSolver().

◆ postTimestep()

void ProcessLib::Process::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.

Definition at line 453 of file Process.cpp.

{
    setLocalAccessibleVectors(x, x_prev);
 
    postTimestepConcreteProcess(x, x_prev, t, delta_t, process_id);
 
    _boundary_conditions[process_id].postTimestep(t, x, process_id);
}

References _boundary_conditions, and postTimestepConcreteProcess().

◆ postTimestepConcreteProcess()

virtual void ProcessLib::Process::postTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	,
		std::vector< GlobalVector * > const &	,
		const double	,
		const double	,
		int const	)

inlineprivatevirtual

Definition at line 272 of file Process.h.

278 {

279 }

Referenced by postTimestep().

◆ preAssemble()

void ProcessLib::Process::preAssemble	(	const double	t,
		double const	dt,
		GlobalVector const &	x )

final

Definition at line 260 of file Process.cpp.

{
    preAssembleConcreteProcess(t, dt, x);
}

References preAssembleConcreteProcess().

◆ preAssembleConcreteProcess()

virtual void ProcessLib::Process::preAssembleConcreteProcess	(	const double	,
		double const	,
		GlobalVector const &	)

inlineprivatevirtual

Reimplemented in ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >.

Definition at line 248 of file Process.h.

251 {

252 }

Referenced by preAssemble().

◆ preIteration()

void ProcessLib::Process::preIteration	(	const unsigned	iter,
		GlobalVector const &	x )

final

Definition at line 488 of file Process.cpp.

{
    MathLib::LinAlg::setLocalAccessibleVector(x);
    preIterationConcreteProcess(iter, x);
}

References preIterationConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

◆ preIterationConcreteProcess()

virtual void ProcessLib::Process::preIterationConcreteProcess	(	const unsigned	,
		GlobalVector const &	)

inlineprivatevirtual

Reimplemented in ProcessLib::TES::TESProcess.

Definition at line 288 of file Process.h.

290 {

291 }

Referenced by preIteration().

◆ preOutput()

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

Definition at line 500 of file Process.cpp.

{
    for (auto const* solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
 
    preOutputConcreteProcess(t, dt, x, x_prev, process_id);
}

References preOutputConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

◆ preOutputConcreteProcess()

virtual void ProcessLib::Process::preOutputConcreteProcess	(	const double	,
		double const	,
		std::vector< GlobalVector * > const &	,
		std::vector< GlobalVector * > const &	,
		int const	)

inlineprivatevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess, and ProcessLib::HeatConduction::HeatConductionProcess.

Definition at line 308 of file Process.h.

312 {

313 }

Referenced by preOutput().

◆ preTimestep()

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

Preprocessing before starting assembly for new timestep.

Definition at line 443 of file Process.cpp.

{
    for (auto* const solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
    preTimestepConcreteProcess(x, t, delta_t, process_id);
 
    _boundary_conditions[process_id].preTimestep(t, x, process_id);
}

References _boundary_conditions, preTimestepConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

◆ preTimestepConcreteProcess()

virtual void ProcessLib::Process::preTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	,
		const double	,
		const double	,
		const int	)

inlineprivatevirtual

Definition at line 264 of file Process.h.

269 {

270 }

Referenced by preTimestep().

◆ requiresNormalization()

bool ProcessLib::Process::requiresNormalization ( ) const

inlineoverride

Definition at line 202 of file Process.h.

202{ return false; }

◆ setInitialConditions()

void ProcessLib::Process::setInitialConditions	(	std::vector< GlobalVector * > &	process_solutions,
		std::vector< GlobalVector * > const &	process_solutions_prev,
		double const	t,
		int const	process_id )

Definition at line 140 of file Process.cpp.

{
    auto& x = *process_solutions[process_id];
    auto& x_prev = *process_solutions_prev[process_id];
 
    // getDOFTableOfProcess can be overloaded by the specific process.
    auto const& dof_table_of_process = getDOFTable(process_id);
 
    auto const& per_process_variables = _process_variables[process_id];
    for (std::size_t variable_id = 0;
         variable_id < per_process_variables.size();
         variable_id++)
    {
        MathLib::LinAlg::setLocalAccessibleVector(x);
        ParameterLib::SpatialPosition pos;
 
        auto const& pv = per_process_variables[variable_id];
        DBUG("Set the initial condition of variable {:s} of process {:d}.",
             pv.get().getName().data(), process_id);
 
        auto const& ic = pv.get().getInitialCondition();
 
        auto const num_comp = pv.get().getNumberOfGlobalComponents();
 
        for (int component_id = 0; component_id < num_comp; ++component_id)
        {
            auto const& mesh_subset =
                dof_table_of_process.getMeshSubset(variable_id, component_id);
            auto const mesh_id = mesh_subset.getMeshID();
            for (auto const* node : mesh_subset.getNodes())
            {
                MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                          node->getID());
 
                pos.setNodeID(node->getID());
                pos.setCoordinates(*node);
                auto const& ic_value = ic(t, pos);
 
                auto global_index =
                    std::abs(dof_table_of_process.getGlobalIndex(l, variable_id,
                                                                 component_id));
#ifdef USE_PETSC
                // The global indices of the ghost entries of the global
                // matrix or the global vectors need to be set as negative
                // values for equation assembly, however the global indices
                // start from zero. Therefore, any ghost entry with zero
                // index is assigned an negative value of the vector size
                // or the matrix dimension. To assign the initial value for
                // the ghost entries, the negative indices of the ghost
                // entries are restored to zero.
                if (global_index == x.size())
                    global_index = 0;
#endif
                x.set(global_index, ic_value[component_id]);
            }
        }
    }
 
    MathLib::LinAlg::finalizeAssembly(x);
    MathLib::LinAlg::copy(x, x_prev);  // pushState
 
    MathLib::LinAlg::setLocalAccessibleVector(x);
    MathLib::LinAlg::setLocalAccessibleVector(x_prev);
 
    setInitialConditionsConcreteProcess(process_solutions, t, process_id);
}

References _process_variables, MathLib::LinAlg::copy(), DBUG(), MathLib::LinAlg::finalizeAssembly(), getDOFTable(), MeshLib::Node, ParameterLib::SpatialPosition::setCoordinates(), setInitialConditionsConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and ParameterLib::SpatialPosition::setNodeID().

◆ setInitialConditionsConcreteProcess()

virtual void ProcessLib::Process::setInitialConditionsConcreteProcess	(	std::vector< GlobalVector * > &	,
		double const	,
		int const	)

inlineprivatevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >.

Definition at line 241 of file Process.h.

245 {

246 }

Referenced by setInitialConditions().

◆ solveReactionEquation()

virtual void ProcessLib::Process::solveReactionEquation	(	std::vector< GlobalVector * > &	,
		std::vector< GlobalVector * > const &	,
		double const	,
		double const	,
		NumLib::EquationSystem &	,
		int const	)

inlinevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 194 of file Process.h.

199 {

200 }

◆ updateDeactivatedSubdomains()

void ProcessLib::Process::updateDeactivatedSubdomains	(	double const	time,
		const int	process_id )

Definition at line 219 of file Process.cpp.

{
    auto const& variables_per_process = getProcessVariables(process_id);
    for (auto const& variable : variables_per_process)
    {
        variable.get().updateDeactivatedSubdomains(time);
    }
 
    _ids_of_active_elements.clear();
 
    auto active_elements_ids = ranges::views::transform(
        [](auto const& variable)
        { return variable.get().getActiveElementIDs(); });
 
    // Early return if there's any process variable with all elements active.
    if (ranges::any_of(variables_per_process | active_elements_ids,
                       [](auto const& vector) { return vector.empty(); }))
    {
        return;
    }
 
    // Some process variable has deactivated elements. Create union of active
    // ids.
 
    _ids_of_active_elements =  // there is at least one process variable.
        variables_per_process[0].get().getActiveElementIDs();
 
    for (auto const& pv_active_element_ids :
         variables_per_process | ranges::views::drop(1) | active_elements_ids)
    {
        std::vector<std::size_t> new_active_elements;
        new_active_elements.reserve(_ids_of_active_elements.size() +
                                    pv_active_element_ids.size());
        ranges::set_union(_ids_of_active_elements, pv_active_element_ids,
                          std::back_inserter(new_active_elements));
 
        _ids_of_active_elements = std::move(new_active_elements);
    }
}

References _ids_of_active_elements, getActiveElementIDs(), and getProcessVariables().

Member Data Documentation

◆ _boundary_conditions

std::vector<BoundaryConditionCollection> ProcessLib::Process::_boundary_conditions

protected

Vector for boundary conditions. For the monolithic scheme or a single process, the size of the vector is one. For the staggered scheme, the size of vector is the number of the coupled processes.

Definition at line 405 of file Process.h.

Referenced by assemble(), assembleWithJacobian(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getKnownSolutions(), initializeProcessBoundaryConditionsAndSourceTerms(), postTimestep(), and preTimestep().

◆ _extrapolator_data

ExtrapolatorData ProcessLib::Process::_extrapolator_data

private

Definition at line 413 of file Process.h.

Referenced by getExtrapolator(), getSingleComponentDOFTable(), and initializeExtrapolator().

◆ _global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler

protected

Definition at line 377 of file Process.h.

◆ _ids_of_active_elements

std::vector<std::size_t> ProcessLib::Process::_ids_of_active_elements

private

Union of active element ids per process variable.

Definition at line 416 of file Process.h.

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _integration_order

unsigned const ProcessLib::Process::_integration_order

protected

Order of the integration method for element-wise integration. The Gauss-Legendre integration method and available orders is implemented in MathLib::GaussLegendre.

Definition at line 384 of file Process.h.

Referenced by initialize(), initializeProcessBoundaryConditionsAndSourceTerms(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), and ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess().

◆ _integration_point_writer

std::vector<std::unique_ptr<MeshLib::IntegrationPointWriter> > ProcessLib::Process::_integration_point_writer

protected

An optional vector containing descriptions for integration point data output and setting of the integration point initial conditions. The integration point writer are implemented in specific processes.

Definition at line 390 of file Process.h.

Referenced by ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::LargeDeformationProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::PhaseFieldProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::RichardsMechanicsProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::SmallDeformationNonlocalProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::ThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::ThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::ThermoRichardsFlowProcess(), getIntegrationPointWriters(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess().

◆ _jacobian_assembler

std::unique_ptr<ProcessLib::AbstractJacobianAssembler> ProcessLib::Process::_jacobian_assembler

protected

Definition at line 376 of file Process.h.

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::HydroMechanicsProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::TH2MProcess(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::ThermoRichardsMechanicsProcess().

◆ _local_to_global_index_map

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::Process::_local_to_global_index_map

protected

Definition at line 368 of file Process.h.

◆ _mesh

MeshLib::Mesh& ProcessLib::Process::_mesh

protected

Definition at line 365 of file Process.h.

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), computeSparsityPattern(), ProcessLib::TES::TESProcess::computeVapourPartialPressure(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getMesh(), initialize(), ProcessLib::TES::TESProcess::initializeSecondaryVariables(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), and ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation().

◆ _mesh_subset_all_nodes

std::unique_ptr<MeshLib::MeshSubset const> ProcessLib::Process::_mesh_subset_all_nodes

protected

Definition at line 366 of file Process.h.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData(), and getDOFTableForExtrapolatorData().

◆ _process_variables

std::vector<std::vector<std::reference_wrapper<ProcessVariable> > > ProcessLib::Process::_process_variables

protected

Variables used by this process. For the monolithic scheme or a single process, the size of the outer vector is one. For the staggered scheme, the size of the outer vector is the number of the coupled processes.

Definition at line 400 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::ComponentTransportProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), getIndicesOfResiduumWithoutInitialCompensation(), getProcessVariables(), getProcessVariables(), initializeBoundaryConditions(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), initializeProcessBoundaryConditionsAndSourceTerms(), ProcessLib::ComponentTransport::ComponentTransportProcess::preOutputConcreteProcess(), and setInitialConditions().

◆ _secondary_variables

SecondaryVariableCollection ProcessLib::Process::_secondary_variables

protected

Definition at line 370 of file Process.h.

◆ _source_term_collections

std::vector<SourceTermCollection> ProcessLib::Process::_source_term_collections

private

Vector for nodal source term collections. For the monolithic scheme or a single process, the size of the vector is one. For the staggered scheme, the size of vector is the number of the coupled processes.

Definition at line 411 of file Process.h.

Referenced by assemble(), assembleWithJacobian(), and initializeProcessBoundaryConditionsAndSourceTerms().

◆ _sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern

protected

Definition at line 392 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

◆ _use_monolithic_scheme

const bool ProcessLib::Process::_use_monolithic_scheme

protected

Definition at line 379 of file Process.h.

◆ cell_average_data_

CellAverageData ProcessLib::Process::cell_average_data_

protected

Definition at line 372 of file Process.h.

◆ constant_one_parameter_name

const std::string ProcessLib::Process::constant_one_parameter_name = "constant_one"

static

Definition at line 47 of file Process.h.

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), and ProjectData::parseParameters().

◆ name

std::string const ProcessLib::Process::name

Definition at line 362 of file Process.h.

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), and ProcessLib::WellboreSimulator::WellboreSimulatorProcess::initializeConcreteProcess().

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

ProcessLib/Process.h
ProcessLib/Process.cpp

Detailed Description

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Process()

Member Function Documentation

◆ assemble()

◆ assembleConcreteProcess()

◆ assembleWithJacobian()

◆ assembleWithJacobianConcreteProcess()

◆ computeSecondaryVariable()

◆ computeSecondaryVariableConcrete()

◆ computeSparsityPattern()

◆ constructDofTable()

◆ constructDofTableOfSpecifiedProcessStaggeredScheme()

◆ constructMonolithicProcessDofTable()

◆ extrapolateIntegrationPointValuesToNodes()

◆ getActiveElementIDs()

◆ getDOFTable()

◆ getDOFTableForExtrapolatorData()

◆ getDOFTables()

◆ getExtrapolator()

◆ getFlux()

◆ getIndicesOfResiduumWithoutInitialCompensation()

◆ getIntegrationPointWriters()

◆ getKnownSolutions()

◆ getMatrixSpecifications()

◆ getMesh()

◆ getProcessVariables() [1/2]

◆ getProcessVariables() [2/2]

◆ getSecondaryVariables()

◆ getSingleComponentDOFTable()

◆ initialize()

◆ initializeBoundaryConditions()

◆ initializeConcreteProcess()

◆ initializeExtrapolator()

◆ initializeProcessBoundaryConditionsAndSourceTerms()

◆ isMonolithicSchemeUsed()

◆ postIteration()

◆ postIterationConcreteProcess()

◆ postNonLinearSolver()

◆ postNonLinearSolverConcreteProcess()

◆ postTimestep()

◆ postTimestepConcreteProcess()

◆ preAssemble()

◆ preAssembleConcreteProcess()

◆ preIteration()

◆ preIterationConcreteProcess()

◆ preOutput()

◆ preOutputConcreteProcess()

◆ preTimestep()

◆ preTimestepConcreteProcess()

◆ requiresNormalization()

◆ setInitialConditions()

◆ setInitialConditionsConcreteProcess()

◆ solveReactionEquation()

◆ updateDeactivatedSubdomains()

Member Data Documentation

◆ _boundary_conditions

◆ _extrapolator_data

◆ _global_assembler

◆ _ids_of_active_elements

◆ _integration_order

◆ _integration_point_writer

◆ _jacobian_assembler

◆ _local_to_global_index_map

◆ _mesh

◆ _mesh_subset_all_nodes

◆ _process_variables

◆ _secondary_variables

◆ _source_term_collections

◆ _sparsity_pattern

◆ _use_monolithic_scheme

◆ cell_average_data_

◆ constant_one_parameter_name