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 Types

using NonlinearSolver = NumLib::NonlinearSolverBase
 
using TimeDiscretization = NumLib::TimeDiscretization
 

Public Member Functions

 Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)
 
void preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
 Preprocessing before starting assembly for new timestep. More...
 
void postTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, int const process_id)
 Postprocessing after a complete timestep. More...
 
void postNonLinearSolver (GlobalVector const &x, GlobalVector const &xdot, const double t, double const dt, int const process_id)
 
void preIteration (const unsigned iter, GlobalVector const &x) final
 
void computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_dot, int const process_id)
 compute secondary variables for the coupled equations or for output. More...
 
NumLib::IterationResult postIteration (GlobalVector const &x) final
 
void initialize ()
 
void setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)
 
MathLib::MatrixSpecifications getMatrixSpecifications (const int process_id) const override
 
void setCoupledSolutionsForStaggeredScheme (CoupledSolutionsForStaggeredScheme *const coupled_solutions)
 
void updateDeactivatedSubdomains (double const time, const int process_id)
 
bool isMonolithicSchemeUsed () const
 
virtual void setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int const)
 
virtual void extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)
 
void preAssemble (const double t, double const dt, GlobalVector const &x) final
 
void assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) final
 
void assembleWithJacobian (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) final
 
std::vector< NumLib::IndexValueVector< GlobalIndexType > > const * getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final
 
virtual NumLib::LocalToGlobalIndexMap const & getDOFTable (const int) const
 
MeshLib::MeshgetMesh () const
 
std::vector< std::reference_wrapper< ProcessVariable > > const & getProcessVariables (const int process_id) const
 
SecondaryVariableCollection const & getSecondaryVariables () const
 
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const & getIntegrationPointWriters () const
 
virtual Eigen::Vector3d getFlux (std::size_t, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &) const
 
virtual void solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)
 

Public Attributes

std::string const name
 

Static Public Attributes

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

Protected Member Functions

NumLib::ExtrapolatorgetExtrapolator () const
 
NumLib::LocalToGlobalIndexMap const & getSingleComponentDOFTable () const
 
void initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id)
 
virtual void constructDofTable ()
 
void constructMonolithicProcessDofTable ()
 
void constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_prosess_id)
 
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool > getDOFTableForExtrapolatorData () const
 
std::vector< 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
 
VectorMatrixAssembler _global_assembler
 
const bool _use_monolithic_scheme
 
CoupledSolutionsForStaggeredScheme_coupled_solutions
 
unsigned const _integration_order
 
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > _integration_point_writer
 
GlobalSparsityPattern _sparsity_pattern
 
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > _process_variables
 
std::vector< BoundaryConditionCollection_boundary_conditions
 

Private Member Functions

virtual void initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order)=0
 Process specific initialization called by initialize(). More...
 
virtual void initializeBoundaryConditions ()
 
virtual void setInitialConditionsConcreteProcess (std::vector< GlobalVector * > &, double const, int const)
 
virtual void preAssembleConcreteProcess (const double, double const, GlobalVector const &)
 
virtual void assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)=0
 
virtual void assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac)=0
 
virtual void preTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, const int)
 
virtual void postTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, int const)
 
virtual void postNonLinearSolverConcreteProcess (GlobalVector const &, GlobalVector const &, const double, double const, int const)
 
virtual void preIterationConcreteProcess (const unsigned, GlobalVector const &)
 
virtual void computeSecondaryVariableConcrete (double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)
 
virtual NumLib::IterationResult postIterationConcreteProcess (GlobalVector const &)
 
void initializeExtrapolator ()
 
void computeSparsityPattern ()
 

Private Attributes

std::vector< SourceTermCollection_source_term_collections
 
ExtrapolatorData _extrapolator_data
 

Member Typedef Documentation

◆ NonlinearSolver

◆ TimeDiscretization

Constructor & Destructor Documentation

◆ Process()

ProcessLib::Process::Process ( std::string  name_,
MeshLib::Mesh mesh,
std::unique_ptr< AbstractJacobianAssembler > &&  jacobian_assembler,
std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &  parameters,
unsigned const  integration_order,
std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&  process_variables,
SecondaryVariableCollection &&  secondary_variables,
const bool  use_monolithic_scheme = true 
)

Definition at line 24 of file Process.cpp.

