OGS
ProcessLib::Process Class Referenceabstract

Detailed Description

Definition at line 40 of file Process.h.

#include <Process.h>

Inheritance diagram for ProcessLib::Process:
[legend]
Collaboration diagram for ProcessLib::Process:
[legend]

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, GlobalMatrix &M, GlobalMatrix &K, 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::MeshgetMesh () 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)
 
- Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual 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::ExtrapolatorgetExtrapolator () 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< GlobalIndexTypegetIndicesOfResiduumWithoutInitialCompensation () 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, 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 &, 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.

54 : name(std::move(name_)),
55 _mesh(mesh),
56 _secondary_variables(std::move(secondary_variables)),
58 _jacobian_assembler(std::move(jacobian_assembler)),
60 _use_monolithic_scheme(use_monolithic_scheme),
61 _integration_order(integration_order),
62 _process_variables(std::move(process_variables)),
64 [&](const std::size_t number_of_process_variables)
65 -> std::vector<BoundaryConditionCollection>
66 {
67 std::vector<BoundaryConditionCollection> pcs_BCs;
68 pcs_BCs.reserve(number_of_process_variables);
69 for (std::size_t i = 0; i < number_of_process_variables; i++)
70 {
71 pcs_BCs.emplace_back(BoundaryConditionCollection(parameters));
72 }
73 return pcs_BCs;
74 }(_process_variables.size())),
76 [&](const std::size_t number_of_processes)
77 -> std::vector<SourceTermCollection>
78 {
79 std::vector<SourceTermCollection> pcs_sts;
80 pcs_sts.reserve(number_of_processes);
81 for (std::size_t i = 0; i < number_of_processes; i++)
82 {
83 pcs_sts.emplace_back(SourceTermCollection(parameters));
84 }
85 return pcs_sts;
86 }(_process_variables.size()))
87{
88}
std::string const name
Definition Process.h:355
std::vector< BoundaryConditionCollection > _boundary_conditions
Definition Process.h:398
CellAverageData cell_average_data_
Definition Process.h:365
MeshLib::Mesh & _mesh
Definition Process.h:358
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > _process_variables
Definition Process.h:393
SecondaryVariableCollection _secondary_variables
Definition Process.h:363
VectorMatrixAssembler _global_assembler
Definition Process.h:370
unsigned const _integration_order
Definition Process.h:377
std::vector< SourceTermCollection > _source_term_collections
Definition Process.h:404
std::unique_ptr< ProcessLib::AbstractJacobianAssembler > _jacobian_assembler
Definition Process.h:369
const bool _use_monolithic_scheme
Definition Process.h:372

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.

271{
272 assert(x.size() == x_prev.size());
273
274 setLocalAccessibleVectors(x, x_prev);
275
276 assembleConcreteProcess(t, dt, x, x_prev, process_id, M, K, b);
277
278 // the last argument is for the jacobian, nullptr is for a unused jacobian
279 _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
280 nullptr);
281
282 // the last argument is for the jacobian, nullptr is for a unused jacobian
283 _source_term_collections[process_id].integrate(t, *x[process_id], b,
284 nullptr);
285}
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
void setLocalAccessibleVectors(std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev)
Definition Process.cpp:26

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

Implemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HT::HTProcess, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TES::TESProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >, and ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >.

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,
GlobalMatrix & M,
GlobalMatrix & K,
GlobalVector & b,
GlobalMatrix & Jac )
final

Definition at line 287 of file Process.cpp.

293{
294 assert(x.size() == x_prev.size());
295
296 setLocalAccessibleVectors(x, x_prev);
297
298 assembleWithJacobianConcreteProcess(t, dt, x, x_prev, process_id, M, K, b,
299 Jac);
300
301 // TODO: apply BCs to Jacobian.
302 _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
303 &Jac);
304
305 // the last argument is for the jacobian, nullptr is for a unused jacobian
306 _source_term_collections[process_id].integrate(t, *x[process_id], b, &Jac);
307}
virtual void assembleWithJacobianConcreteProcess(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, GlobalMatrix &Jac)=0

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,
GlobalMatrix & M,
GlobalMatrix & K,
GlobalVector & b,
GlobalMatrix & Jac )
privatepure virtual

Implemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HT::HTProcess, ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TES::TESProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::HeatConduction::HeatConductionProcess, and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

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

482{
483 for (auto const* solution : x)
486
487 computeSecondaryVariableConcrete(t, dt, x, x_prev, process_id);
488}
virtual void computeSecondaryVariableConcrete(double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)
Definition Process.h:286
void setLocalAccessibleVector(PETScVector const &x)
Definition LinAlg.cpp:27

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

