Loading [MathJax]/extensions/tex2jax.js
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, 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::vector< std::reference_wrapper< ProcessVariable > > > const & getProcessVariables () const
 
std::vector< std::reference_wrapper< ProcessVariable > > const & getProcessVariables (const int process_id) const
 
std::vector< std::size_t > const & getActiveElementIDs () const
 
SecondaryVariableCollection const & getSecondaryVariables () const
 
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const & getIntegrationPointWriters () const
 
virtual Eigen::Vector3d getFlux (std::size_t, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &) const
 
virtual void solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)
 
bool requiresNormalization () const override
 
- Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::vector< std::string > > initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)
 
virtual ~SubmeshAssemblySupport ()=default
 

Public Attributes

std::string const name
 

Static Public Attributes

static PROCESSLIB_EXPORT const std::string constant_one_parameter_name = "constant_one"
 

Protected Member Functions

std::vector< NumLib::LocalToGlobalIndexMap const * > getDOFTables (int const number_of_processes) const
 
NumLib::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, 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:362
std::vector< BoundaryConditionCollection > _boundary_conditions
Definition Process.h:405
CellAverageData cell_average_data_
Definition Process.h:372
MeshLib::Mesh & _mesh
Definition Process.h:365
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > _process_variables
Definition Process.h:400
SecondaryVariableCollection _secondary_variables
Definition Process.h:370
VectorMatrixAssembler _global_assembler
Definition Process.h:377
unsigned const _integration_order
Definition Process.h:384
std::vector< SourceTermCollection > _source_term_collections
Definition Process.h:411
std::unique_ptr< ProcessLib::AbstractJacobianAssembler > _jacobian_assembler
Definition Process.h:376
const bool _use_monolithic_scheme
Definition Process.h:379

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

270{
271 assert(x.size() == x_prev.size());
272
273 setLocalAccessibleVectors(x, x_prev);
274
275 assembleConcreteProcess(t, dt, x, x_prev, process_id, M, K, b);
276
277 // the last argument is for the jacobian, nullptr is for a unused jacobian
278 _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, &K, b,
279 nullptr);
280
281 // the last argument is for the jacobian, nullptr is for a unused jacobian
282 _source_term_collections[process_id].integrate(t, *x[process_id], b,
283 nullptr);
284}
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::HeatConduction::HeatConductionProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >, 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::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, and ProcessLib::WellboreSimulator::WellboreSimulatorProcess.

Referenced by assemble().

◆ assembleWithJacobian()

void ProcessLib::Process::assembleWithJacobian ( const double t,
double const dt,
std::vector< GlobalVector * > const & x,
std::vector< GlobalVector * > const & x_prev,
int const process_id,
GlobalVector & b,
GlobalMatrix & Jac )
final

Definition at line 286 of file Process.cpp.

291{
292 assert(x.size() == x_prev.size());
293
294 setLocalAccessibleVectors(x, x_prev);
295
296 assembleWithJacobianConcreteProcess(t, dt, x, x_prev, process_id, b, Jac);
297
298 // TODO: apply BCs to Jacobian.
299 _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, nullptr,
300 b, &Jac);
301
302 // the last argument is for the jacobian, nullptr is for a unused jacobian
303 _source_term_collections[process_id].integrate(t, *x[process_id], b, &Jac);
304}
virtual void assembleWithJacobianConcreteProcess(const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac)=0

References _boundary_conditions, _source_term_collections, and assembleWithJacobianConcreteProcess().

◆ assembleWithJacobianConcreteProcess()

virtual void ProcessLib::Process::assembleWithJacobianConcreteProcess ( const double t,
double const dt,
std::vector< GlobalVector * > const & x,
std::vector< GlobalVector * > const & x_prev,
int const process_id,
GlobalVector & b,
GlobalMatrix & Jac )
privatepure virtual

Implemented in ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >, 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::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, and ProcessLib::WellboreSimulator::WellboreSimulatorProcess.

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

478{
479 for (auto const* solution : x)
482
483 computeSecondaryVariableConcrete(t, dt, x, x_prev, process_id);
484}
virtual void computeSecondaryVariableConcrete(double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)
Definition Process.h:293
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 435 of file Process.cpp.

436{
439}
std::unique_ptr< NumLib::LocalToGlobalIndexMap > _local_to_global_index_map
Definition Process.h:368
GlobalSparsityPattern _sparsity_pattern
Definition Process.h:392
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::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >.

Definition at line 306 of file Process.cpp.

307{
309 {
311
312 return;
313 }
314
315 // For staggered scheme:
316 const int specified_process_id = 0;
318}
void constructDofTableOfSpecifiedProcessStaggeredScheme(const int specified_process_id)
Definition Process.cpp:352
void constructMonolithicProcessDofTable()
Definition Process.cpp:320

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