34  : name(std::move(name_)),
35  _mesh(mesh),
36  _secondary_variables(std::move(secondary_variables)),
37  _global_assembler(std::move(jacobian_assembler)),
38  _use_monolithic_scheme(use_monolithic_scheme),
39  _coupled_solutions(nullptr),
40  _integration_order(integration_order),
41  _process_variables(std::move(process_variables)),
43  [&](const std::size_t number_of_process_variables)
44  -> std::vector<BoundaryConditionCollection>
45  {
46  std::vector<BoundaryConditionCollection> pcs_BCs;
47  pcs_BCs.reserve(number_of_process_variables);
48  for (std::size_t i = 0; i < number_of_process_variables; i++)
49  {
50  pcs_BCs.emplace_back(BoundaryConditionCollection(parameters));
51  }
52  return pcs_BCs;
53  }(_process_variables.size())),
55  [&](const std::size_t number_of_processes)
56  -> std::vector<SourceTermCollection>
57  {
58  std::vector<SourceTermCollection> pcs_sts;
59  pcs_sts.reserve(number_of_processes);
60  for (std::size_t i = 0; i < number_of_processes; i++)
61  {
62  pcs_sts.emplace_back(SourceTermCollection(parameters));
63  }
64  return pcs_sts;
65  }(_process_variables.size()))
66 {
67 }
std::string const name
Definition: Process.h:328
std::vector< BoundaryConditionCollection > _boundary_conditions
Definition: Process.h:370
MeshLib::Mesh & _mesh
Definition: Process.h:331
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > _process_variables
Definition: Process.h:365
SecondaryVariableCollection _secondary_variables
Definition: Process.h:336
CoupledSolutionsForStaggeredScheme * _coupled_solutions
Definition: Process.h:344
VectorMatrixAssembler _global_assembler
Definition: Process.h:338
unsigned const _integration_order
Definition: Process.h:349
std::vector< SourceTermCollection > _source_term_collections
Definition: Process.h:376
const bool _use_monolithic_scheme
Definition: Process.h:340

Member Function Documentation

◆ assemble()

void ProcessLib::Process::assemble ( const double  t,
double const  dt,
std::vector< GlobalVector * > const &  x,
std::vector< GlobalVector * > const &  xdot,
int const  process_id,
GlobalMatrix M,
GlobalMatrix K,
GlobalVector b 
)
final

Definition at line 211 of file Process.cpp.

216 {
217  assert(x.size() == xdot.size());
218  for (std::size_t i = 0; i < x.size(); i++)
219  {
222  }
223 
224  assembleConcreteProcess(t, dt, x, xdot, process_id, M, K, b);
225 
226  // the last argument is for the jacobian, nullptr is for a unused jacobian
227  _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
228  nullptr);
229 
230  // the last argument is for the jacobian, nullptr is for a unused jacobian
231  _source_term_collections[process_id].integrate(t, *x[process_id], b,
232  nullptr);
233 }
virtual void assembleConcreteProcess(const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)=0
void setLocalAccessibleVector(PETScVector const &x)
Definition: LinAlg.cpp:27
static const double t

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

◆ assembleConcreteProcess()

virtual void ProcessLib::Process::assembleConcreteProcess ( const double  t,
double const  dt,
std::vector< GlobalVector * > const &  x,
std::vector< GlobalVector * > const &  xdot,
int const  process_id,
GlobalMatrix M,
GlobalMatrix K,
GlobalVector b 
)
privatepure virtual

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

Referenced by assemble().

◆ assembleWithJacobian()

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

Definition at line 235 of file Process.cpp.

241 {
242  assert(x.size() == xdot.size());
243  for (std::size_t i = 0; i < x.size(); i++)
244  {
247  }
248 
249  assembleWithJacobianConcreteProcess(t, dt, x, xdot, process_id, M, K, b,
250  Jac);
251 
252  // TODO: apply BCs to Jacobian.
253  _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
254  &Jac);
255 
256  // the last argument is for the jacobian, nullptr is for a unused jacobian
257  _source_term_collections[process_id].integrate(t, *x[process_id], b, &Jac);
258 }
virtual void assembleWithJacobianConcreteProcess(const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac)=0

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

◆ assembleWithJacobianConcreteProcess()

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

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

Referenced by assembleWithJacobian().

◆ computeSecondaryVariable()

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

compute secondary variables for the coupled equations or for output.

Definition at line 415 of file Process.cpp.

420 {
421  for (auto const* solution : x)
424 
425  computeSecondaryVariableConcrete(t, dt, x, x_dot, process_id);
426 }
virtual void computeSecondaryVariableConcrete(double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)
Definition: Process.h:266

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

◆ computeSecondaryVariableConcrete()