◆ computeSecondaryVariableConcrete()

◆ computeSparsityPattern()

void ProcessLib::Process::computeSparsityPattern ( )
private

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

Definition at line 439 of file Process.cpp.

440{
443}
std::unique_ptr< NumLib::LocalToGlobalIndexMap > _local_to_global_index_map
Definition Process.h:361
GlobalSparsityPattern _sparsity_pattern
Definition Process.h:385
GlobalSparsityPattern computeSparsityPattern(LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh)
Computes a sparsity pattern for the given inputs.

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.

Reimplemented in ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< 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 309 of file Process.cpp.

310{
312 {
314
315 return;
316 }
317
318 // For staggered scheme:
319 const int specified_process_id = 0;
321}
void constructDofTableOfSpecifiedProcessStaggeredScheme(const int specified_process_id)
Definition Process.cpp:356
void constructMonolithicProcessDofTable()
Definition Process.cpp:323

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

358{
359 // Create single component dof in every of the mesh nodes.
361 std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
362
363 // Vector of mesh subsets.
364 std::vector<MeshLib::MeshSubset> all_mesh_subsets;
365
366 // Vector of the number of variable components
367 std::vector<int> vec_var_n_components;
368 // Collect the mesh subsets in a vector for each variables' components.
369 std::generate_n(std::back_inserter(all_mesh_subsets),
370 _process_variables[specified_process_id][0]
371 .get()
372 .getNumberOfGlobalComponents(),
373 [&]() { return *_mesh_subset_all_nodes; });
374
375 // Create a vector of the number of variable components.
376 vec_var_n_components.push_back(_process_variables[specified_process_id][0]
377 .get()
378 .getNumberOfGlobalComponents());
380 std::make_unique<NumLib::LocalToGlobalIndexMap>(
381 std::move(all_mesh_subsets), vec_var_n_components,
383
385}
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition Mesh.h:106
std::unique_ptr< MeshLib::MeshSubset const > _mesh_subset_all_nodes
Definition Process.h:359
@ BY_LOCATION
Ordering data by spatial location.
auto & get(Tuples &... ts)
Definition Get.h:59

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

324{
325 // Create single component dof in every of the mesh nodes.
327 std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
328
329 // Vector of mesh subsets.
330 std::vector<MeshLib::MeshSubset> all_mesh_subsets;
331
332 // Collect the mesh subsets in a vector for the components of each
333 // variables.
334 for (ProcessVariable const& pv : _process_variables[0])
335 {
336 std::generate_n(std::back_inserter(all_mesh_subsets),
337 pv.getNumberOfGlobalComponents(),
338 [&]() { return *_mesh_subset_all_nodes; });
339 }
340
341 // Create a vector of the number of variable components
342 std::vector<int> vec_var_n_components;
343 transform(cbegin(_process_variables[0]), cend(_process_variables[0]),
344 back_inserter(vec_var_n_components),
345 [](ProcessVariable const& pv)
346 { return pv.getNumberOfGlobalComponents(); });
347
349 std::make_unique<NumLib::LocalToGlobalIndexMap>(
350 std::move(all_mesh_subsets), vec_var_n_components,
352
354}

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

162 {
164 }
std::vector< std::size_t > _ids_of_active_elements
Union of active element ids per process variable.
Definition Process.h:409

References _ids_of_active_elements.

Referenced by updateDeactivatedSubdomains().

◆ getDOFTable()

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

399{
400 if (_local_to_global_index_map->getNumberOfGlobalComponents() == 1)
401 {
402 // For single-variable-single-component processes reuse the existing DOF
403 // table.
404 const bool manage_storage = false;
405 return std::make_tuple(_local_to_global_index_map.get(),
406 manage_storage);
407 }
408
409 // Otherwise construct a new DOF table.
410 std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component;
411 all_mesh_subsets_single_component.emplace_back(*_mesh_subset_all_nodes);
412
413 const bool manage_storage = true;
414
415 return std::make_tuple(new NumLib::LocalToGlobalIndexMap(
416 std::move(all_mesh_subsets_single_component),
417 // by location order is needed for output
419 manage_storage);
420}

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

389{
390 std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
391 dof_tables.reserve(number_of_processes);
392 std::generate_n(std::back_inserter(dof_tables), number_of_processes,
393 [&]() { return &getDOFTable(dof_tables.size()); });
394 return dof_tables;
395}
virtual NumLib::LocalToGlobalIndexMap const & getDOFTable(const int) const
Definition Process.h:148

References getDOFTable().

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::setInitialConditionsConcreteProcess().

◆ getExtrapolator()

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

◆ getFlux()

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

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

515{
516 std::vector<GlobalIndexType> indices;
517
518 for (std::size_t process_id = 0; process_id < _process_variables.size();
519 process_id++)
520 {
521 auto const& dof_table_of_process = getDOFTable(process_id);
522
523 auto const& per_process_variables = _process_variables[process_id];
524 for (std::size_t variable_id = 0;
525 variable_id < per_process_variables.size();
526 variable_id++)
527 {
528 auto const& pv = per_process_variables[variable_id];
529 DBUG("Set the initial condition of variable {:s} of process {:d}.",
530 pv.get().getName().data(), process_id);
531
532 if ((pv.get().compensateNonEquilibriumInitialResiduum()))
533 {
534 continue;
535 }
536
537 auto const num_comp = pv.get().getNumberOfGlobalComponents();
538
539 for (int component_id = 0; component_id < num_comp; ++component_id)
540 {
541 auto const& mesh_subset = dof_table_of_process.getMeshSubset(
542 variable_id, component_id);
543 auto const mesh_id = mesh_subset.getMeshID();
544 for (auto const* node : mesh_subset.getNodes())
545 {
546 MeshLib::Location const l(
547 mesh_id, MeshLib::MeshItemType::Node, node->getID());
548
549 auto global_index =
550 std::abs(dof_table_of_process.getGlobalIndex(
551 l, variable_id, component_id));
552
553 indices.push_back(global_index);
554 }
555 }
556 }
557 }
558
559 return indices;
560}
std::vector< std::size_t > getNodes(GeoLib::Point const &pnt, std::vector< MeshLib::Node * > const &nodes, MeshLib::PropertyVector< int > const &mat_ids, std::pair< int, int > const &mat_limits, std::pair< double, double > const &elevation_limits, MeshLib::Mesh const &mesh)
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30

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

173 {
175 }
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > _integration_point_writer
Definition Process.h:383

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

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

References _boundary_conditions.

◆ getMatrixSpecifications()

◆ getMesh()

◆ getProcessVariables()

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

Definition at line 156 of file Process.h.

157 {
158 return _process_variables[process_id];
159 }

References _process_variables.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::AssemblyMixin< Process >::assembleGeneric(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::computeSecondaryVariableConcrete(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::computeSecondaryVariableConcrete(), ProcessLib::LiquidFlow::LiquidFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ComponentTransport::ComponentTransportProcess::computeSecondaryVariableConcrete(), ProcessLib::createConstraintDirichletBoundaryCondition(), anonymous_namespace{ProcessOutputData.cpp}::getProcessVariablesOfAllProcesses(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::initializeConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation(), ProcessLib::AssemblyMixin< Process >::updateActiveElements(), and updateDeactivatedSubdomains().

◆ getSecondaryVariables()

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

Definition at line 166 of file Process.h.

167 {
169 }

References _secondary_variables.

Referenced by ProcessLib::createProcessOutputData().

◆ getSingleComponentDOFTable()

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

◆ initialize()

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

Definition at line 119 of file Process.cpp.

121{
122 DBUG("Initialize process.");
123
124 DBUG("Construct dof mappings.");
126
127 DBUG("Compute sparsity pattern");
129
130 DBUG("Initialize the extrapolator");
132
135
136 DBUG("Initialize boundary conditions.");
138}
virtual void initializeBoundaryConditions(std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
Definition Process.cpp:105
virtual void initializeConcreteProcess(NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order)=0
Process specific initialization called by initialize().
void initializeExtrapolator()
Definition Process.cpp:422
virtual void constructDofTable()
Definition Process.cpp:309
void computeSparsityPattern()
Definition Process.cpp:439

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.

107{
108 // The number of processes is identical to the size of _process_variables,
109 // the vector contains variables for different processes. See the
110 // documentation of _process_variables.
111 const std::size_t number_of_processes = _process_variables.size();
112 for (std::size_t pcs_id = 0; pcs_id < number_of_processes; pcs_id++)
113 {
115 *_local_to_global_index_map, pcs_id, media);
116 }
117}
void initializeProcessBoundaryConditionsAndSourceTerms(const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
Definition Process.cpp:90

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

Implemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HT::HTProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::TES::TESProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, and ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess.

Referenced by initialize().

◆ initializeExtrapolator()

void ProcessLib::Process::initializeExtrapolator ( )
private

Definition at line 422 of file Process.cpp.

423{
424 NumLib::LocalToGlobalIndexMap* dof_table_single_component;
425 bool manage_storage;
426
427 std::tie(dof_table_single_component, manage_storage) =
429
430 std::unique_ptr<NumLib::Extrapolator> extrapolator(
432 *dof_table_single_component));
433
434 // TODO: Later on the DOF table can change during the simulation!
435 _extrapolator_data = ExtrapolatorData(
436 std::move(extrapolator), dof_table_single_component, manage_storage);
437}
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool > getDOFTableForExtrapolatorData() const
Definition Process.cpp:398

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.

93{
94 auto const& per_process_variables = _process_variables[process_id];
95 auto& per_process_BCs = _boundary_conditions[process_id];
96
97 per_process_BCs.addBCsForProcessVariables(per_process_variables, dof_table,
98 _integration_order, *this, media);
99
100 auto& per_process_sts = _source_term_collections[process_id];
101 per_process_sts.addSourceTermsForProcessVariables(
102 per_process_variables, dof_table, _integration_order);
103}

References _boundary_conditions, _integration_order, _process_variables, and _source_term_collections.

Referenced by initializeBoundaryConditions().

◆ isMonolithicSchemeUsed()

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

◆ postIteration()

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

Definition at line 496 of file Process.cpp.

497{
500}
virtual NumLib::IterationResult postIterationConcreteProcess(GlobalVector const &)
Definition Process.h:295

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

◆ postIterationConcreteProcess()

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

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

471{
472 setLocalAccessibleVectors(x, x_prev);
473
474 postNonLinearSolverConcreteProcess(x, x_prev, t, dt, process_id);
475}
virtual void postNonLinearSolverConcreteProcess(std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, double const, int const)
Definition Process.h:274

References postNonLinearSolverConcreteProcess().

◆ postNonLinearSolverConcreteProcess()

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

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

459{
460 setLocalAccessibleVectors(x, x_prev);
461
462 postTimestepConcreteProcess(x, x_prev, t, delta_t, process_id);
463
464 _boundary_conditions[process_id].postTimestep(t, x, process_id);
465}
virtual void postTimestepConcreteProcess(std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, const double, int const)
Definition Process.h:265

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

◆ preAssemble()

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

Definition at line 260 of file Process.cpp.

262{
264}
virtual void preAssembleConcreteProcess(const double, double const, GlobalVector const &)
Definition Process.h:240

References preAssembleConcreteProcess().

◆ preAssembleConcreteProcess()

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

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

Definition at line 240 of file Process.h.

243 {
244 }

Referenced by preAssemble().

◆ preIteration()

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

Definition at line 490 of file Process.cpp.

491{
494}
virtual void preIterationConcreteProcess(const unsigned, GlobalVector const &)
Definition Process.h:281

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

283 {
284 }

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

506{
507 for (auto const* solution : x)
509
510 preOutputConcreteProcess(t, dt, x, x_prev, process_id);
511}
virtual void preOutputConcreteProcess(const double, double const, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, int const)
Definition Process.h:301

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

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

447{
448 for (auto* const solution : x)
450 preTimestepConcreteProcess(x, t, delta_t, process_id);
451
452 _boundary_conditions[process_id].preTimestep(t, x, process_id);
453}
virtual void preTimestepConcreteProcess(std::vector< GlobalVector * > const &, const double, const double, const int)
Definition Process.h:257

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

◆ preTimestepConcreteProcess()

◆ 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.

145{
146 auto& x = *process_solutions[process_id];
147 auto& x_prev = *process_solutions_prev[process_id];
148
149 // getDOFTableOfProcess can be overloaded by the specific process.
150 auto const& dof_table_of_process = getDOFTable(process_id);
151
152 auto const& per_process_variables = _process_variables[process_id];
153 for (std::size_t variable_id = 0;
154 variable_id < per_process_variables.size();
155 variable_id++)
156 {
159
160 auto const& pv = per_process_variables[variable_id];
161 DBUG("Set the initial condition of variable {:s} of process {:d}.",
162 pv.get().getName().data(), process_id);
163
164 auto const& ic = pv.get().getInitialCondition();
165
166 auto const num_comp = pv.get().getNumberOfGlobalComponents();
167
168 for (int component_id = 0; component_id < num_comp; ++component_id)
169 {
170 auto const& mesh_subset =
171 dof_table_of_process.getMeshSubset(variable_id, component_id);
172 auto const mesh_id = mesh_subset.getMeshID();
173 for (auto const* node : mesh_subset.getNodes())
174 {
176 node->getID());
177
178 pos.setNodeID(node->getID());
179 pos.setCoordinates(*node);
180 auto const& ic_value = ic(t, pos);
181
182 auto global_index =
183 std::abs(dof_table_of_process.getGlobalIndex(l, variable_id,
184 component_id));
185#ifdef USE_PETSC
186 // The global indices of the ghost entries of the global
187 // matrix or the global vectors need to be set as negative
188 // values for equation assembly, however the global indices
189 // start from zero. Therefore, any ghost entry with zero
190 // index is assigned an negative value of the vector size
191 // or the matrix dimension. To assign the initial value for
192 // the ghost entries, the negative indices of the ghost
193 // entries are restored to zero.
194 if (global_index == x.size())
195 global_index = 0;
196#endif
197 x.set(global_index, ic_value[component_id]);
198 }
199 }
200 }
201
203 MathLib::LinAlg::copy(x, x_prev); // pushState
204
207
208 setInitialConditionsConcreteProcess(process_solutions, t, process_id);
209}
void setNodeID(std::size_t node_id)
void setCoordinates(MathLib::Point3d const &coordinates)
virtual void setInitialConditionsConcreteProcess(std::vector< GlobalVector * > &, double const, int const)
Definition Process.h:233
void finalizeAssembly(PETScMatrix &A)
Definition LinAlg.cpp:170
void copy(PETScVector const &x, PETScVector &y)
Definition LinAlg.cpp:37

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

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

193 {
194 }

◆ updateDeactivatedSubdomains()

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

Definition at line 219 of file Process.cpp.

221{
222 auto const& variables_per_process = getProcessVariables(process_id);
223 for (auto const& variable : variables_per_process)
224 {
225 variable.get().updateDeactivatedSubdomains(time);
226 }
227
229
230 auto active_elements_ids = ranges::views::transform(
231 [](auto const& variable)
232 { return variable.get().getActiveElementIDs(); });
233
234 // Early return if there's any process variable with all elements active.
235 if (ranges::any_of(variables_per_process | active_elements_ids,
236 [](auto const& vector) { return vector.empty(); }))
237 {
238 return;
239 }
240
241 // Some process variable has deactivated elements. Create union of active
242 // ids.
243
244 _ids_of_active_elements = // there is at least one process variable.
245 variables_per_process[0].get().getActiveElementIDs();
246
247 for (auto const& pv_active_element_ids :
248 variables_per_process | ranges::views::drop(1) | active_elements_ids)
249 {
250 std::vector<std::size_t> new_active_elements;
251 new_active_elements.reserve(_ids_of_active_elements.size() +
252 pv_active_element_ids.size());
253 ranges::set_union(_ids_of_active_elements, pv_active_element_ids,
254 std::back_inserter(new_active_elements));
255
256 _ids_of_active_elements = std::move(new_active_elements);
257 }
258}
std::vector< std::size_t > const & getActiveElementIDs() const
Definition Process.h:161
std::vector< std::reference_wrapper< ProcessVariable > > const & getProcessVariables(const int process_id) const
Definition Process.h:156

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

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

◆ _global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler
protected

Definition at line 370 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess().

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

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _integration_order

unsigned const ProcessLib::Process::_integration_order
protected

◆ _integration_point_writer

◆ _jacobian_assembler

◆ _local_to_global_index_map

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

Definition at line 361 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::AssemblyMixin< Process >::assembleGeneric(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), computeSparsityPattern(), ProcessLib::TES::TESProcess::computeVapourPartialPressure(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getDOFTable(), getDOFTableForExtrapolatorData(), ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData(), ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::LiquidFlow::LiquidFlowProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux(), getMatrixSpecifications(), initialize(), initializeBoundaryConditions(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::TES::TESProcess::postIterationConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::preOutputConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::preOutputConcreteProcess(), and ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess().

◆ _mesh

◆ _mesh_subset_all_nodes

◆ _process_variables

◆ _secondary_variables

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

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

◆ _sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern
protected

Definition at line 385 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

◆ _use_monolithic_scheme

◆ cell_average_data_

CellAverageData ProcessLib::Process::cell_average_data_
protected

Definition at line 365 of file Process.h.

◆ constant_one_parameter_name

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

◆ name

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

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