Detailed Description

Definition at line 40 of file Process.h.

#include <Process.h>

Inheritance diagram for ProcessLib::Process:

Collaboration diagram for ProcessLib::Process:

Public Types
using	NonlinearSolver = NumLib::NonlinearSolverBase

using	TimeDiscretization = NumLib::TimeDiscretization

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. 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	setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int 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, 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< 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)

Public Attributes
std::string const	name

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

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

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

VectorMatrixAssembler	_global_assembler

const bool	_use_monolithic_scheme

CoupledSolutionsForStaggeredScheme *	_coupled_solutions

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

virtual void	initializeBoundaryConditions ()

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 &xdot, 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 &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, 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 &, const double, const double, int const)

virtual void	postNonLinearSolverConcreteProcess (GlobalVector const &, 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 &)

void	initializeExtrapolator ()

void	computeSparsityPattern ()

Private Attributes
std::vector< SourceTermCollection >	_source_term_collections

ExtrapolatorData	_extrapolator_data

Member Typedef Documentation

◆ NonlinearSolver

using ProcessLib::Process::NonlinearSolver = NumLib::NonlinearSolverBase

Definition at line 48 of file Process.h.

◆ TimeDiscretization

using ProcessLib::Process::TimeDiscretization = NumLib::TimeDiscretization

Definition at line 49 of file Process.h.

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 24 of file Process.cpp.

     : name(std::move(name_)),
       _mesh(mesh),
       _secondary_variables(std::move(secondary_variables)),
       _global_assembler(std::move(jacobian_assembler)),
       _use_monolithic_scheme(use_monolithic_scheme),
       _coupled_solutions(nullptr),
       _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 &	xdot,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b
	)

final

Definition at line 211 of file Process.cpp.

 {
     assert(x.size() == xdot.size());
     for (std::size_t i = 0; i < x.size(); i++)
     {
         MathLib::LinAlg::setLocalAccessibleVector(*x[i]);
         MathLib::LinAlg::setLocalAccessibleVector(*xdot[i]);
     }
  
     assembleConcreteProcess(t, dt, x, xdot, 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, assembleConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::t.

◆ assembleConcreteProcess()

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

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

final

Definition at line 235 of file Process.cpp.

 {
     assert(x.size() == xdot.size());
     for (std::size_t i = 0; i < x.size(); i++)
     {
         MathLib::LinAlg::setLocalAccessibleVector(*x[i]);
         MathLib::LinAlg::setLocalAccessibleVector(*xdot[i]);
     }
  
     assembleWithJacobianConcreteProcess(t, dt, x, xdot, process_id, M, K, b,
                                         Jac);
  
     // TODO: apply BCs to Jacobian.
     _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, 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, assembleWithJacobianConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::t.

◆ assembleWithJacobianConcreteProcess()

virtual void ProcessLib::Process::assembleWithJacobianConcreteProcess	(	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,
		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_dot,
		int const	process_id
	)

compute secondary variables for the coupled equations or for output.

Definition at line 415 of file Process.cpp.

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

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

◆ computeSecondaryVariableConcrete()

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

inlineprivatevirtual

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

Definition at line 266 of file Process.h.

272 {

273 }

Referenced by computeSecondaryVariable().

◆ computeSparsityPattern()

void ProcessLib::Process::computeSparsityPattern ( )

private

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

Definition at line 380 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 260 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_prosess_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 307 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 274 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 112 of file Process.h.

116 {

117 }

◆ getDOFTable()

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

inlinevirtual

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

Definition at line 141 of file Process.h.

     {
         return *_local_to_global_index_map;
     }

References _local_to_global_index_map.

Referenced by anonymous_namespace{ProcessOutputData.cpp}::computeDofTablesForSubmesh(), 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::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::HT::HTProcess.

Definition at line 339 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().

◆ getExtrapolator()

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

inlineprotected

Definition at line 185 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::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::HT::HTProcess, ProcessLib::LiquidFlow::LiquidFlowProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 167 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 441 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 160 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 135 of file Process.h.

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

References _boundary_conditions, and MathLib::t.

◆ getMatrixSpecifications()

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

override

Definition at line 187 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::solveReactionEquation().

◆ getMesh()

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

inline

Definition at line 147 of file Process.h.

147 { 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()

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

inline

Definition at line 149 of file Process.h.

     {
         return _process_variables[process_id];
     }

References _process_variables.

◆ getSecondaryVariables()

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

inline

Definition at line 154 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 190 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 ( )

Definition at line 96 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();
 }

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

◆ initializeBoundaryConditions()

void ProcessLib::Process::initializeBoundaryConditions ( )

privatevirtual

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

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

Definition at line 83 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);
     }
 }

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

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 69 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);
  
     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()