◆ computeSparsityPattern()

void ProcessLib::Process::computeSparsityPattern ( )
private

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

Definition at line 380 of file Process.cpp.

381 {
384 }
std::unique_ptr< NumLib::LocalToGlobalIndexMap > _local_to_global_index_map
Definition: Process.h:334
GlobalSparsityPattern _sparsity_pattern
Definition: Process.h:357
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::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::HeatTransportBHE::HeatTransportBHEProcess.

Definition at line 260 of file Process.cpp.

261 {
263  {
265 
266  return;
267  }
268 
269  // For staggered scheme:
270  const int specified_process_id = 0;
272 }
void constructDofTableOfSpecifiedProcessStaggeredScheme(const int specified_prosess_id)
Definition: Process.cpp:307
void constructMonolithicProcessDofTable()
Definition: Process.cpp:274

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

Referenced by initialize().

◆ constructDofTableOfSpecifiedProcessStaggeredScheme()

void ProcessLib::Process::constructDofTableOfSpecifiedProcessStaggeredScheme ( const int  specified_prosess_id)
protected

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

Definition at line 307 of file Process.cpp.

309 {
310  // Create single component dof in every of the mesh nodes.
312  std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
313 
314  // Vector of mesh subsets.
315  std::vector<MeshLib::MeshSubset> all_mesh_subsets;
316 
317  // Vector of the number of variable components
318  std::vector<int> vec_var_n_components;
319  // Collect the mesh subsets in a vector for each variables' components.
320  std::generate_n(std::back_inserter(all_mesh_subsets),
321  _process_variables[specified_process_id][0]
322  .get()
323  .getNumberOfGlobalComponents(),
324  [&]() { return *_mesh_subset_all_nodes; });
325 
326  // Create a vector of the number of variable components.
327  vec_var_n_components.push_back(_process_variables[specified_process_id][0]
328  .get()
329  .getNumberOfGlobalComponents());
331  std::make_unique<NumLib::LocalToGlobalIndexMap>(
332  std::move(all_mesh_subsets), vec_var_n_components,
334 
336 }
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition: Mesh.h:101
std::unique_ptr< MeshLib::MeshSubset const > _mesh_subset_all_nodes
Definition: Process.h:332
@ BY_LOCATION
Ordering data by spatial location.

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

Referenced by constructDofTable().

◆ constructMonolithicProcessDofTable()

void ProcessLib::Process::constructMonolithicProcessDofTable ( )
protected

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

Definition at line 274 of file Process.cpp.

275 {
276  // Create single component dof in every of the mesh nodes.
278  std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
279 
280  // Vector of mesh subsets.
281  std::vector<MeshLib::MeshSubset> all_mesh_subsets;
282 
283  // Collect the mesh subsets in a vector for the components of each
284  // variables.
285  for (ProcessVariable const& pv : _process_variables[0])
286  {
287  std::generate_n(std::back_inserter(all_mesh_subsets),
288  pv.getNumberOfGlobalComponents(),
289  [&]() { return *_mesh_subset_all_nodes; });
290  }
291 
292  // Create a vector of the number of variable components
293  std::vector<int> vec_var_n_components;
294  transform(cbegin(_process_variables[0]), cend(_process_variables[0]),
295  back_inserter(vec_var_n_components),
296  [](ProcessVariable const& pv)
297  { return pv.getNumberOfGlobalComponents(); });
298 
300  std::make_unique<NumLib::LocalToGlobalIndexMap>(
301  std::move(all_mesh_subsets), vec_var_n_components,
303 
305 }

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

Referenced by constructDofTable().

◆ extrapolateIntegrationPointValuesToNodes()

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

Definition at line 112 of file Process.h.

116  {
117  }

◆ getDOFTable()

◆ getDOFTableForExtrapolatorData()

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

Get the address of a LocalToGlobalIndexMap, and the status of its memory. If the LocalToGlobalIndexMap is created as new in this function, the function also returns a true boolean value to let Extrapolator manage the memory by the address returned by this function.

Returns
Address of a LocalToGlobalIndexMap and its memory status.

Reimplemented in ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::HT::HTProcess.

Definition at line 339 of file Process.cpp.

340 {
341  if (_local_to_global_index_map->getNumberOfGlobalComponents() == 1)
342  {
343  // For single-variable-single-component processes reuse the existing DOF
344  // table.
345  const bool manage_storage = false;
346  return std::make_tuple(_local_to_global_index_map.get(),
347  manage_storage);
348  }
349 
350  // Otherwise construct a new DOF table.
351  std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component;
352  all_mesh_subsets_single_component.emplace_back(*_mesh_subset_all_nodes);
353 
354  const bool manage_storage = true;
355 
356  return std::make_tuple(new NumLib::LocalToGlobalIndexMap(
357  std::move(all_mesh_subsets_single_component),
358  // by location order is needed for output
360  manage_storage);
361 }

References _local_to_global_index_map, _mesh_subset_all_nodes, and NumLib::BY_LOCATION.

Referenced by initializeExtrapolator().

◆ getExtrapolator()

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

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

442 {
443  std::vector<GlobalIndexType> indices;
444 
445  for (std::size_t process_id = 0; process_id < _process_variables.size();
446  process_id++)
447  {
448  auto const& dof_table_of_process = getDOFTable(process_id);
449 
450  auto const& per_process_variables = _process_variables[process_id];
451  for (std::size_t variable_id = 0;
452  variable_id < per_process_variables.size();
453  variable_id++)
454  {
455  auto const& pv = per_process_variables[variable_id];
456  DBUG("Set the initial condition of variable {:s} of process {:d}.",
457  pv.get().getName().data(), process_id);
458 
459  if ((pv.get().compensateNonEquilibriumInitialResiduum()))
460  {
461  continue;
462  }
463 
464  auto const num_comp = pv.get().getNumberOfGlobalComponents();
465 
466  for (int component_id = 0; component_id < num_comp; ++component_id)
467  {
468  auto const& mesh_subset = dof_table_of_process.getMeshSubset(
469  variable_id, component_id);
470  auto const mesh_id = mesh_subset.getMeshID();
471  for (auto const* node : mesh_subset.getNodes())
472  {
473  MeshLib::Location const l(
474  mesh_id, MeshLib::MeshItemType::Node, node->getID());
475 
476  auto global_index =
477  std::abs(dof_table_of_process.getGlobalIndex(
478  l, variable_id, component_id));
479 
480  indices.push_back(global_index);
481  }
482  }
483  }
484  }
485 
486  return indices;
487 }
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition: Logging.h:29
virtual NumLib::LocalToGlobalIndexMap const & getDOFTable(const int) const
Definition: Process.h:141

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

◆ getIntegrationPointWriters()

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

Definition at line 160 of file Process.h.

161  {
163  }
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > _integration_point_writer
Definition: Process.h:355

References _integration_point_writer.

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

◆ getKnownSolutions()

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

Definition at line 135 of file Process.h.

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

References _boundary_conditions, and MathLib::t.

◆ getMatrixSpecifications()

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

Definition at line 187 of file Process.cpp.

189 {
190  auto const& l = *_local_to_global_index_map;
191  return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
192  &l.getGhostIndices(), &_sparsity_pattern};
193 }

References _local_to_global_index_map, and _sparsity_pattern.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation().

◆ getMesh()

◆ getProcessVariables()

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

Definition at line 149 of file Process.h.

150  {
151  return _process_variables[process_id];
152  }

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::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::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::preTimestepConcreteProcess(), ProcessLib::HT::HTProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers(), ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation(), and updateDeactivatedSubdomains().

◆ getSecondaryVariables()

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

Definition at line 154 of file Process.h.

155  {
156  return _secondary_variables;
157  }

References _secondary_variables.

Referenced by ProcessLib::createProcessOutputData().

◆ getSingleComponentDOFTable()

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

◆ initialize()

void ProcessLib::Process::initialize ( )

Definition at line 96 of file Process.cpp.

97 {
98  DBUG("Initialize process.");
99 
100  DBUG("Construct dof mappings.");
102 
103  DBUG("Compute sparsity pattern");
105 
106  DBUG("Initialize the extrapolator");
108 
111 
112  DBUG("Initialize boundary conditions.");
114 }
virtual void initializeBoundaryConditions()
Definition: Process.cpp:83
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:363
virtual void constructDofTable()
Definition: Process.cpp:260
void computeSparsityPattern()
Definition: Process.cpp:380

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

◆ initializeBoundaryConditions()

void ProcessLib::Process::initializeBoundaryConditions ( )
privatevirtual

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

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

Definition at line 83 of file Process.cpp.

84 {
85  // The number of processes is identical to the size of _process_variables,
86  // the vector contains variables for different processes. See the
87  // documentation of _process_variables.
88  const std::size_t number_of_processes = _process_variables.size();
89  for (std::size_t pcs_id = 0; pcs_id < number_of_processes; pcs_id++)
90  {
93  }
94 }
void initializeProcessBoundaryConditionsAndSourceTerms(const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id)
Definition: Process.cpp:69

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

Referenced by initialize().

◆ initializeExtrapolator()

void ProcessLib::Process::initializeExtrapolator ( )
private

Definition at line 363 of file Process.cpp.

364 {
365  NumLib::LocalToGlobalIndexMap* dof_table_single_component;
366  bool manage_storage;
367 
368  std::tie(dof_table_single_component, manage_storage) =
370 
371  std::unique_ptr<NumLib::Extrapolator> extrapolator(
373  *dof_table_single_component));
374 
375  // TODO: Later on the DOF table can change during the simulation!
376  _extrapolator_data = ExtrapolatorData(
377  std::move(extrapolator), dof_table_single_component, manage_storage);
378 }
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool > getDOFTableForExtrapolatorData() const
Definition: Process.cpp:339

References _extrapolator_data, and getDOFTableForExtrapolatorData().

Referenced by initialize().

◆ initializeProcessBoundaryConditionsAndSourceTerms()

void ProcessLib::Process::initializeProcessBoundaryConditionsAndSourceTerms ( const NumLib::LocalToGlobalIndexMap dof_table,
const int  process_id 
)
protected

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

Definition at line 69 of file Process.cpp.

71 {
72  auto const& per_process_variables = _process_variables[process_id];
73  auto& per_process_BCs = _boundary_conditions[process_id];
74 
75  per_process_BCs.addBCsForProcessVariables(per_process_variables, dof_table,
76  _integration_order, *this);
77 
78  auto& per_process_sts = _source_term_collections[process_id];
79  per_process_sts.addSourceTermsForProcessVariables(
80  per_process_variables, dof_table, _integration_order);
81 }

References _boundary_conditions, _integration_order, _process_variables, and _source_term_collections.

Referenced by initializeBoundaryConditions().

◆ isMonolithicSchemeUsed()

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

◆ postIteration()

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

Definition at line 434 of file Process.cpp.

435 {
438 }
virtual NumLib::IterationResult postIterationConcreteProcess(GlobalVector const &)
Definition: Process.h:275

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

◆ postIterationConcreteProcess()

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

◆ postNonLinearSolver()

void ProcessLib::Process::postNonLinearSolver ( GlobalVector const &  x,
GlobalVector const &  xdot,
const double  t,
double const  dt,
int const  process_id 
)

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

Definition at line 406 of file Process.cpp.

409 {
412  postNonLinearSolverConcreteProcess(x, xdot, t, dt, process_id);
413 }
virtual void postNonLinearSolverConcreteProcess(GlobalVector const &, GlobalVector const &, const double, double const, int const)
Definition: Process.h:255

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

◆ postNonLinearSolverConcreteProcess()

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

◆ postTimestep()

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

Postprocessing after a complete timestep.

Definition at line 396 of file Process.cpp.

398 {
399  for (auto* const solution : x)
401  postTimestepConcreteProcess(x, t, delta_t, process_id);
402 
403  _boundary_conditions[process_id].postTimestep(t, x, process_id);
404 }
virtual void postTimestepConcreteProcess(std::vector< GlobalVector * > const &, const double, const double, int const)
Definition: Process.h:247

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

◆ postTimestepConcreteProcess()

◆ preAssemble()

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

Definition at line 205 of file Process.cpp.

207 {
209 }
virtual void preAssembleConcreteProcess(const double, double const, GlobalVector const &)
Definition: Process.h:221

References preAssembleConcreteProcess(), and MathLib::t.

◆ preAssembleConcreteProcess()

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

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

Definition at line 221 of file Process.h.

224  {
225  }

Referenced by preAssemble().

◆ preIteration()

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

Definition at line 428 of file Process.cpp.

429 {
432 }
virtual void preIterationConcreteProcess(const unsigned, GlobalVector const &)
Definition: Process.h:261

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

◆ preIterationConcreteProcess()

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

Reimplemented in ProcessLib::TES::TESProcess.

Definition at line 261 of file Process.h.

263  {
264  }

Referenced by preIteration().

◆ preTimestep()

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

Preprocessing before starting assembly for new timestep.

Definition at line 386 of file Process.cpp.

388 {
389  for (auto* const solution : x)
391  preTimestepConcreteProcess(x, t, delta_t, process_id);
392 
393  _boundary_conditions[process_id].preTimestep(t, x, process_id);
394 }
virtual void preTimestepConcreteProcess(std::vector< GlobalVector * > const &, const double, const double, const int)
Definition: Process.h:239

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

◆ preTimestepConcreteProcess()

◆ setCoupledSolutionsForStaggeredScheme()

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

Definition at line 98 of file Process.h.

100  {
101  _coupled_solutions = coupled_solutions;
102  }

References _coupled_solutions.

◆ setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

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

Reimplemented in ProcessLib::HT::HTProcess.

Definition at line 107 of file Process.h.

109  {
110  }

◆ setInitialConditions()

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

Definition at line 116 of file Process.cpp.

121 {
122  auto& x = *process_solutions[process_id];
123  auto& x_prev = *process_solutions_prev[process_id];
124 
125  // getDOFTableOfProcess can be overloaded by the specific process.
126  auto const& dof_table_of_process = getDOFTable(process_id);
127 
128  auto const& per_process_variables = _process_variables[process_id];
129  for (std::size_t variable_id = 0;
130  variable_id < per_process_variables.size();
131  variable_id++)
132  {
135 
136  auto const& pv = per_process_variables[variable_id];
137  DBUG("Set the initial condition of variable {:s} of process {:d}.",
138  pv.get().getName().data(), process_id);
139 
140  auto const& ic = pv.get().getInitialCondition();
141 
142  auto const num_comp = pv.get().getNumberOfGlobalComponents();
143 
144  for (int component_id = 0; component_id < num_comp; ++component_id)
145  {
146  auto const& mesh_subset =
147  dof_table_of_process.getMeshSubset(variable_id, component_id);
148  auto const mesh_id = mesh_subset.getMeshID();
149  for (auto const* node : mesh_subset.getNodes())
150  {
152  node->getID());
153 
154  pos.setNodeID(node->getID());
155  pos.setCoordinates(*node);
156  auto const& ic_value = ic(t, pos);
157 
158  auto global_index =
159  std::abs(dof_table_of_process.getGlobalIndex(l, variable_id,
160  component_id));
161 #ifdef USE_PETSC
162  // The global indices of the ghost entries of the global
163  // matrix or the global vectors need to be set as negative
164  // values for equation assembly, however the global indices
165  // start from zero. Therefore, any ghost entry with zero
166  // index is assigned an negative value of the vector size
167  // or the matrix dimension. To assign the initial value for
168  // the ghost entries, the negative indices of the ghost
169  // entries are restored to zero.
170  if (global_index == x.size())
171  global_index = 0;
172 #endif
173  x.set(global_index, ic_value[component_id]);
174  }
175  }
176  }
177 
179  MathLib::LinAlg::copy(x, x_prev); // pushState
180 
183 
184  setInitialConditionsConcreteProcess(process_solutions, t, process_id);
185 }
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:214
void finalizeAssembly(PETScMatrix &A)
Definition: LinAlg.cpp:163
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(), ParameterLib::SpatialPosition::setNodeID(), and MathLib::t.

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