354{
355 // Create single component dof in every of the mesh nodes.
357 std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
358
359 // Vector of mesh subsets.
360 std::vector<MeshLib::MeshSubset> all_mesh_subsets;
361
362 // Vector of the number of variable components
363 std::vector<int> vec_var_n_components;
364 // Collect the mesh subsets in a vector for each variables' components.
365 std::generate_n(std::back_inserter(all_mesh_subsets),
366 _process_variables[specified_process_id][0]
367 .get()
368 .getNumberOfGlobalComponents(),
369 [&]() { return *_mesh_subset_all_nodes; });
370
371 // Create a vector of the number of variable components.
372 vec_var_n_components.push_back(_process_variables[specified_process_id][0]
373 .get()
374 .getNumberOfGlobalComponents());
376 std::make_unique<NumLib::LocalToGlobalIndexMap>(
377 std::move(all_mesh_subsets), vec_var_n_components,
379
381}
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition Mesh.h:108
std::unique_ptr< MeshLib::MeshSubset const > _mesh_subset_all_nodes
Definition Process.h:366
@ 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 320 of file Process.cpp.

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

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

Referenced by constructDofTable().

◆ extrapolateIntegrationPointValuesToNodes()

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

Definition at line 107 of file Process.h.

111 {
112 }

◆ getActiveElementIDs()

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

Definition at line 167 of file Process.h.

168 {
170 }
std::vector< std::size_t > _ids_of_active_elements
Union of active element ids per process variable.
Definition Process.h:416

References _ids_of_active_elements.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::computeSecondaryVariableConcrete(), ProcessLib::HeatConduction::HeatConductionProcess::computeSecondaryVariableConcrete(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::computeSecondaryVariableConcrete(), ProcessLib::LiquidFlow::LiquidFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::computeSecondaryVariableConcrete(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::postTimestepConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation(), ProcessLib::AssemblyMixinBase::updateActiveElements(), and ProcessLib::AssemblyMixinBase::updateActiveElementsImpl().

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

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

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

385{
386 std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
387 dof_tables.reserve(number_of_processes);
388 std::generate_n(std::back_inserter(dof_tables), number_of_processes,
389 [&]() { return &getDOFTable(dof_tables.size()); });
390 return dof_tables;
391}
virtual NumLib::LocalToGlobalIndexMap const & getDOFTable(const int) const
Definition Process.h:147

References getDOFTable().

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

◆ getExtrapolator()

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

511{
512 std::vector<GlobalIndexType> indices;
513
514 for (std::size_t process_id = 0; process_id < _process_variables.size();
515 process_id++)
516 {
517 auto const& dof_table_of_process = getDOFTable(process_id);
518
519 auto const& per_process_variables = _process_variables[process_id];
520 for (std::size_t variable_id = 0;
521 variable_id < per_process_variables.size();
522 variable_id++)
523 {
524 auto const& pv = per_process_variables[variable_id];
525 DBUG("Set the initial condition of variable {:s} of process {:d}.",
526 pv.get().getName().data(), process_id);
527
528 if ((pv.get().compensateNonEquilibriumInitialResiduum()))
529 {
530 continue;
531 }
532
533 auto const num_comp = pv.get().getNumberOfGlobalComponents();
534
535 for (int component_id = 0; component_id < num_comp; ++component_id)
536 {
537 auto const& mesh_subset = dof_table_of_process.getMeshSubset(
538 variable_id, component_id);
539 for (auto const& l : MeshLib::views::meshLocations(
540 mesh_subset, MeshLib::MeshItemType::Node))
541 {
542 auto global_index =
543 std::abs(dof_table_of_process.getGlobalIndex(
544 l, variable_id, component_id));
545
546 indices.push_back(global_index);
547 }
548 }
549 }
550 }
551
552 return indices;
553}
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
auto meshLocations(Mesh const &mesh, MeshItemType const item_type)
Definition Mesh.h:238

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

◆ getIntegrationPointWriters()

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

Definition at line 178 of file Process.h.

179 {
181 }
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > _integration_point_writer
Definition Process.h:390

References _integration_point_writer.

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

◆ getKnownSolutions()

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

Definition at line 141 of file Process.h.

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

References _boundary_conditions.

◆ getMatrixSpecifications()

◆ getMesh()

◆ getProcessVariables() [1/2]

◆ getProcessVariables() [2/2]

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

Definition at line 162 of file Process.h.

163 {
164 return _process_variables[process_id];
165 }

References _process_variables.

◆ getSecondaryVariables()

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

Definition at line 172 of file Process.h.

173 {
175 }

References _secondary_variables.

Referenced by ProcessLib::createProcessOutputData().

◆ getSingleComponentDOFTable()

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

Definition at line 213 of file Process.h.

214 {
216 }
NumLib::LocalToGlobalIndexMap const & getDOFTable() const

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

◆ 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:418
virtual void constructDofTable()
Definition Process.cpp:306
void computeSparsityPattern()
Definition Process.cpp:435

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::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< 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::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >, 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::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, and ProcessLib::WellboreSimulator::WellboreSimulatorProcess.

Referenced by initialize().

◆ initializeExtrapolator()

void ProcessLib::Process::initializeExtrapolator ( )
private

Definition at line 418 of file Process.cpp.

419{
420 NumLib::LocalToGlobalIndexMap* dof_table_single_component;
421 bool manage_storage;
422
423 std::tie(dof_table_single_component, manage_storage) =
425
426 std::unique_ptr<NumLib::Extrapolator> extrapolator(
428 *dof_table_single_component));
429
430 // TODO: Later on the DOF table can change during the simulation!
431 _extrapolator_data = ExtrapolatorData(
432 std::move(extrapolator), dof_table_single_component, manage_storage);
433}
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool > getDOFTableForExtrapolatorData() const
Definition Process.cpp:394

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, _mesh);
103}