bool ProcessLib::Process::isMonolithicSchemeUsed ( ) const

inline

Definition at line 106 of file Process.h.

106 { return _use_monolithic_scheme; }

References _use_monolithic_scheme.

Referenced by ProcessLib::createConstraintDirichletBoundaryCondition(), anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess(), and ProcessLib::Output::isOutputProcess().

◆ postIteration()

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

final

Definition at line 434 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::TES::TESProcess, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, and ProcessLib::HeatTransportBHE::HeatTransportBHEProcess.

Definition at line 275 of file Process.h.

     {
         return NumLib::IterationResult::SUCCESS;
     }

References NumLib::SUCCESS.

Referenced by postIteration().

◆ postNonLinearSolver()

void ProcessLib::Process::postNonLinearSolver	(	GlobalVector const &	x,
		GlobalVector const &	xdot,
		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 406 of file Process.cpp.

 {
     MathLib::LinAlg::setLocalAccessibleVector(x);
     MathLib::LinAlg::setLocalAccessibleVector(xdot);
     postNonLinearSolverConcreteProcess(x, xdot, t, dt, process_id);
 }

References postNonLinearSolverConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::t.

◆ postNonLinearSolverConcreteProcess()

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

inlineprivatevirtual

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

Definition at line 255 of file Process.h.

258 {

259 }

Referenced by postNonLinearSolver().

◆ postTimestep()

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

Postprocessing after a complete timestep.

Definition at line 396 of file Process.cpp.

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

References _boundary_conditions, postTimestepConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::t.

◆ postTimestepConcreteProcess()

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

inlineprivatevirtual

Definition at line 247 of file Process.h.

252 {

253 }

Referenced by postTimestep().

◆ preAssemble()

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

final

Definition at line 205 of file Process.cpp.

 {
     preAssembleConcreteProcess(t, dt, x);
 }

References preAssembleConcreteProcess(), and MathLib::t.

◆ preAssembleConcreteProcess()

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

inlineprivatevirtual

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

Definition at line 221 of file Process.h.

224 {

225 }

Referenced by preAssemble().

◆ preIteration()

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

final

Definition at line 428 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 261 of file Process.h.

263 {

264 }

Referenced by preIteration().

◆ 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 386 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(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::t.

◆ preTimestepConcreteProcess()

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

inlineprivatevirtual

Reimplemented in ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, and ProcessLib::TES::TESProcess.

Definition at line 239 of file Process.h.

244 {

245 }

Referenced by preTimestep().

◆ setCoupledSolutionsForStaggeredScheme()

void ProcessLib::Process::setCoupledSolutionsForStaggeredScheme ( CoupledSolutionsForStaggeredScheme *const coupled_solutions )

inline

Definition at line 98 of file Process.h.

     {
         _coupled_solutions = coupled_solutions;
     }

References _coupled_solutions.

◆ setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

virtual void ProcessLib::Process::setCoupledTermForTheStaggeredSchemeToLocalAssemblers ( int const )

inlinevirtual

Reimplemented in ProcessLib::HT::HTProcess.

Definition at line 107 of file Process.h.

109 {

110 }

◆ 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 116 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(), ParameterLib::SpatialPosition::setNodeID(), and MathLib::t.

◆ setInitialConditionsConcreteProcess()

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

inlineprivatevirtual

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

Definition at line 214 of file Process.h.

218 {

219 }

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 176 of file Process.h.

181 {

182 }

◆ updateDeactivatedSubdomains()

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

Definition at line 195 of file Process.cpp.

 {
     auto const& variables_per_process = getProcessVariables(process_id);
     for (auto const& variable : variables_per_process)
     {
         variable.get().updateDeactivatedSubdomains(time);
     }
 }

References 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 370 of file Process.h.

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

◆ _coupled_solutions

CoupledSolutionsForStaggeredScheme* ProcessLib::Process::_coupled_solutions

protected

Pointer to CoupledSolutionsForStaggeredScheme, which contains the references to the solutions of the coupled processes.

Definition at line 344 of file Process.h.

Referenced by setCoupledSolutionsForStaggeredScheme(), and ProcessLib::HT::HTProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers().

◆ _extrapolator_data

ExtrapolatorData ProcessLib::Process::_extrapolator_data

private

Definition at line 378 of file Process.h.

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

◆ _global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler

protected

Definition at line 338 of file Process.h.

◆ _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 349 of file Process.h.

Referenced by initialize(), initializeProcessBoundaryConditionsAndSourceTerms(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::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 355 of file Process.h.

◆ _local_to_global_index_map

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

protected

Definition at line 334 of file Process.h.

◆ _mesh

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

protected

Definition at line 331 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::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::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 332 of file Process.h.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), getDOFTableForExtrapolatorData(), and ProcessLib::HT::HTProcess::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 365 of file Process.h.

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

◆ _secondary_variables

SecondaryVariableCollection ProcessLib::Process::_secondary_variables

protected

Definition at line 336 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 376 of file Process.h.

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

◆ _sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern

protected

Definition at line 357 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

◆ _use_monolithic_scheme

const bool ProcessLib::Process::_use_monolithic_scheme

protected

Definition at line 340 of file Process.h.

◆ constant_one_parameter_name

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

static

Definition at line 46 of file Process.h.

Referenced by ProcessLib::LiquidFlow::createLiquidFlowProcess(), and ProjectData::parseParameters().

◆ name

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

Definition at line 328 of file Process.h.

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess().

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

ProcessLib/Process.h
ProcessLib/Process.cpp

Detailed Description

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Member Typedef Documentation

◆ NonlinearSolver

◆ TimeDiscretization

Constructor & Destructor Documentation

◆ Process()

Member Function Documentation

◆ assemble()

◆ assembleConcreteProcess()

◆ assembleWithJacobian()

◆ assembleWithJacobianConcreteProcess()

◆ computeSecondaryVariable()

◆ computeSecondaryVariableConcrete()

◆ computeSparsityPattern()

◆ constructDofTable()

◆ constructDofTableOfSpecifiedProcessStaggeredScheme()

◆ constructMonolithicProcessDofTable()

◆ extrapolateIntegrationPointValuesToNodes()

◆ getDOFTable()

◆ getDOFTableForExtrapolatorData()

◆ getExtrapolator()

◆ getFlux()

◆ getIndicesOfResiduumWithoutInitialCompensation()

◆ getIntegrationPointWriters()

◆ getKnownSolutions()

◆ getMatrixSpecifications()

◆ getMesh()

◆ getProcessVariables()

◆ getSecondaryVariables()

◆ getSingleComponentDOFTable()

◆ initialize()

◆ initializeBoundaryConditions()

◆ initializeConcreteProcess()

◆ initializeExtrapolator()

◆ initializeProcessBoundaryConditionsAndSourceTerms()

◆ isMonolithicSchemeUsed()

◆ postIteration()

◆ postIterationConcreteProcess()

◆ postNonLinearSolver()

◆ postNonLinearSolverConcreteProcess()

◆ postTimestep()

◆ postTimestepConcreteProcess()

◆ preAssemble()

◆ preAssembleConcreteProcess()

◆ preIteration()

◆ preIterationConcreteProcess()

◆ preTimestep()

◆ preTimestepConcreteProcess()

◆ setCoupledSolutionsForStaggeredScheme()

◆ setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

◆ setInitialConditions()

◆ setInitialConditionsConcreteProcess()

◆ solveReactionEquation()

◆ updateDeactivatedSubdomains()

Member Data Documentation

◆ _boundary_conditions

◆ _coupled_solutions

◆ _extrapolator_data

◆ _global_assembler

◆ _integration_order

◆ _integration_point_writer

◆ _local_to_global_index_map

◆ _mesh

◆ _mesh_subset_all_nodes

◆ _process_variables

◆ _secondary_variables

◆ _source_term_collections

◆ _sparsity_pattern

◆ _use_monolithic_scheme

◆ constant_one_parameter_name

◆ name