181  {
182  }

◆ updateDeactivatedSubdomains()

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

Definition at line 195 of file Process.cpp.

197 {
198  auto const& variables_per_process = getProcessVariables(process_id);
199  for (auto const& variable : variables_per_process)
200  {
201  variable.get().updateDeactivatedSubdomains(time);
202  }
203 }
std::vector< std::reference_wrapper< ProcessVariable > > const & getProcessVariables(const int process_id) const
Definition: Process.h:149

References getProcessVariables().

Member Data Documentation

◆ _boundary_conditions

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

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

Definition at line 370 of file Process.h.

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

◆ _coupled_solutions

CoupledSolutionsForStaggeredScheme* ProcessLib::Process::_coupled_solutions
protected

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

Definition at line 344 of file Process.h.

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

◆ _extrapolator_data

ExtrapolatorData ProcessLib::Process::_extrapolator_data
private

Definition at line 378 of file Process.h.

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

◆ _global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler
protected

Definition at line 338 of file Process.h.

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::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess().

◆ _integration_order

unsigned const ProcessLib::Process::_integration_order
protected

◆ _integration_point_writer

◆ _local_to_global_index_map

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

Definition at line 334 of file Process.h.

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::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::ThermoRichardsFlow::ThermoRichardsFlowProcess::getDOFTables(), 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::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::preTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::setInitialConditionsConcreteProcess().

◆ _mesh

◆ _mesh_subset_all_nodes

◆ _process_variables

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

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

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

◆ _sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern
protected

Definition at line 357 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

◆ _use_monolithic_scheme

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