References _boundary_conditions, _integration_order, _mesh, _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 492 of file Process.cpp.

493{
496}
virtual NumLib::IterationResult postIterationConcreteProcess(GlobalVector const &)
Definition Process.h:302

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

◆ postIterationConcreteProcess()

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

Reimplemented in ProcessLib::HeatTransportBHE::HeatTransportBHEProcess.

Definition at line 302 of file Process.h.

References NumLib::SUCCESS.

Referenced by postIteration().

◆ postNonLinearSolver()

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

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

Definition at line 463 of file Process.cpp.

467{
468 setLocalAccessibleVectors(x, x_prev);
469
470 postNonLinearSolverConcreteProcess(x, x_prev, t, dt, process_id);
471}
virtual void postNonLinearSolverConcreteProcess(std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, double const, int const)
Definition Process.h:281

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

455{
456 setLocalAccessibleVectors(x, x_prev);
457
458 postTimestepConcreteProcess(x, x_prev, t, delta_t, process_id);
459
460 _boundary_conditions[process_id].postTimestep(t, x, process_id);
461}
virtual void postTimestepConcreteProcess(std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, const double, const double, int const)
Definition Process.h:272

References _boundary_conditions, and postTimestepConcreteProcess().

◆ postTimestepConcreteProcess()

◆ preAssemble()

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

Definition at line 259 of file Process.cpp.

261{
263}
virtual void preAssembleConcreteProcess(const double, double const, GlobalVector const &)
Definition Process.h:248

References preAssembleConcreteProcess().

◆ preAssembleConcreteProcess()

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

Definition at line 248 of file Process.h.

251 {
252 }

Referenced by preAssemble().

◆ preIteration()

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

Definition at line 486 of file Process.cpp.

487{
490}
virtual void preIterationConcreteProcess(const unsigned, GlobalVector const &)
Definition Process.h:288

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

◆ preIterationConcreteProcess()

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

Definition at line 288 of file Process.h.

290 {
291 }

Referenced by preIteration().

◆ preOutput()

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

Definition at line 498 of file Process.cpp.

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

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

443{
444 for (auto* const solution : x)
446 preTimestepConcreteProcess(x, t, delta_t, process_id);
447
448 _boundary_conditions[process_id].preTimestep(t, x, process_id);
449}
virtual void preTimestepConcreteProcess(std::vector< GlobalVector * > const &, const double, const double, const int)
Definition Process.h:264

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

◆ preTimestepConcreteProcess()

◆ requiresNormalization()

bool ProcessLib::Process::requiresNormalization ( ) const
inlineoverride

Definition at line 202 of file Process.h.

202{ return false; }

◆ setInitialConditions()

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

Definition at line 140 of file Process.cpp.

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

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

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

199 {
200 }

◆ updateDeactivatedSubdomains()

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

Definition at line 218 of file Process.cpp.

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

References _ids_of_active_elements, and getProcessVariables().

Member Data Documentation

◆ _boundary_conditions

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

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

Definition at line 405 of file Process.h.

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

◆ _extrapolator_data

ExtrapolatorData ProcessLib::Process::_extrapolator_data
private

Definition at line 413 of file Process.h.

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

◆ _global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler
protected

Definition at line 377 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::WellboreSimulator::WellboreSimulatorProcess::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 416 of file Process.h.

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _integration_order

unsigned const ProcessLib::Process::_integration_order
protected

◆ _integration_point_writer

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

◆ _jacobian_assembler

◆ _local_to_global_index_map

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

Definition at line 368 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleWithJacobianConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::computeSecondaryVariableConcrete(), computeSparsityPattern(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getDOFTable(), ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData(), getDOFTableForExtrapolatorData(), ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), ProcessLib::LiquidFlow::LiquidFlowProcess::getFlux(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux(), getMatrixSpecifications(), initialize(), initializeBoundaryConditions(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::WellboreSimulator::WellboreSimulatorProcess::postTimestepConcreteProcess(), 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 411 of file Process.h.

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

◆ _sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern
protected

Definition at line 392 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

◆ _use_monolithic_scheme

◆ cell_average_data_

CellAverageData ProcessLib::Process::cell_average_data_
protected

Definition at line 372 of file Process.h.

◆ constant_one_parameter_name

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

◆ name


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