ProcessLib Namespace Reference

Detailed Description

Common convenitions for naming: X_gas_nonwet mass fraction of gas component(e.g air) in nonwetting phase (gas component doesn't include water vapor, same for the following) x_gas_nonwet molar fraction of gas component in nonwetting phase x_vapor_nonwet molar fraction of vapor in nonwetting phase p_vapor_nonwet water vapor pressure p_gas_nonwet partial pressure of gas component mol_density_nonwet molar density of nonwetting phase mol_density_water molar density of water density_water mass density of water density_nonwet_gas mass density of gas component in the nonwetting phase density_nonwet_vapor mass density of vapor in the nonwetting phase density_nonwet mass density of the nonwetting phase density_wet mass density of wetting pahse density_solid mass density of the solid phase velocity_nonwet velocity of nonwetting phase velocity_wet velocity of wetting phase heat_capacity_dry_gas heat capacity of dry gas heat_capacity_water_vapor heat capacity of water vapor heat_capacity_water heat capacity of liquid water heat_capacity_solid heat capacity of soil grain latent_heat_evaporation latent heat for evaporation(water to vapor) enthalpy_nonwet_gas enthalpy of gas component in the nonwetting phase enthalpy_nonwet_vapor enthalpy of water vapor in the nonwetting phase enthalpy_wet enthalpy of wetting phase enthalpy_nonwet enthalpy of the nonwetting phase internal_energy_nonwet specific internal energy for the nonwetting phase internal_energy_wet specific internal energy for the wetting phase heat_conductivity_dry_solid heat conductivity of the dry porous medium heat_conductivity_wet_solid heat conductivity of the fully saturated porous medium heat_conductivity_unsaturated heat conductivity of the unsaturated porous medium

common nomenclature -----------—primary variable-------------------— pn_int_pt pressure for nonwetting phase at each integration point pc_int_pt capillary pressure at each integration point -----------—secondary variable-----------------— Sw wetting phase saturation dSw_dpc derivative of wetting phase saturation with respect to capillary pressure rho_nonwet density of nonwetting phase drhononwet_dpn derivative of nonwetting phase density with respect to nonwetting phase pressure rho_wet density of wetting phase k_rel_nonwet relative permeability of nonwetting phase mu_nonwet viscosity of nonwetting phase lambda_nonwet mobility of nonwetting phase k_rel_wet relative permeability of wetting phase mu_wet viscosity of wetting phase lambda_wet mobility of wetting phase

Namespaces
	BoundaryConditionAndSourceTerm
	ComponentTransport
	Deformation
	detail
	HeatConduction
	HeatTransportBHE
	HT
	HydroMechanics
	LIE
	LinearBMatrix
	LiquidFlow
	NormalTractionBoundaryCondition
	PhaseField
	RichardsComponentTransport
	RichardsFlow
	RichardsMechanics
	SmallDeformation
	SmallDeformationNonlocal
	SourceTerms
	SteadyStateDiffusion
	StokesFlow
	TES
	TH2M
	ThermalTwoPhaseFlowWithPP
	ThermoHydroMechanics
	ThermoMechanicalPhaseField
	ThermoMechanics
	ThermoRichardsFlow
	ThermoRichardsMechanics
	TwoPhaseFlowWithPP
	TwoPhaseFlowWithPrho

Classes
class	TESFEMReactionAdaptorCaOH2
class	AbstractJacobianAssembler
	Base class for Jacobian assemblers. More...
class	AnalyticalJacobianAssembler
class	BoundaryCondition
class	BoundaryConditionCollection
struct	BoundaryConditionConfig
class	ConstraintDirichletBoundaryCondition
struct	IntegrationPointData
class	ConstraintDirichletBoundaryConditionLocalAssemblerInterface
class	ConstraintDirichletBoundaryConditionLocalAssembler
class	DeactivatedSubdomainDirichlet
class	DirichletBoundaryCondition
class	DirichletBoundaryConditionWithinTimeInterval
class	GenericNaturalBoundaryCondition
class	GenericNaturalBoundaryConditionLocalAssemblerInterface
class	GenericNaturalBoundaryConditionLocalAssembler
struct	HCNonAdvectiveFreeComponentFlowBoundaryConditionData
class	HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler
struct	NeumannBoundaryConditionData
class	NeumannBoundaryConditionLocalAssembler
class	NodalSourceTerm
class	PhaseFieldIrreversibleDamageOracleBoundaryCondition
class	PrimaryVariableConstraintDirichletBoundaryCondition
class	BHEInflowPythonBoundaryCondition
	A boundary condition whose values are computed by a Python script. More...
class	BHEInflowPythonBoundaryConditionPythonSideInterfaceTrampoline
class	BHEInflowPythonBoundaryConditionPythonSideInterface
struct	PythonBoundaryConditionData
class	PythonBoundaryCondition
	A boundary condition whose values are computed by a Python script. More...
struct	MethodNotOverriddenInDerivedClassException
class	PythonBoundaryConditionLocalAssembler
class	PythonBoundaryConditionPythonSideInterfaceTrampoline
class	PythonBoundaryConditionPythonSideInterface
struct	RobinBoundaryConditionData
class	RobinBoundaryConditionLocalAssembler
class	SolutionDependentDirichletBoundaryCondition
class	SourceTerm
class	SourceTermCollection
struct	SourceTermConfig
struct	SourceTermIntegrationPointData
struct	VariableDependentNeumannBoundaryConditionData
class	VariableDependentNeumannBoundaryConditionLocalAssembler
class	VolumetricSourceTerm
class	VolumetricSourceTermLocalAssemblerInterface
class	VolumetricSourceTermLocalAssembler
class	CentralDifferencesJacobianAssembler
	Assembles the Jacobian matrix using central differences. More...
class	CompareJacobiansJacobianAssembler
struct	CoupledSolutionsForStaggeredScheme
struct	LocalCoupledSolutions
struct	DeactivatedSubdomainMesh
struct	DeactivatedSubdomain
class	BMatrixPolicyType
class	GMatrixPolicyType
class	HMatrixPolicyType
class	LocalAssemblerInterface
class	ExtrapolatorData
struct	IntegrationPointWriter
struct	IntegrationPointMetaData
class	Output
struct	OutputDataSpecification
	Holds information about which variables to write to output files. More...
struct	SecondaryVariableFunctions
struct	SecondaryVariable
	Stores information about a specific secondary variable. More...
class	SecondaryVariableCollection
	Handles configuration of several secondary variables from the project file. More...
struct	Parameter
class	Process
struct	ProcessData
class	ProcessVariable
class	LocalDataInitializer
class	SurfaceFlux
struct	SurfaceFluxData
class	SurfaceFluxLocalAssemblerInterface
class	SurfaceFluxLocalAssembler
class	TimeLoop
	Time loop capable of time-integrating several processes at once. More...
struct	TrafoLog
struct	TrafoIdentity
struct	TrafoTanh
struct	TrafoScale
class	VectorMatrixAssembler

Typedefs
using	HCNonAdvectiveFreeComponentFlowBoundaryCondition = GenericNaturalBoundaryCondition< HCNonAdvectiveFreeComponentFlowBoundaryConditionData, HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler >
using	NeumannBoundaryCondition = GenericNaturalBoundaryCondition< NeumannBoundaryConditionData, NeumannBoundaryConditionLocalAssembler >
using	RobinBoundaryCondition = GenericNaturalBoundaryCondition< RobinBoundaryConditionData, RobinBoundaryConditionLocalAssembler >
using	VariableDependentNeumannBoundaryCondition = GenericNaturalBoundaryCondition< VariableDependentNeumannBoundaryConditionData, VariableDependentNeumannBoundaryConditionLocalAssembler >
template<typename ShpPol , unsigned NNodes, unsigned NodalDOF, int Dim>
using	LocalAssemblerTraits = detail::LocalAssemblerTraitsFixed< ShpPol, NNodes, NodalDOF, Dim >
using	Trafo = ProcessLib::TrafoScale

Enumerations
enum class	OutputType : uint8_t { vtk , xdmf }

Functions
std::unique_ptr< ConstraintDirichletBoundaryCondition >	createConstraintDirichletBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, unsigned const integration_order, int const component_id, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, Process const &constraining_process)
std::unique_ptr< BoundaryCondition >	createBoundaryCondition (const BoundaryConditionConfig &config, const NumLib::LocalToGlobalIndexMap &dof_table, const MeshLib::Mesh &bulk_mesh, const int variable_id, const unsigned integration_order, const unsigned shapefunction_order, const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &parameters, const Process &process)
std::unique_ptr< BoundaryCondition >	createDirichletBoundaryConditionWithinTimeInterval (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id, const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &parameters)
std::unique_ptr< SourceTerm >	createNodalSourceTerm (BaseLib::ConfigTree const &config, MeshLib::Mesh const &st_mesh, std::unique_ptr< NumLib::LocalToGlobalIndexMap > dof_table, std::size_t const source_term_mesh_id, const int variable_id, const int component_id, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< SourceTerm >	createSourceTerm (const SourceTermConfig &config, const NumLib::LocalToGlobalIndexMap &dof_table_bulk, const MeshLib::Mesh &source_term_mesh, const int variable_id, const unsigned integration_order, const unsigned shapefunction_order, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< SourceTerm >	createVolumetricSourceTerm (BaseLib::ConfigTree const &config, unsigned const bulk_mesh_dimension, MeshLib::Mesh const &source_term_mesh, std::unique_ptr< NumLib::LocalToGlobalIndexMap > source_term_dof_table, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, unsigned const shapefunction_order)
std::unique_ptr< DirichletBoundaryCondition >	createDirichletBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id, const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &parameters)
void	checkParametersOfDirichletBoundaryCondition (MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id)
void	getEssentialBCValuesLocal (ParameterLib::Parameter< double > const &parameter, MeshLib::Mesh const &bc_mesh, std::vector< MeshLib::Node * > const &nodes_in_bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_boundary, int const variable_id, int const component_id, const double t, GlobalVector const &, NumLib::IndexValueVector< GlobalIndexType > &bc_values)
std::unique_ptr< HCNonAdvectiveFreeComponentFlowBoundaryCondition >	createHCNonAdvectiveFreeComponentFlowBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table, int const variable_id, int const component_id, unsigned const integration_order, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const global_dim, Process const &process, unsigned const shapefunction_order)
std::unique_ptr< NeumannBoundaryCondition >	createNeumannBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< PhaseFieldIrreversibleDamageOracleBoundaryCondition >	createPhaseFieldIrreversibleDamageOracleBoundaryCondition (BaseLib::ConfigTree const &config, NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, int const variable_id, int const component_id)
std::unique_ptr< PrimaryVariableConstraintDirichletBoundaryCondition >	createPrimaryVariableConstraintDirichletBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id, const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &parameters)
template<typename BHEType >
std::unique_ptr< BHEInflowPythonBoundaryCondition< BHEType > >	createBHEInflowPythonBoundaryCondition (std::pair< GlobalIndexType, GlobalIndexType > &&in_out_global_indices, BHEType &bhe, BHEInflowPythonBoundaryConditionPythonSideInterface &py_bc_object)
void	bheInflowpythonBindBoundaryCondition (pybind11::module &m)
	Creates BHE Inflow Python bindings for the Python BC class. More...
std::unique_ptr< SourceTerm >	createPythonSourceTerm (BaseLib::ConfigTree const &config, MeshLib::Mesh const &source_term_mesh, std::unique_ptr< NumLib::LocalToGlobalIndexMap > dof_table, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim)
std::unique_ptr< PythonBoundaryCondition >	createPythonBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &boundary_mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t bulk_mesh_id, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim)
	Creates a new PythonBoundaryCondition object. More...
void	pythonBindBoundaryCondition (pybind11::module &m)
	Creates Python bindings for the Python BC class. More...
std::unique_ptr< RobinBoundaryCondition >	createRobinBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< SolutionDependentDirichletBoundaryCondition >	createSolutionDependentDirichletBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< VariableDependentNeumannBoundaryCondition >	createVariableDependentNeumannBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< CentralDifferencesJacobianAssembler >	createCentralDifferencesJacobianAssembler (BaseLib::ConfigTree const &config)
std::unique_ptr< CompareJacobiansJacobianAssembler >	createCompareJacobiansJacobianAssembler (BaseLib::ConfigTree const &config)
std::vector< double >	getCoupledLocalSolutions (std::vector< GlobalVector * > const &global_solutions, std::vector< std::vector< GlobalIndexType >> const &indices)
template<typename IsActive >
static std::pair< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > >	extractInnerAndOuterNodes (MeshLib::Mesh const &mesh, MeshLib::Mesh const &sub_mesh, IsActive is_active)
static std::unique_ptr< DeactivatedSubdomainMesh >	createDeactivatedSubdomainMesh (MeshLib::Mesh const &mesh, int const material_id)
static MathLib::PiecewiseLinearInterpolation	parseTimeIntervalOrCurve (std::optional< BaseLib::ConfigTree > const &time_interval_config, std::optional< std::string > const &curve_name, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
static std::pair< Eigen::Vector3d, Eigen::Vector3d >	parseLineSegment (BaseLib::ConfigTree const &config)
	Returns a line segment represented by its begin and end points. More...
std::unique_ptr< DeactivatedSubdomain const >	createDeactivatedSubdomain (BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
std::vector< std::unique_ptr< DeactivatedSubdomain const > >	createDeactivatedSubdomains (BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
std::unique_ptr< AbstractJacobianAssembler >	createJacobianAssembler (std::optional< BaseLib::ConfigTree > const &config)
static std::unique_ptr< ProcessData >	makeProcessData (std::unique_ptr< NumLib::TimeStepAlgorithm > &&timestepper, NumLib::NonlinearSolverBase &nonlinear_solver, int const process_id, Process &process, std::unique_ptr< NumLib::TimeDiscretization > &&time_disc, std::unique_ptr< NumLib::ConvergenceCriterion > &&conv_crit, bool const compensate_non_equilibrium_initial_residuum)
std::vector< std::unique_ptr< ProcessData > >	createPerProcessData (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< Process >> const &processes, std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase >> const &nonlinear_solvers)
std::unique_ptr< TimeLoop >	createTimeLoop (BaseLib::ConfigTree const &config, std::string const &output_directory, std::vector< std::unique_ptr< Process >> const &processes, std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase >> const &nonlinear_solvers, std::vector< std::unique_ptr< MeshLib::Mesh >> const &meshes)
	Builds a TimeLoop from the given configuration. More...
template<int DisplacementDim, int NPOINTS, typename N_Type , typename HMatrixType >
void	computeHMatrix (N_Type const &N, HMatrixType &H)
	Fills a H-matrix based on given shape function. More...
std::unique_ptr< Output >	createOutput (const BaseLib::ConfigTree &config, std::string const &output_directory, std::vector< std::unique_ptr< MeshLib::Mesh >> const &meshes)
void	createSecondaryVariables (BaseLib::ConfigTree const &config, SecondaryVariableCollection &secondary_variables)
void	addIntegrationPointWriter (MeshLib::Mesh &mesh, std::vector< std::unique_ptr< IntegrationPointWriter >> const &integration_point_writer)
IntegrationPointMetaData	getIntegrationPointMetaData (MeshLib::Mesh const &mesh, std::string const &name)
void	addProcessDataToMesh (const double t, std::vector< GlobalVector * > const &x, int const process_id, MeshLib::Mesh &mesh, [[maybe_unused]] std::vector< NumLib::LocalToGlobalIndexMap const * > const &bulk_dof_tables, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< std::reference_wrapper< ProcessVariable >> const &process_variables, SecondaryVariableCollection const &secondary_variables, bool const output_secondary_variable, std::vector< std::unique_ptr< IntegrationPointWriter >> const *const integration_point_writer, OutputDataSpecification const &process_output)
void	makeOutput (std::string const &file_name, MeshLib::Mesh const &mesh, bool const compress_output, int const data_mode)
void	addProcessDataToMesh (const double t, std::vector< GlobalVector * > const &x, int const process_id, MeshLib::Mesh &mesh, std::vector< NumLib::LocalToGlobalIndexMap const * > const &bulk_dof_tables, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< std::reference_wrapper< ProcessVariable >> const &process_variables, SecondaryVariableCollection const &secondary_variables, bool const output_secondary_variable, std::vector< std::unique_ptr< IntegrationPointWriter >> const *integration_point_writer, OutputDataSpecification const &process_output)
	Prepare the output data, i.e. add the solution to vtu data structure. More...
template<typename LocalAssemblerCollection >
SecondaryVariableFunctions	makeExtrapolator (const unsigned num_components, NumLib::Extrapolator &extrapolator, LocalAssemblerCollection const &local_assemblers, typename NumLib::ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection >::IntegrationPointValuesMethod integration_point_values_method)
void	preTimestepForAllProcesses (double const t, double const dt, std::vector< std::unique_ptr< ProcessData >> const &per_process_data, std::vector< GlobalVector * > const &_process_solutions)
void	postTimestepForAllProcesses (double const t, double const dt, std::vector< std::unique_ptr< ProcessData >> const &per_process_data, std::vector< GlobalVector * > const &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, std::vector< std::size_t > &xdot_vector_ids)
template<NumLib::ODESystemTag ODETag>
void	setTimeDiscretizedODESystem (ProcessData &process_data, NumLib::ODESystem< ODETag, NumLib::NonlinearSolverTag::Picard > &ode_sys)
void	setTimeDiscretizedODESystem (ProcessData &process_data)
std::pair< std::vector< GlobalVector * >, std::vector< GlobalVector * > >	setInitialConditions (double const t0, std::vector< std::unique_ptr< ProcessData >> const &per_process_data)
void	calculateNonEquilibriumInitialResiduum (std::vector< std::unique_ptr< ProcessData >> const &per_process_data, std::vector< GlobalVector * > process_solutions, std::vector< GlobalVector * > const &process_solutions_prev)
NumLib::NonlinearSolverStatus	solveOneTimeStepOneProcess (std::vector< GlobalVector * > &x, std::vector< GlobalVector * > const &x_prev, std::size_t const timestep, double const t, double const delta_t, ProcessData const &process_data, Output &output_control, std::size_t &xdot_id)
static NumLib::NonlinearSolverStatus	solveMonolithicProcess (const double t, const double dt, const std::size_t timestep_id, ProcessData const &process_data, std::vector< GlobalVector * > &x, std::vector< GlobalVector * > const &x_prev, Output &output, std::size_t &xdot_id)
GlobalVector	computeResiduum (GlobalVector const &x, GlobalVector const &xdot, GlobalMatrix const &M, GlobalMatrix const &K, GlobalVector const &b)
template<int GlobalDim, template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< MeshLib::Element * > const &mesh_elements, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
template<template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (const unsigned dimension, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
ProcessVariable &	findProcessVariable (std::vector< ProcessVariable > const &variables, BaseLib::ConfigTree const &pv_config, std::string const &tag)
std::vector< std::reference_wrapper< ProcessVariable > >	findProcessVariables (std::vector< ProcessVariable > const &variables, BaseLib::ConfigTree const &pv_config, std::initializer_list< std::string > tags)
std::vector< std::reference_wrapper< ProcessVariable > >	findProcessVariables (std::vector< ProcessVariable > const &variables, BaseLib::ConfigTree const &pv_config, std::string const &tag)
template<int DisplacementDim, typename IntegrationPointData , typename MemberType >
std::vector< double > const &	getIntegrationPointKelvinVectorData (std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &ip_data, MemberType member, std::vector< double > &cache)
template<int DisplacementDim, typename IntegrationPointData , typename MemberType >
std::vector< double >	getIntegrationPointKelvinVectorData (std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &ip_data, MemberType member)
template<int DisplacementDim, typename IntegrationPointData , typename MemberType >
std::size_t	setIntegrationPointKelvinVectorData (double const *values, std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &ip_data, MemberType member)
template<typename IntegrationPointData , typename MemberType >
std::vector< double > const &	getIntegrationPointScalarData (std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &ip_data, MemberType member, std::vector< double > &cache)
template<typename IntegrationPointData , typename MemberType >
std::size_t	setIntegrationPointScalarData (double const *values, std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &ip_data, MemberType member)
template<typename IntegrationPointData , typename MemberType , typename MaterialStateVariables >
std::vector< double >	getIntegrationPointDataMaterialStateVariables (std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &ip_data_vector, MemberType member, std::function< BaseLib::DynamicSpan< double >(MaterialStateVariables &)> get_values_span, int const n_components)
template<typename IntegrationPointData , typename MemberType , typename MaterialStateVariables >
std::size_t	setIntegrationPointDataMaterialStateVariables (double const *values, std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &ip_data_vector, MemberType member, std::function< BaseLib::DynamicSpan< double >(MaterialStateVariables &)> get_values_span)
template<int Components, typename StoreValuesFunction >
std::vector< double >	transposeInPlace (StoreValuesFunction const &store_values_function)

Variables
static constexpr std::string_view	timestepper_cannot_reduce_dt

Typedef Documentation

HCNonAdvectiveFreeComponentFlowBoundaryCondition

using ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryCondition = typedef GenericNaturalBoundaryCondition< HCNonAdvectiveFreeComponentFlowBoundaryConditionData, HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler>

Definition at line 19 of file HCNonAdvectiveFreeComponentFlowBoundaryCondition.h.

LocalAssemblerTraits

template<typename ShpPol , unsigned NNodes, unsigned NodalDOF, int Dim>

using ProcessLib::LocalAssemblerTraits = typedef detail::LocalAssemblerTraitsFixed<ShpPol, NNodes, NodalDOF, Dim>

Definition at line 186 of file LocalAssemblerTraits.h.

NeumannBoundaryCondition

using ProcessLib::NeumannBoundaryCondition = typedef GenericNaturalBoundaryCondition<NeumannBoundaryConditionData, NeumannBoundaryConditionLocalAssembler>

Definition at line 19 of file NeumannBoundaryCondition.h.

RobinBoundaryCondition

using ProcessLib::RobinBoundaryCondition = typedef GenericNaturalBoundaryCondition<RobinBoundaryConditionData, RobinBoundaryConditionLocalAssembler>

Definition at line 18 of file RobinBoundaryCondition.h.

Trafo

using ProcessLib::Trafo = typedef ProcessLib::TrafoScale

Definition at line 87 of file VariableTransformation.h.

VariableDependentNeumannBoundaryCondition

using ProcessLib::VariableDependentNeumannBoundaryCondition = typedef GenericNaturalBoundaryCondition< VariableDependentNeumannBoundaryConditionData, VariableDependentNeumannBoundaryConditionLocalAssembler>

Definition at line 19 of file VariableDependentNeumannBoundaryCondition.h.

Enumeration Type Documentation

OutputType

enum ProcessLib::OutputType : uint8_t

strong

Writes output to the given file_name using the specified file format.

See Output::_output_file_data_mode documentation for the data_mode parameter.

Enumerator
vtk
xdmf

Definition at line 50 of file ProcessOutput.h.

{
    vtk,
    xdmf
};

Function Documentation

addIntegrationPointWriter()

void ProcessLib::addIntegrationPointWriter	(	MeshLib::Mesh &	mesh,
		std::vector< std::unique_ptr< IntegrationPointWriter >> const &	integration_point_writer
	)

Add integration point data the the mesh's properties.

Adds all integration point data arrays given by the input vector and the corresponding meta data as VTK's field data. Integration point data stored as field data (contrary to point or cell data), as plain double arrays. The data is supplemented with information in JSON format, which is stored as array of characters.

Definition at line 91 of file IntegrationPointWriter.cpp.

{
    std::vector<IntegrationPointMetaData> meta_data;
    meta_data.reserve(size(integration_point_writer));
    transform(cbegin(integration_point_writer), cend(integration_point_writer),
              back_inserter(meta_data),
              [&](auto const& ip_writer)
              { return addIntegrationPointData(mesh, *ip_writer); });
    if (!meta_data.empty())
    {
        addIntegrationPointMetaData(mesh, meta_data);
    }
}

References addIntegrationPointData(), and addIntegrationPointMetaData().

Referenced by addProcessDataToMesh().

addProcessDataToMesh() [1/2]

void ProcessLib::addProcessDataToMesh	(	const double	t,
		std::vector< GlobalVector * > const &	x,
		int const	process_id,
		MeshLib::Mesh &	mesh,
		[[maybe_unused] ] std::vector< NumLib::LocalToGlobalIndexMap const * > const &	bulk_dof_tables,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_table,
		std::vector< std::reference_wrapper< ProcessVariable >> const &	process_variables,
		SecondaryVariableCollection const &	secondary_variables,
		bool const	output_secondary_variable,
		std::vector< std::unique_ptr< IntegrationPointWriter >> const *const	integration_point_writer,
		OutputDataSpecification const &	process_output
	)

Definition at line 137 of file ProcessOutput.cpp.

{
    DBUG("Process output data.");
 
    addOgsVersion(mesh);
 
    // Copy result
#ifdef USE_PETSC
    // TODO It is also possible directly to copy the data for single process
    // variable to a mesh property. It needs a vector of global indices and
    // some PETSc magic to do so.
    std::vector<double> x_copy(x[process_id]->getLocalSize() +
                               x[process_id]->getGhostSize());
#else
    std::vector<double> x_copy(x[process_id]->size());
#endif
    x[process_id]->copyValues(x_copy);
 
    auto const& output_variables = process_output.output_variables;
    std::set<std::string> already_output;
 
    int global_component_offset = 0;
    int global_component_offset_next = 0;
 
    const auto number_of_dof_variables =
        dof_table[process_id]->getNumberOfVariables();
    // primary variables
    for (int variable_id = 0;
         variable_id < static_cast<int>(process_variables.size());
         ++variable_id)
    {
        ProcessVariable& pv = process_variables[variable_id];
        int const n_components = pv.getNumberOfGlobalComponents();
        // If (number_of_dof_variables==1), the case is either the staggered
        // scheme being applied or a single PDE being solved.
        const int sub_meshset_id =
            (number_of_dof_variables == 1) ? 0 : variable_id;
 
        if (number_of_dof_variables > 1)
        {
            global_component_offset = global_component_offset_next;
            global_component_offset_next += n_components;
        }
 
        if (output_variables.find(pv.getName()) == output_variables.cend())
        {
            continue;
        }
 
        already_output.insert(pv.getName());
 
        DBUG("  process variable {:s}", pv.getName());
 
        auto const num_comp = pv.getNumberOfGlobalComponents();
        auto& output_data = *MeshLib::getOrCreateMeshProperty<double>(
            mesh, pv.getName(), MeshLib::MeshItemType::Node, num_comp);
 
        for (int component_id = 0; component_id < num_comp; ++component_id)
        {
            auto const& mesh_subset = dof_table[process_id]->getMeshSubset(
                sub_meshset_id, component_id);
            auto const mesh_id = mesh_subset.getMeshID();
            for (auto const* node : mesh_subset.getNodes())
            {
#ifdef USE_PETSC
                if (bulk_dof_tables[process_id] != dof_table[process_id])
                {
                    if (!mesh.getProperties().existsPropertyVector<std::size_t>(
                            "bulk_node_ids"))
                    {
                        OGS_FATAL(
                            "The required bulk node ids map does not exist in "
                            "the boundary mesh '{:s}' or has the wrong data "
                            "type (should be equivalent to C++ data type "
                            "std::size_t which is an unsigned integer of size "
                            "{:d} or UInt64 in vtk terminology).",
                            mesh.getName(), sizeof(std::size_t));
                    }
                    auto const bulk_node_id_map =
                        *mesh.getProperties().getPropertyVector<std::size_t>(
                            "bulk_node_ids");
 
                    if (static_cast<MeshLib::NodePartitionedMesh const&>(mesh)
                            .isGhostNode(node->getID()))
                    {
                        auto const bulk_node_id =
                            bulk_node_id_map[node->getID()];
                        // use bulk_dof_tables to find information
                        std::size_t const bulk_mesh_id = 0;
                        MeshLib::Location const l(bulk_mesh_id,
                                                  MeshLib::MeshItemType::Node,
                                                  bulk_node_id);
                        auto const global_component_id =
                            global_component_offset + component_id;
                        auto const index =
                            bulk_dof_tables[process_id]->getLocalIndex(
                                l, global_component_id,
                                x[process_id]->getRangeBegin(),
                                x[process_id]->getRangeEnd());
 
                        output_data[node->getID() * n_components +
                                    component_id] = x_copy[index];
                        continue;
                    }
                }
#endif
                MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                          node->getID());
 
                auto const global_component_id =
                    global_component_offset + component_id;
                auto const index = dof_table[process_id]->getLocalIndex(
                    l, global_component_id, x[process_id]->getRangeBegin(),
                    x[process_id]->getRangeEnd());
 
                output_data[node->getID() * n_components + component_id] =
                    x_copy[index];
            }
        }
    }
 
    if (output_secondary_variable)
    {
        for (auto const& external_variable_name : secondary_variables)
        {
            auto const& name = external_variable_name.first;
            if (!already_output.insert(name).second)
            {
                // no insertion took place, output already done
                continue;
            }
 
            addSecondaryVariableNodes(
                t, x, dof_table, secondary_variables.get(name), name, mesh);
 
            if (process_output.output_residuals)
            {
                addSecondaryVariableResiduals(
                    t, x, dof_table, secondary_variables.get(name), name, mesh);
            }
        }
    }
 
    if (integration_point_writer != nullptr)
    {
        addIntegrationPointWriter(mesh, *integration_point_writer);
    }
}

References addIntegrationPointWriter(), addOgsVersion(), addSecondaryVariableNodes(), addSecondaryVariableResiduals(), DBUG(), MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getName(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), MeshLib::NodePartitionedMesh::isGhostNode(), MaterialPropertyLib::name, MeshLib::Node, OGS_FATAL, ProcessLib::OutputDataSpecification::output_residuals, and ProcessLib::OutputDataSpecification::output_variables.

Referenced by ProcessLib::Output::doOutputAlways(), and ProcessLib::Output::doOutputNonlinearIteration().

addProcessDataToMesh() [2/2]

void ProcessLib::addProcessDataToMesh	(	const double	t,
		std::vector< GlobalVector * > const &	x,
		int const	process_id,
		MeshLib::Mesh &	mesh,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	bulk_dof_tables,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		std::vector< std::reference_wrapper< ProcessVariable >> const &	process_variables,
		SecondaryVariableCollection const &	secondary_variables,
		bool const	output_secondary_variable,
		std::vector< std::unique_ptr< IntegrationPointWriter >> const *	integration_point_writer,
		OutputDataSpecification const &	process_output
	)

Prepare the output data, i.e. add the solution to vtu data structure.

bheInflowpythonBindBoundaryCondition()

OGS_EXPORT_SYMBOL void ProcessLib::bheInflowpythonBindBoundaryCondition

(

pybind11::module &

m

)

Creates BHE Inflow Python bindings for the Python BC class.

Definition at line 64 of file BHEInflowPythonBoundaryConditionModule.cpp.

{
    namespace py = pybind11;
 
    py::class_<BHEInflowPythonBoundaryConditionPythonSideInterface,
               BHEInflowPythonBoundaryConditionPythonSideInterfaceTrampoline>
        pybc(m, "BHENetwork");
 
    pybc.def(py::init());
 
    pybc.def("initializeDataContainer",
             &BHEInflowPythonBoundaryConditionPythonSideInterface::
                 initializeDataContainer);
    pybc.def("tespySolver",
             &BHEInflowPythonBoundaryConditionPythonSideInterface::tespySolver);
 
    pybc.def("serverCommunication",
             &BHEInflowPythonBoundaryConditionPythonSideInterface::
                 serverCommunication);
}

References ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::tespySolver().

Referenced by PYBIND11_EMBEDDED_MODULE().

calculateNonEquilibriumInitialResiduum()

void ProcessLib::calculateNonEquilibriumInitialResiduum	(	std::vector< std::unique_ptr< ProcessData >> const &	per_process_data,
		std::vector< GlobalVector * >	process_solutions,
		std::vector< GlobalVector * > const &	process_solutions_prev
	)

Definition at line 251 of file TimeLoop.cpp.

{
    INFO("Calculate non-equilibrium initial residuum.");
    for (auto& process_data : per_process_data)
    {
        auto& ode_sys = *process_data->tdisc_ode_sys;
 
        auto& time_disc = *process_data->time_disc;
        auto& nonlinear_solver = process_data->nonlinear_solver;
        auto& conv_crit = *process_data->conv_crit;
 
        auto const nl_tag = process_data->nonlinear_solver_tag;
        setEquationSystem(nonlinear_solver, ode_sys, conv_crit, nl_tag);
        // dummy values to handle the time derivative terms more or less
        // correctly, i.e. to ignore them.
        double const t = 0;
        double const dt = 1;
        time_disc.nextTimestep(t, dt);
        nonlinear_solver.calculateNonEquilibriumInitialResiduum(
            process_solutions, process_solutions_prev,
            process_data->process_id);
    }
}

References INFO(), and anonymous_namespace{TimeLoop.cpp}::setEquationSystem().

Referenced by ProcessLib::TimeLoop::loop().

checkParametersOfDirichletBoundaryCondition()

void ProcessLib::checkParametersOfDirichletBoundaryCondition	(	MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id
	)

Definition at line 23 of file DirichletBoundaryConditionAuxiliaryFunctions.cpp.

{
    if (variable_id >=
            static_cast<int>(dof_table_bulk.getNumberOfVariables()) ||
        component_id >=
            dof_table_bulk.getNumberOfVariableComponents(variable_id))
    {
        OGS_FATAL(
            "Variable id or component id too high. Actual values: ({:d}, "
            "{:d}), maximum values: ({:d}, {:d}).",
            variable_id, component_id, dof_table_bulk.getNumberOfVariables(),
            dof_table_bulk.getNumberOfVariableComponents(variable_id));
    }
 
    if (!bc_mesh.getProperties().existsPropertyVector<std::size_t>(
            "bulk_node_ids"))
    {
        OGS_FATAL(
            "The required bulk node ids map does not exist in the boundary "
            "mesh '{:s}' or has the wrong data type (should be equivalent to "
            "C++ data type std::size_t which is an unsigned integer of size "
            "{:d} or UInt64 in vtk terminology).",
            bc_mesh.getName(), sizeof(std::size_t));
    }
 
    DBUG(
        "Found {:d} nodes for Dirichlet BCs for the variable {:d} and "
        "component {:d}",
        bc_mesh.getNodes().size(), variable_id, component_id);
}

References DBUG(), MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), MeshLib::Mesh::getProperties(), and OGS_FATAL.

Referenced by ProcessLib::DirichletBoundaryCondition::DirichletBoundaryCondition(), ProcessLib::PrimaryVariableConstraintDirichletBoundaryCondition::PrimaryVariableConstraintDirichletBoundaryCondition(), ProcessLib::SolutionDependentDirichletBoundaryCondition::SolutionDependentDirichletBoundaryCondition(), ProcessLib::DeactivatedSubdomainDirichlet::config(), and ProcessLib::DirichletBoundaryConditionWithinTimeInterval::config().

computeHMatrix()

template<int DisplacementDim, int NPOINTS, typename N_Type , typename HMatrixType >

void ProcessLib::computeHMatrix	(	N_Type const &	N,
		HMatrixType &	H
	)

Fills a H-matrix based on given shape function.

Definition at line 53 of file HMatrixUtils.h.

{
    static_assert(1 < DisplacementDim && DisplacementDim <= 3,
                  "LinearHMatrix::computeHMatrix: DisplacementDim must be in "
                  "range (1,3].");
 
    H.setZero();
 
    for (int j = 0; j < DisplacementDim; j++)
    {
        H.block(j, j * NPOINTS, 1, NPOINTS) = N;
    }
}

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerFracture< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::HydroMechanicsLocalAssemblerFracture(), and ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationLocalAssemblerFracture().

computeResiduum()

GlobalVector ProcessLib::computeResiduum	(	GlobalVector const &	x,
		GlobalVector const &	xdot,
		GlobalMatrix const &	M,
		GlobalMatrix const &	K,
		GlobalVector const &	b
	)

Computes the residuum r = -M*x_dot - K*x + b. Negation for consistency with the Newton scheme.

Definition at line 16 of file ComputeResiduum.cpp.

{
    using namespace MathLib::LinAlg;
    GlobalVector residuum;
    matMult(M, xdot, residuum);
    matMultAdd(K, x, residuum, residuum);
    axpy(residuum, -1, b);
    scale(residuum, -1);
    return residuum;
}

References MathLib::LinAlg::axpy(), MathLib::LinAlg::matMult(), MathLib::LinAlg::matMultAdd(), and MathLib::LinAlg::scale().

Referenced by ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), and ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess().

createBHEInflowPythonBoundaryCondition()

template<typename BHEType >

std::unique_ptr<BHEInflowPythonBoundaryCondition<BHEType> > ProcessLib::createBHEInflowPythonBoundaryCondition	(	std::pair< GlobalIndexType, GlobalIndexType > &&	in_out_global_indices,
		BHEType &	bhe,
		BHEInflowPythonBoundaryConditionPythonSideInterface &	py_bc_object
	)

Definition at line 96 of file BHEInflowPythonBoundaryCondition.h.

{
    DBUG("Constructing BHEInflowPythonBoundaryCondition.");
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // For this special boundary condition the boundary condition is not empty
    // if the global indices are non-negative.
    if (in_out_global_indices.first < 0 && in_out_global_indices.second < 0)
    {
        return nullptr;
    }
    // If only one of the global indices (in or out) is negative the
    // implementation is not valid.
    if (in_out_global_indices.first < 0 || in_out_global_indices.second < 0)
    {
        OGS_FATAL(
            "The partition cuts the BHE into two independent parts. This "
            "behaviour is not implemented.");
    }
#endif  // USE_PETSC
    return std::make_unique<BHEInflowPythonBoundaryCondition<BHEType>>(
        std::move(in_out_global_indices), bhe, py_bc_object);
}

References DBUG(), and OGS_FATAL.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom().

createBoundaryCondition()

std::unique_ptr< BoundaryCondition > ProcessLib::createBoundaryCondition	(	const BoundaryConditionConfig &	config,
		const NumLib::LocalToGlobalIndexMap &	dof_table,
		const MeshLib::Mesh &	bulk_mesh,
		const int	variable_id,
		const unsigned	integration_order,
		const unsigned	shapefunction_order,
		const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &	parameters,
		const Process &	process
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__PhaseFieldIrreversibleDamageOracleBoundaryCondition

Definition at line 35 of file CreateBoundaryCondition.cpp.

{
    // Surface mesh and bulk mesh must have equal axial symmetry flags!
    if (config.boundary_mesh.isAxiallySymmetric() !=
        bulk_mesh.isAxiallySymmetric())
    {
        OGS_FATAL(
            "The boundary mesh {:s} axially symmetric but the bulk mesh {:s}. "
            "Both must have an equal axial symmetry property.",
            config.boundary_mesh.isAxiallySymmetric() ? "is" : "is not",
            bulk_mesh.isAxiallySymmetric() ? "is" : "is not");
    }
 
    auto const type = config.config.peekConfigParameter<std::string>("type");
 
    if (type == "Dirichlet")
    {
        return ProcessLib::createDirichletBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, parameters);
    }
    if (type == "DirichletWithinTimeInterval")
    {
        return ProcessLib::createDirichletBoundaryConditionWithinTimeInterval(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, parameters);
    }
    if (type == "Neumann")
    {
        return ProcessLib::createNeumannBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, integration_order, shapefunction_order,
            bulk_mesh.getDimension(), parameters);
    }
    if (type == "Robin")
    {
        return ProcessLib::createRobinBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, integration_order, shapefunction_order,
            bulk_mesh.getDimension(), parameters);
    }
    if (type == "VariableDependentNeumann")
    {
        return ProcessLib::createVariableDependentNeumannBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, integration_order, shapefunction_order,
            bulk_mesh.getDimension(), parameters);
    }
 
    if (type == "Python")
    {
#ifdef OGS_USE_PYTHON
        return ProcessLib::createPythonBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, bulk_mesh.getID(),
            variable_id, *config.component_id, integration_order,
            shapefunction_order, bulk_mesh.getDimension());
#else
        OGS_FATAL("OpenGeoSys has not been built with Python support.");
#endif
    }
 
    //
    // Special boundary conditions
    //
    if (type == "ConstraintDirichlet")
    {
        return createConstraintDirichletBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            integration_order, *config.component_id, parameters, process);
    }
    if (type == "PrimaryVariableConstraintDirichlet")
    {
        return createPrimaryVariableConstraintDirichletBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, parameters);
    }
    if (type == "SolutionDependentDirichlet")
    {
        return ProcessLib::createSolutionDependentDirichletBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, parameters);
    }
    if (type == "HCNonAdvectiveFreeComponentFlowBoundary")
    {
        return createHCNonAdvectiveFreeComponentFlowBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, variable_id,
            *config.component_id, integration_order, parameters,
            bulk_mesh.getDimension(), process, shapefunction_order);
    }
    if (type == "NormalTraction")
    {
        switch (bulk_mesh.getDimension())
        {
            case 2:
                return ProcessLib::NormalTractionBoundaryCondition::
                    createNormalTractionBoundaryCondition<2>(
                        config.config, config.boundary_mesh, dof_table,
                        variable_id, integration_order, shapefunction_order,
                        parameters);
            case 3:
                return ProcessLib::NormalTractionBoundaryCondition::
                    createNormalTractionBoundaryCondition<3>(
                        config.config, config.boundary_mesh, dof_table,
                        variable_id, integration_order, shapefunction_order,
                        parameters);
            default:
                OGS_FATAL(
                    "NormalTractionBoundaryCondition can not be instantiated "
                    "for mesh dimensions other than two or three. "
                    "{}-dimensional mesh was given.",
                    bulk_mesh.getDimension());
        }
    }
    if (type == "PhaseFieldIrreversibleDamageOracleBoundaryCondition")
    {
        return ProcessLib::
            createPhaseFieldIrreversibleDamageOracleBoundaryCondition(
                config.config, dof_table, bulk_mesh, variable_id,
                *config.component_id);
    }
    OGS_FATAL("Unknown boundary condition type: `{:s}'.", type);
}

References ProcessLib::BoundaryConditionConfig::boundary_mesh, ProcessLib::BoundaryConditionConfig::component_id, ProcessLib::BoundaryConditionConfig::config, createConstraintDirichletBoundaryCondition(), createDirichletBoundaryCondition(), createDirichletBoundaryConditionWithinTimeInterval(), createHCNonAdvectiveFreeComponentFlowBoundaryCondition(), createNeumannBoundaryCondition(), createPhaseFieldIrreversibleDamageOracleBoundaryCondition(), createPrimaryVariableConstraintDirichletBoundaryCondition(), createPythonBoundaryCondition(), createRobinBoundaryCondition(), createSolutionDependentDirichletBoundaryCondition(), createVariableDependentNeumannBoundaryCondition(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getID(), MeshLib::Mesh::isAxiallySymmetric(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::ProcessVariable::createBoundaryConditions().

createCentralDifferencesJacobianAssembler()

std::unique_ptr< CentralDifferencesJacobianAssembler > ProcessLib::createCentralDifferencesJacobianAssembler

(

BaseLib::ConfigTree const &

config

)

Input File Parameter:

prj__processes__process__jacobian_assembler__type

Input File Parameter:

prj__processes__process__jacobian_assembler__CentralDifferences__relative_epsilons

Input File Parameter:

prj__processes__process__jacobian_assembler__CentralDifferences__component_magnitudes

Definition at line 148 of file CentralDifferencesJacobianAssembler.cpp.

{
    config.checkConfigParameter("type", "CentralDifferences");
 
    // TODO make non-optional.
    auto rel_eps = config.getConfigParameterOptional<std::vector<double>>(
        "relative_epsilons");
    auto comp_mag = config.getConfigParameterOptional<std::vector<double>>(
        "component_magnitudes");
 
    if (!!rel_eps != !!comp_mag)
    {
        OGS_FATAL(
            "Either both or none of <relative_epsilons> and "
            "<component_magnitudes> have to be specified.");
    }
 
    std::vector<double> abs_eps;
 
    if (rel_eps)
    {
        if (rel_eps->size() != comp_mag->size())
        {
            OGS_FATAL(
                "The numbers of components of  <relative_epsilons> and "
                "<component_magnitudes> do not match.");
        }
 
        abs_eps.resize(rel_eps->size());
        for (std::size_t i = 0; i < rel_eps->size(); ++i)
        {
            abs_eps[i] = (*rel_eps)[i] * (*comp_mag)[i];
        }
    }
    else
    {
        // By default 1e-8 is used as epsilon for all components.
        // TODO: remove this default value.
        abs_eps.emplace_back(1e-8);
    }
 
    return std::make_unique<CentralDifferencesJacobianAssembler>(
        std::move(abs_eps));
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), and OGS_FATAL.

Referenced by createJacobianAssembler().

createCompareJacobiansJacobianAssembler()

std::unique_ptr< CompareJacobiansJacobianAssembler > ProcessLib::createCompareJacobiansJacobianAssembler

(

BaseLib::ConfigTree const &

config

)

Input File Parameter:

prj__processes__process__jacobian_assembler__type

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__jacobian_assembler

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__reference_jacobian_assembler

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__abs_tol

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__rel_tol

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__fail_on_error

Input File Parameter:

prj__processes__process__jacobian_assembler__CompareJacobians__log_file

Definition at line 401 of file CompareJacobiansJacobianAssembler.cpp.

{
    // TODO doc script corner case: Parameter could occur at different
    // locations.
    config.checkConfigParameter("type", "CompareJacobians");
 
    auto asm1 =
        createJacobianAssembler(config.getConfigSubtree("jacobian_assembler"));
 
    auto asm2 = createJacobianAssembler(
        config.getConfigSubtree("reference_jacobian_assembler"));
 
    auto const abs_tol = config.getConfigParameter<double>("abs_tol");
    auto const rel_tol = config.getConfigParameter<double>("rel_tol");
 
    auto const fail_on_error = config.getConfigParameter<bool>("fail_on_error");
 
    auto const log_file = config.getConfigParameter<std::string>("log_file");
 
    return std::make_unique<CompareJacobiansJacobianAssembler>(
        std::move(asm1), std::move(asm2), abs_tol, rel_tol, fail_on_error,
        log_file);
}

References BaseLib::ConfigTree::checkConfigParameter(), createJacobianAssembler(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::getConfigSubtree().

Referenced by createJacobianAssembler().

createConstraintDirichletBoundaryCondition()

std::unique_ptr< ConstraintDirichletBoundaryCondition > ProcessLib::createConstraintDirichletBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		unsigned const	integration_order,
		int const	component_id,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		Process const &	constraining_process
	)

The function parses the config tree and creates a ConstraintDirichletBoundaryCondition.

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__ConstraintDirichletBoundaryCondition__constraint_type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__ConstraintDirichletBoundaryCondition__constraining_process_variable

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__ConstraintDirichletBoundaryCondition__constraint_threshold

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__ConstraintDirichletBoundaryCondition__constraint_direction

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__ConstraintDirichletBoundaryCondition__parameter

Definition at line 229 of file ConstraintDirichletBoundaryCondition.cpp.

{
    DBUG("Constructing ConstraintDirichletBoundaryCondition from config.");
    config.checkConfigParameter("type", "ConstraintDirichlet");
 
    auto const constraint_type =
        config.getConfigParameter<std::string>("constraint_type");
    if (constraint_type != "Flux")
    {
        OGS_FATAL("The constraint type is '{:s}', but has to be 'Flux'.",
                  constraint_type);
    }
 
    // Todo (TF) Open question: How to specify which getFlux function should be
    // used for the constraint calculation?
    auto const constraining_process_variable =
        config.getConfigParameter<std::string>("constraining_process_variable");
 
    if (!constraining_process.isMonolithicSchemeUsed())
    {
        OGS_FATAL(
            "The constraint dirichlet boundary condition is implemented only "
            "for monolithic implemented processes.");
    }
    const int process_id = 0;
    auto process_variables =
        constraining_process.getProcessVariables(process_id);
    auto constraining_pv =
        std::find_if(process_variables.cbegin(), process_variables.cend(),
                     [&constraining_process_variable](ProcessVariable const& pv)
                     { return pv.getName() == constraining_process_variable; });
    if (constraining_pv == std::end(process_variables))
    {
        auto const& constraining_process_variable_name =
            process_variables[variable_id].get().getName();
        OGS_FATAL(
            "<constraining_process_variable> in process variable name '{:s}' "
            "at geometry 'TODO' : The constraining process variable is set as "
            "'{:s}', but this is not specified in the project file.",
            constraining_process_variable_name,
            constraining_process_variable);
    }
 
    auto const constraint_threshold =
        config.getConfigParameter<double>("constraint_threshold");
 
    auto const constraint_direction_string =
        config.getConfigParameter<std::string>("constraint_direction");
    if (constraint_direction_string != "greater" &&
        constraint_direction_string != "lower")
    {
        OGS_FATAL(
            "The constraint direction is '{:s}', but has to be either "
            "'greater' or 'lower'.",
            constraint_direction_string);
    }
    bool const lower = constraint_direction_string == "lower";
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", param_name);
 
    auto& param = ParameterLib::findParameter<double>(param_name, parameters, 1,
                                                      &bc_mesh);
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<ConstraintDirichletBoundaryCondition>(
        param, dof_table_bulk, variable_id, component_id, bc_mesh,
        integration_order, constraining_process.getMesh(), constraint_threshold,
        lower,
        [&constraining_process](std::size_t const element_id,
                                MathLib::Point3d const& pnt, double const t,
                                std::vector<GlobalVector*> const& x)
        { return constraining_process.getFlux(element_id, pnt, t, x); });
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getProcessVariables(), ProcessLib::Process::isMonolithicSchemeUsed(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createDeactivatedSubdomain()

std::unique_ptr<DeactivatedSubdomain const> ProcessLib::createDeactivatedSubdomain	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	mesh,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &	curves
	)

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__time_interval

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__time_curve

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__line_segment

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__boundary_parameter

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__material_ids

Definition at line 172 of file CreateDeactivatedSubdomain.cpp.

{
    auto const& time_interval_config =
        config.getConfigSubtreeOptional("time_interval");
 
    auto const& curve_name =
        config.getConfigParameterOptional<std::string>("time_curve");
    auto time_interval =
        parseTimeIntervalOrCurve(time_interval_config, curve_name, curves);
 
    auto const line_segment_config =
        config.getConfigSubtreeOptional("line_segment");
 
    if (time_interval_config && line_segment_config)
    {
        OGS_FATAL(
            "When using time interval for subdomain deactivation a line "
            "segment must not be specified.");
    }
 
    if (curve_name && !line_segment_config)
    {
        OGS_FATAL(
            "When using curve for subdomain deactivation a line segment must "
            "be specified.");
    }
 
    // If time interval was specified then a dummy line segment is used
    // *internally* because the whole selected material ids subdomain will be
    // deactivated.
    std::pair line_segment{Eigen::Vector3d{0, 0, 0}, Eigen::Vector3d{1, 1, 1}};
 
    if (curve_name)
    {
        line_segment = parseLineSegment(*line_segment_config);
    }
 
    ParameterLib::Parameter<double>* boundary_value_parameter = nullptr;
    auto boundary_value_parameter_name =
        config.getConfigParameterOptional<std::string>("boundary_parameter");
    if (boundary_value_parameter_name)
    {
        DBUG("Using parameter {:s}", *boundary_value_parameter_name);
        boundary_value_parameter = &ParameterLib::findParameter<double>(
            *boundary_value_parameter_name, parameters, 1, &mesh);
    }
 
    auto deactivated_subdomain_material_ids =
        config.getConfigParameter("material_ids", std::vector<int>{});
 
    if (deactivated_subdomain_material_ids.empty())
    {
        OGS_FATAL(
            "The material IDs of the deactivated subdomains are not given. The "
            "program terminates now.");
    }
 
    std::sort(deactivated_subdomain_material_ids.begin(),
              deactivated_subdomain_material_ids.end());
 
    auto const* const material_ids = materialIDs(mesh);
    if (material_ids == nullptr)
    {
        OGS_FATAL(
            "The mesh doesn't contain materialIDs for subdomain deactivation. "
            "The program terminates now.");
    }
 
    std::vector<std::unique_ptr<DeactivatedSubdomainMesh>>
        deactivated_subdomain_meshes;
    deactivated_subdomain_meshes.reserve(
        deactivated_subdomain_material_ids.size());
 
    std::transform(begin(deactivated_subdomain_material_ids),
                   end(deactivated_subdomain_material_ids),
                   back_inserter(deactivated_subdomain_meshes),
                   [&](std::size_t const id)
                   { return createDeactivatedSubdomainMesh(mesh, id); });
 
    return std::make_unique<DeactivatedSubdomain const>(
        std::move(time_interval),
        line_segment,
        std::move(deactivated_subdomain_material_ids),
        std::move(deactivated_subdomain_meshes),
        boundary_value_parameter);
}

References createDeactivatedSubdomainMesh(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtreeOptional(), MeshLib::materialIDs(), OGS_FATAL, parseLineSegment(), and parseTimeIntervalOrCurve().

Referenced by createDeactivatedSubdomains().

createDeactivatedSubdomainMesh()

static std::unique_ptr<DeactivatedSubdomainMesh> ProcessLib::createDeactivatedSubdomainMesh ( MeshLib::Mesh const &  mesh, int const  material_id  )

static

Definition at line 64 of file CreateDeactivatedSubdomain.cpp.

{
    // An element is active if its material id matches the selected material id.
    auto is_active = [material_id, material_ids = *materialIDs(mesh)](
                         MeshLib::Element const* const e)
    { return material_id == material_ids[e->getID()]; };
 
    auto const& elements = mesh.getElements();
    std::vector<MeshLib::Element*> deactivated_elements;
    std::copy_if(begin(elements), end(elements),
                 back_inserter(deactivated_elements),
                 [&](auto const e) { return is_active(e); });
 
    // Subdomain mesh consisting of deactivated elements.
    auto sub_mesh = MeshLib::createMeshFromElementSelection(
        "deactivate_subdomain_" + std::to_string(material_id),
        MeshLib::cloneElements(deactivated_elements));
 
    auto [inner_nodes, outer_nodes] =
        extractInnerAndOuterNodes(mesh, *sub_mesh, is_active);
    return std::make_unique<DeactivatedSubdomainMesh>(
        std::move(sub_mesh), std::move(inner_nodes), std::move(outer_nodes));
}

References MeshLib::cloneElements(), MeshLib::createMeshFromElementSelection(), extractInnerAndOuterNodes(), MeshLib::Mesh::getElements(), and MeshLib::materialIDs().

Referenced by createDeactivatedSubdomain().

createDeactivatedSubdomains()

std::vector< std::unique_ptr< DeactivatedSubdomain const > > ProcessLib::createDeactivatedSubdomains	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	mesh,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &	curves
	)

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain

Definition at line 270 of file CreateDeactivatedSubdomain.cpp.

{
    std::vector<std::unique_ptr<DeactivatedSubdomain const>>
        deactivated_subdomains;
    // Deactivated subdomains
    if (auto subdomains_config =
        config.getConfigSubtreeOptional("deactivated_subdomains"))
    {
        INFO("There are subdomains being deactivated.");
 
        auto const deactivated_subdomain_configs =
            subdomains_config->getConfigSubtreeList("deactivated_subdomain");
        std::transform(begin(deactivated_subdomain_configs),
                       end(deactivated_subdomain_configs),
                       back_inserter(deactivated_subdomains),
                       [&](auto const& config) {
                           return createDeactivatedSubdomain(
                               config, mesh, parameters, curves);
                       });
    }
    return deactivated_subdomains;
}

References createDeactivatedSubdomain(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and INFO().

createDirichletBoundaryCondition()

std::unique_ptr< DirichletBoundaryCondition > ProcessLib::createDirichletBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id,
		const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Dirichlet__parameter

Definition at line 57 of file DirichletBoundaryCondition.cpp.

{
    DBUG("Constructing DirichletBoundaryCondition from config.");
    config.checkConfigParameter("type", "Dirichlet");
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", param_name);
 
    auto& parameter = ParameterLib::findParameter<double>(
        param_name, parameters, 1, &bc_mesh);
 
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<DirichletBoundaryCondition>(
        parameter, bc_mesh, dof_table_bulk, variable_id, component_id);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getNumberOfElements(), and MeshLib::Mesh::getNumberOfNodes().

Referenced by createBoundaryCondition().

createDirichletBoundaryConditionWithinTimeInterval()

std::unique_ptr< BoundaryCondition > ProcessLib::createDirichletBoundaryConditionWithinTimeInterval	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id,
		const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__DirichletWithinTimeInterval__parameter

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__DirichletWithinTimeInterval__time_interval

Definition at line 20 of file CreateDirichletBoundaryConditionWithinTimeInterval.cpp.

{
    DBUG(
        "Constructing DirichletBoundaryConditionWithinTimeInterval from "
        "config.");
 
    config.checkConfigParameter("type", "DirichletWithinTimeInterval");
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", param_name);
 
    auto& param = ParameterLib::findParameter<double>(param_name, parameters, 1,
                                                      &bc_mesh);
 
    config.peekConfigParameter<std::string>("time_interval");
    auto time_interval = BaseLib::createTimeInterval(config);
 
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<DirichletBoundaryConditionWithinTimeInterval>(
        std::move(time_interval), param, bc_mesh, dof_table_bulk, variable_id,
        component_id);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::createTimeInterval(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by createBoundaryCondition().

createHCNonAdvectiveFreeComponentFlowBoundaryCondition()

std::unique_ptr< HCNonAdvectiveFreeComponentFlowBoundaryCondition > ProcessLib::createHCNonAdvectiveFreeComponentFlowBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	global_dim,
		Process const &	process,
		unsigned const	shapefunction_order
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__HCNonAdvectiveFreeComponentFlowBoundary__parameter

Definition at line 19 of file HCNonAdvectiveFreeComponentFlowBoundaryCondition.cpp.

{
    DBUG(
        "Constructing open boundary for Component Transport process from "
        "config.");
    config.checkConfigParameter("type",
                                "HCNonAdvectiveFreeComponentFlowBoundary");
 
    if (bc_mesh.getDimension() + 1 != global_dim)
    {
        OGS_FATAL(
            "The dimension ({:d}) of the given boundary mesh '{:s}' is not by "
            "one lower than the bulk dimension ({:d}).",
            bc_mesh.getDimension(), bc_mesh.getName(), global_dim);
    }
 
    auto const boundary_permeability_name =
        config.getConfigParameter<std::string>("parameter");
    auto const& boundary_permeability = ParameterLib::findParameter<double>(
        boundary_permeability_name, parameters, 1, &bc_mesh);
 
    if (global_dim != 3)
    {
        OGS_FATAL(
            "HCNonAdvectiveFreeComponentFlowBoundary is only implemented for "
            "2D boundary meshes");
    }
    auto const bulk_element_ids =
        bc_mesh.getProperties().template getPropertyVector<std::size_t>(
            "bulk_element_ids", MeshLib::MeshItemType::Cell, 1);
    auto const bulk_face_ids =
        bc_mesh.getProperties().template getPropertyVector<std::size_t>(
            "bulk_face_ids", MeshLib::MeshItemType::Cell, 1);
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<HCNonAdvectiveFreeComponentFlowBoundaryCondition>(
        integration_order, shapefunction_order, dof_table, variable_id,
        component_id, global_dim, bc_mesh,
        HCNonAdvectiveFreeComponentFlowBoundaryConditionData{
            boundary_permeability, *bulk_face_ids, *bulk_element_ids, process});
}

References MeshLib::Cell, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createJacobianAssembler()

std::unique_ptr< AbstractJacobianAssembler > ProcessLib::createJacobianAssembler

(

std::optional< BaseLib::ConfigTree > const &

config

)

Input File Parameter:

prj__processes__process__jacobian_assembler__type

Definition at line 20 of file CreateJacobianAssembler.cpp.

{
    if (!config)
    {
        return std::make_unique<AnalyticalJacobianAssembler>();
    }
 
    auto const type = config->peekConfigParameter<std::string>("type");
 
    if (type == "Analytical")
    {
        config->ignoreConfigParameter("type");
        return std::make_unique<AnalyticalJacobianAssembler>();
    }
    if (type == "CentralDifferences")
    {
        return createCentralDifferencesJacobianAssembler(*config);
    }
    if (type == "CompareJacobians")
    {
        return createCompareJacobiansJacobianAssembler(*config);
    }
 
    OGS_FATAL("Unknown Jacobian assembler type: `{:s}'.", type);
}

References createCentralDifferencesJacobianAssembler(), createCompareJacobiansJacobianAssembler(), and OGS_FATAL.

Referenced by createCompareJacobiansJacobianAssembler(), and ProjectData::parseProcesses().

createLocalAssemblers() [1/2]

template<template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::createLocalAssemblers	(	const unsigned	dimension,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		const unsigned	shapefunction_order,
		std::vector< std::unique_ptr< LocalAssemblerInterface >> &	local_assemblers,
		ExtraCtorArgs &&...	extra_ctor_args
	)

Creates local assemblers for each element of the given mesh.

Template Parameters

LocalAssemblerImplementation	the individual local assembler type
LocalAssemblerInterface	the general local assembler interface
ExtraCtorArgs	types of additional constructor arguments. Those arguments will be passed to the constructor of LocalAssemblerImplementation.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 64 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    switch (dimension)
    {
        case 1:
            createLocalAssemblers<1, LocalAssemblerImplementation>(
                dof_table, shapefunction_order, mesh_elements, local_assemblers,
                std::forward<ExtraCtorArgs>(extra_ctor_args)...);
            break;
        case 2:
            createLocalAssemblers<2, LocalAssemblerImplementation>(
                dof_table, shapefunction_order, mesh_elements, local_assemblers,
                std::forward<ExtraCtorArgs>(extra_ctor_args)...);
            break;
        case 3:
            createLocalAssemblers<3, LocalAssemblerImplementation>(
                dof_table, shapefunction_order, mesh_elements, local_assemblers,
                std::forward<ExtraCtorArgs>(extra_ctor_args)...);
            break;
        default:
            OGS_FATAL(
                "Meshes with dimension greater than three are not supported.");
    }
}

References DBUG(), and OGS_FATAL.

createLocalAssemblers() [2/2]

template<int GlobalDim, template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::createLocalAssemblers	(	NumLib::LocalToGlobalIndexMap const &	dof_table,
		const unsigned	shapefunction_order,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		std::vector< std::unique_ptr< LocalAssemblerInterface >> &	local_assemblers,
		ExtraCtorArgs &&...	extra_ctor_args
	)

Definition at line 23 of file CreateLocalAssemblers.h.

{
    static_assert(
        GlobalDim == 1 || GlobalDim == 2 || GlobalDim == 3,
        "Meshes with dimension greater than three are not supported.");
    // Shape matrices initializer
    using LocalDataInitializer =
        LocalDataInitializer<LocalAssemblerInterface,
                             LocalAssemblerImplementation, GlobalDim,
                             ExtraCtorArgs...>;
 
    DBUG("Create local assemblers.");
    // Populate the vector of local assemblers.
    local_assemblers.resize(mesh_elements.size());
 
    LocalDataInitializer initializer(dof_table, shapefunction_order);
 
    DBUG("Calling local assembler builder for all mesh elements.");
    GlobalExecutor::transformDereferenced(
        initializer, mesh_elements, local_assemblers,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References DBUG(), and NumLib::SerialExecutor::transformDereferenced().

createNeumannBoundaryCondition()

std::unique_ptr< NeumannBoundaryCondition > ProcessLib::createNeumannBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Neumann__parameter

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Neumann__area_parameter

Definition at line 17 of file NeumannBoundaryCondition.cpp.

{
    DBUG("Constructing Neumann BC from config.");
    config.checkConfigParameter("type", "Neumann");
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", param_name);
 
    auto const& param = ParameterLib::findParameter<double>(
        param_name, parameters, 1, &bc_mesh);
 
    // In case of partitioned mesh the boundary could be empty, i.e. there
    // is no boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    ParameterLib::Parameter<double> const* integral_measure(nullptr);
    if (global_dim - bc_mesh.getDimension() != 1)
    {
        auto const area_parameter_name =
            config.getConfigParameter<std::string>("area_parameter");
        DBUG("area parameter name '{:s}'", area_parameter_name);
        integral_measure = &ParameterLib::findParameter<double>(
            area_parameter_name, parameters, 1, &bc_mesh);
    }
 
    if (bc_mesh.getDimension() >= global_dim)
    {
        OGS_FATAL(
            "The dimension ({:d}) of the given boundary mesh '{:s}' is not "
            "lower than the bulk dimension ({:d}).",
            bc_mesh.getDimension(), bc_mesh.getName(), global_dim);
    }
 
    return std::make_unique<NeumannBoundaryCondition>(
        integration_order, shapefunction_order, dof_table, variable_id,
        component_id, global_dim, bc_mesh,
        NeumannBoundaryConditionData{param, integral_measure});
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createNodalSourceTerm()

std::unique_ptr< SourceTerm > ProcessLib::createNodalSourceTerm	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	st_mesh,
		std::unique_ptr< NumLib::LocalToGlobalIndexMap >	dof_table,
		std::size_t const	source_term_mesh_id,
		const int	variable_id,
		const int	component_id,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__Nodal__parameter

Definition at line 20 of file CreateNodalSourceTerm.cpp.

{
    DBUG("Constructing NodalSourceTerm from config.");
    config.checkConfigParameter("type", "Nodal");
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s} as nodal source term.", param_name);
 
    auto& param = ParameterLib::findParameter<double>(param_name, parameters, 1,
                                                      &st_mesh);
 
    return std::make_unique<NodalSourceTerm>(std::move(dof_table),
                                             source_term_mesh_id, st_mesh,
                                             variable_id, component_id, param);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by createSourceTerm().

createOutput()

std::unique_ptr< Output > ProcessLib::createOutput	(	const BaseLib::ConfigTree &	config,
		std::string const &	output_directory,
		std::vector< std::unique_ptr< MeshLib::Mesh >> const &	meshes
	)

Input File Parameter:

prj__time_loop__output__type

Input File Parameter:

prj__time_loop__output__prefix

Input File Parameter:

prj__time_loop__output__suffix

Input File Parameter:

prj__time_loop__output__compress_output

Input File Parameter:

prj__time_loop__output__hdf

Input File Parameter:

prj__time_loop__output__hdf__number_of_files

Input File Parameter:

prj__time_loop__output__data_mode

Input File Parameter:

prj__time_loop__output__timesteps

Input File Parameter:

prj__time_loop__output__timesteps__pair

Input File Parameter:

prj__time_loop__output__timesteps__pair__repeat

Input File Parameter:

prj__time_loop__output__timesteps__pair__each_steps

Input File Parameter:

prj__time_loop__output__variables

Input File Parameter:

prj__time_loop__output__variables__variable

Input File Parameter:

prj__time_loop__output__output_extrapolation_residuals

Input File Parameter:

prj__time_loop__output__meshes

Input File Parameter:

prj__time_loop__output__meshes__mesh

Input File Parameter:

prj__time_loop__output__fixed_output_times

Input File Parameter:

prj__time_loop__output__output_iteration_results

Definition at line 25 of file CreateOutput.cpp.

{
    DBUG("Parse output configuration:");
    OutputType const output_type = [](auto output_type)
    {
        try
        {
            const std::map<std::string, OutputType> outputType_to_enum = {
                {"VTK", OutputType::vtk}, {"XDMF", OutputType::xdmf}};
            auto type = outputType_to_enum.at(output_type);
 
            return type;
        }
        catch (std::out_of_range&)
        {
            OGS_FATAL(
                "No supported file type provided. Read `{:s}' from <output><type> \
                in prj File. Supported: VTK, XDMF.",
                output_type);
        }
    }(config.getConfigParameter<std::string>("type"));
 
    auto const prefix =
        config.getConfigParameter<std::string>("prefix", "{:meshname}");
 
    auto const suffix =
        config.getConfigParameter<std::string>("suffix",
                                               "_ts_{:timestep}_t_{:time}");
 
    auto const compress_output =
        config.getConfigParameter("compress_output", true);
 
    auto const hdf =
        config.getConfigSubtreeOptional("hdf");
 
    auto number_of_files = [&hdf]() -> unsigned int
    {
        if (hdf)
        {
            return hdf->getConfigParameter<unsigned int>("number_of_files");
        }
        else
        {
            return 1;
        }
    }();
 
    auto const data_mode =
        config.getConfigParameter<std::string>("data_mode", "Appended");
 
    // Construction of output times
    std::vector<Output::PairRepeatEachSteps> repeats_each_steps;
 
    if (auto const timesteps = config.getConfigSubtreeOptional("timesteps"))
    {
        for (auto pair : timesteps->getConfigSubtreeList("pair"))
        {
            auto repeat = pair.getConfigParameter<unsigned>("repeat");
            auto each_steps = pair.getConfigParameter<unsigned>("each_steps");
 
            assert(repeat != 0 && each_steps != 0);
            repeats_each_steps.emplace_back(repeat, each_steps);
        }
 
        if (repeats_each_steps.empty())
        {
            OGS_FATAL(
                "You have not given any pair (<repeat/>, <each_steps/>) that "
                "defines at which timesteps output shall be written. "
                "Aborting.");
        }
    }
    else
    {
        repeats_each_steps.emplace_back(1, 1);
    }
 
    auto const out_vars = config.getConfigSubtree("variables");
 
    std::set<std::string> output_variables;
    for (auto out_var :
         out_vars.getConfigParameterList<std::string>("variable"))
    {
        if (output_variables.find(out_var) != output_variables.cend())
        {
            OGS_FATAL("output variable `{:s}' specified more than once.",
                      out_var);
        }
 
        DBUG("adding output variable `{:s}'", out_var);
        output_variables.insert(out_var);
    }
 
    bool const output_residuals = config.getConfigParameter<bool>(
        "output_extrapolation_residuals", false);
 
    OutputDataSpecification output_data_specification{output_variables,
                                                      output_residuals};
 
    std::vector<std::string> mesh_names_for_output;
    if (auto const meshes_config = config.getConfigSubtreeOptional("meshes"))
    {
        if (prefix.find("{:meshname}") == std::string::npos)
        {
            OGS_FATAL(
                "There are multiple meshes defined in the output section of "
                "the project file, but the prefix doesn't contain "
                "'{{:meshname}}'. Thus the names for the files, the simulation "
                "results should be written to, would not be distinguishable "
                "for different meshes.");
        }
        for (auto mesh_config : meshes_config->getConfigParameterList("mesh"))
        {
            mesh_names_for_output.push_back(
                mesh_config.getValue<std::string>());
            INFO("Configure mesh '{:s}' for output.",
                 mesh_names_for_output.back());
        }
    }
 
    std::vector<double> fixed_output_times =
        config.getConfigParameter<std::vector<double>>("fixed_output_times",
                                                       {});
    // Remove possible duplicated elements and sort.
    BaseLib::makeVectorUnique(fixed_output_times);
 
    bool const output_iteration_results =
        config.getConfigParameter<bool>("output_iteration_results", false);
 
    return std::make_unique<Output>(
        output_directory, output_type, prefix, suffix, compress_output,
        number_of_files, data_mode, output_iteration_results,
        std::move(repeats_each_steps), std::move(fixed_output_times),
        std::move(output_data_specification), std::move(mesh_names_for_output),
        meshes);
}

References DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), BaseLib::makeVectorUnique(), OGS_FATAL, vtk, and xdmf.

Referenced by createTimeLoop().

createPerProcessData()

std::vector< std::unique_ptr< ProcessData > > ProcessLib::createPerProcessData	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< Process >> const &	processes,
		std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase >> const &	nonlinear_solvers
	)

Input File Parameter:

prj__time_loop__processes__process

Input File Parameter:

prj__time_loop__processes__process__ref

Input File Parameter:

prj__time_loop__processes__process__nonlinear_solver

Input File Parameter:

prj__time_loop__processes__process__time_discretization

Input File Parameter:

prj__time_loop__processes__process__time_stepping

Input File Parameter:

prj__time_loop__processes__process__convergence_criterion

Input File Parameter:

prj__time_loop__processes__process__compensate_non_equilibrium_initial_residuum

Input File Parameter:

prj__time_loop__processes__process__output

Definition at line 65 of file CreateProcessData.cpp.

{
    std::vector<std::unique_ptr<ProcessData>> per_process_data;
    int process_id = 0;
 
    for (auto pcs_config : config.getConfigSubtreeList("process"))
    {
        auto const pcs_name = pcs_config.getConfigAttribute<std::string>("ref");
        auto& pcs = *BaseLib::getIfOrError(
            processes,
            [&pcs_name](std::unique_ptr<Process> const& p)
            { return p->name == pcs_name; },
            "A process with the given name has not been defined.");
 
        auto const nl_slv_name =
            pcs_config.getConfigParameter<std::string>("nonlinear_solver");
        auto& nl_slv = *BaseLib::getOrError(
            nonlinear_solvers, nl_slv_name,
            "A nonlinear solver with the given name has not been defined.");
 
        auto time_disc = NumLib::createTimeDiscretization(
            pcs_config.getConfigSubtree("time_discretization"));
 
        auto timestepper = NumLib::createTimeStepper(
            pcs_config.getConfigSubtree("time_stepping"));
 
        auto conv_crit = NumLib::createConvergenceCriterion(
            pcs_config.getConfigSubtree("convergence_criterion"));
 
        auto const compensate_non_equilibrium_initial_residuum =
            pcs_config.getConfigParameter<bool>(
                "compensate_non_equilibrium_initial_residuum", false);
 
        auto output = pcs_config.getConfigSubtreeOptional("output");
        if (output)
        {
            OGS_FATAL(
                "In order to make the specification of output in the project "
                "file consistent, the variables output tags were moved from "
                "xpath "
                "'//OpenGeoSysProject/time_loop/processes/process/output' to "
                "the global output section, i.e., to the xpath "
                "'//OpenGeoSysProject/time_loop/output'. This has to be done "
                "in the current project file!");
        }
 
        per_process_data.emplace_back(
            makeProcessData(std::move(timestepper), nl_slv, process_id, pcs,
                            std::move(time_disc), std::move(conv_crit),
                            compensate_non_equilibrium_initial_residuum));
        ++process_id;
    }
 
    if (per_process_data.size() != processes.size())
    {
        if (processes.size() > 1)
        {
            OGS_FATAL(
                "Some processes have not been configured to be solved by this  "
                "time loop.");
        }
        else
        {
            INFO(
                "The equations of the coupled processes will be solved by the "
                "staggered scheme.");
        }
    }
 
    return per_process_data;
}

References NumLib::createConvergenceCriterion(), NumLib::createTimeDiscretization(), NumLib::createTimeStepper(), BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::getIfOrError(), BaseLib::getOrError(), INFO(), makeProcessData(), and OGS_FATAL.

Referenced by createTimeLoop().

createPhaseFieldIrreversibleDamageOracleBoundaryCondition()

std::unique_ptr< PhaseFieldIrreversibleDamageOracleBoundaryCondition > ProcessLib::createPhaseFieldIrreversibleDamageOracleBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh,
		int const	variable_id,
		int const	component_id
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Definition at line 69 of file PhaseFieldIrreversibleDamageOracleBoundaryCondition.cpp.

{
    DBUG(
        "Constructing PhaseFieldIrreversibleDamageOracleBoundaryCondition from "
        "config.");
    config.checkConfigParameter(
        "type", "PhaseFieldIrreversibleDamageOracleBoundaryCondition");
 
    return std::make_unique<
        PhaseFieldIrreversibleDamageOracleBoundaryCondition>(
        dof_table, mesh, variable_id, component_id);
}

References BaseLib::ConfigTree::checkConfigParameter(), and DBUG().

Referenced by createBoundaryCondition().

createPrimaryVariableConstraintDirichletBoundaryCondition()

std::unique_ptr< PrimaryVariableConstraintDirichletBoundaryCondition > ProcessLib::createPrimaryVariableConstraintDirichletBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id,
		const std::vector< std::unique_ptr< ParameterLib::ParameterBase >> &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__PrimaryVariableConstraintDirichletBoundaryCondition__parameter

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__PrimaryVariableConstraintDirichletBoundaryCondition__threshold_parameter

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__PrimaryVariableConstraintDirichletBoundaryCondition__comparison_operator

Definition at line 107 of file PrimaryVariableConstraintDirichletBoundaryCondition.cpp.

{
    DBUG(
        "Constructing PrimaryVariableConstraintDirichletBoundaryCondition from "
        "config.");
    config.checkConfigParameter("type", "PrimaryVariableConstraintDirichlet");
 
    auto const param_name = config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", param_name);
 
    auto& parameter = ParameterLib::findParameter<double>(
        param_name, parameters, 1, &bc_mesh);
 
    auto const threshold_parameter_name =
        config.getConfigParameter<std::string>("threshold_parameter");
    DBUG("Using parameter {:s} as threshold_parameter",
         threshold_parameter_name);
 
    auto& threshold_parameter = ParameterLib::findParameter<double>(
        threshold_parameter_name, parameters, 1, &bc_mesh);
 
    auto const comparison_operator_string =
        config.getConfigParameter<std::string>("comparison_operator");
    if (comparison_operator_string != "greater" &&
        comparison_operator_string != "less")
    {
        OGS_FATAL(
            "The comparison operator is '{:s}', but has to be either "
            "'greater' or 'less'.",
            comparison_operator_string);
    }
    bool const less = comparison_operator_string == "less";
 
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<
        PrimaryVariableConstraintDirichletBoundaryCondition>(
        parameter, bc_mesh, dof_table_bulk, variable_id, component_id,
        threshold_parameter, less);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createPythonBoundaryCondition()

std::unique_ptr< PythonBoundaryCondition > ProcessLib::createPythonBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	boundary_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t	bulk_mesh_id,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim
	)

Creates a new PythonBoundaryCondition object.

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__bc_object

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__flush_stdout

Definition at line 168 of file PythonBoundaryCondition.cpp.

{
    config.checkConfigParameter("type", "Python");
 
    auto const bc_object = config.getConfigParameter<std::string>("bc_object");
    auto const flush_stdout = config.getConfigParameter("flush_stdout", false);
 
    // Evaluate Python code in scope of main module
    pybind11::object scope =
        pybind11::module::import("__main__").attr("__dict__");
 
    if (!scope.contains(bc_object))
    {
        OGS_FATAL(
            "Function `{:s}' is not defined in the python script file, or "
            "there was no python script file specified.",
            bc_object);
    }
 
    auto* bc = scope[bc_object.c_str()]
                   .cast<PythonBoundaryConditionPythonSideInterface*>();
 
    if (variable_id >= static_cast<int>(dof_table.getNumberOfVariables()) ||
        component_id >= dof_table.getNumberOfVariableComponents(variable_id))
    {
        OGS_FATAL(
            "Variable id or component id too high. Actual values: ({:d}, "
            "{:d}), maximum values: ({:d}, {:d}).",
            variable_id, component_id, dof_table.getNumberOfVariables(),
            dof_table.getNumberOfVariableComponents(variable_id));
    }
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (boundary_mesh.getDimension() == 0 &&
        boundary_mesh.getNumberOfNodes() == 0 &&
        boundary_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<PythonBoundaryCondition>(
        PythonBoundaryConditionData{
            bc, dof_table, bulk_mesh_id,
            dof_table.getGlobalComponent(variable_id, component_id),
            boundary_mesh},
        integration_order, shapefunction_order, global_dim, flush_stdout);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), NumLib::LocalToGlobalIndexMap::getGlobalComponent(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createPythonSourceTerm()

std::unique_ptr< SourceTerm > ProcessLib::createPythonSourceTerm	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	source_term_mesh,
		std::unique_ptr< NumLib::LocalToGlobalIndexMap >	dof_table,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim
	)

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__Python__source_term_object

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__Python__flush_stdout

Definition at line 23 of file CreatePythonSourceTerm.cpp.

{
    DBUG("Constructing PythonSourceTerm from config.");
    config.checkConfigParameter("type", "Python");
 
    auto const source_term_object =
        config.getConfigParameter<std::string>("source_term_object");
    auto const flush_stdout = config.getConfigParameter("flush_stdout", false);
 
    // Evaluate Python code in scope of main module
    pybind11::object scope =
        pybind11::module::import("__main__").attr("__dict__");
 
    if (!scope.contains(source_term_object))
    {
        OGS_FATAL(
            "Function `{:s}' is not defined in the python script file, or "
            "there was no python script file specified.",
            source_term_object);
    }
 
    auto* source_term = scope[source_term_object.c_str()]
                            .cast<ProcessLib::SourceTerms::Python::
                                      PythonSourceTermPythonSideInterface*>();
 
    // In case of partitioned mesh the source_term could be empty, i.e. there is
    // no source_term condition.
#ifdef USE_PETSC
    // This can be extracted to createSourceTerm() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createSourceTerm().
    if (source_term_mesh.getDimension() == 0 &&
        source_term_mesh.getNumberOfNodes() == 0 &&
        source_term_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    auto const global_component_id =
        dof_table->getGlobalComponent(variable_id, component_id);
    return std::make_unique<ProcessLib::SourceTerms::Python::PythonSourceTerm>(
        std::move(dof_table),
        ProcessLib::SourceTerms::Python::PythonSourceTermData{
            source_term, global_component_id, source_term_mesh,
            source_term_mesh.getID()},
        integration_order, shapefunction_order, global_dim, flush_stdout);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getID(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), and OGS_FATAL.

Referenced by createSourceTerm().

createRobinBoundaryCondition()

std::unique_ptr< RobinBoundaryCondition > ProcessLib::createRobinBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Creates a new uniform Robin boundary condition from the given data.

The Robin boundary condition is given in the form \( \alpha \cdot [ u_0 - u(x) ] \), where the coefficients \( \alpha \) and \( u_0 \) are obtained from the config, and \( u \) is the unknown to which the boundary condition is applied.

The value \( \alpha \cdot [ u_0 - u(x) ] \) is a flux. It replaces the integrand in the boundary integral for the variable \( u \).

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Robin__alpha

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Robin__u_0

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__Robin__area_parameter

Definition at line 17 of file RobinBoundaryCondition.cpp.

{
    DBUG("Constructing RobinBcConfig from config.");
    config.checkConfigParameter("type", "Robin");
 
    if (bc_mesh.getDimension() >= global_dim)
    {
        OGS_FATAL(
            "The dimension ({:d}) of the given boundary mesh '{:s}' is not "
            "lower than the bulk dimension ({:d}).",
            bc_mesh.getDimension(), bc_mesh.getName(), global_dim);
    }
 
    auto const alpha_name = config.getConfigParameter<std::string>("alpha");
    auto const u_0_name = config.getConfigParameter<std::string>("u_0");
 
    auto const& alpha = ParameterLib::findParameter<double>(
        alpha_name, parameters, 1, &bc_mesh);
    auto const& u_0 =
        ParameterLib::findParameter<double>(u_0_name, parameters, 1, &bc_mesh);
 
    ParameterLib::Parameter<double> const* integral_measure(nullptr);
    if (global_dim - bc_mesh.getDimension() != 1)
    {
        auto const area_parameter_name =
            config.getConfigParameter<std::string>("area_parameter");
        DBUG("area parameter name '{:s}'", area_parameter_name);
        integral_measure = &ParameterLib::findParameter<double>(
            area_parameter_name, parameters, 1, &bc_mesh);
    }
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<RobinBoundaryCondition>(
        integration_order, shapefunction_order, dof_table, variable_id,
        component_id, global_dim, bc_mesh,
        RobinBoundaryConditionData{alpha, u_0, integral_measure});
}

References MaterialPropertyLib::alpha, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createSecondaryVariables()

void ProcessLib::createSecondaryVariables	(	BaseLib::ConfigTree const &	config,
		SecondaryVariableCollection &	secondary_variables
	)

Input File Parameter:

prj__processes__process__secondary_variables

Input File Parameter:

prj__processes__process__secondary_variables__secondary_variable

Input File Parameter:

prj__processes__process__secondary_variables__secondary_variable__type

Input File Parameter:

prj__processes__process__secondary_variables__secondary_variable__internal_name

Input File Parameter:

prj__processes__process__secondary_variables__secondary_variable__output_name

Definition at line 18 of file CreateSecondaryVariables.cpp.

{
    auto sec_vars_config =
        config.getConfigSubtreeOptional("secondary_variables");
    if (!sec_vars_config)
    {
        return;
    }
 
    for (
        auto sec_var_config :
        sec_vars_config->getConfigSubtreeList("secondary_variable"))
    {
        auto const type =
            sec_var_config.getConfigAttributeOptional<std::string>("type");
        if (type)
        {
            WARN(
                "Secondary variable type specification is deprecated and is "
                "ignored. All secondary variable types are 'static'.");
        }
 
        auto const internal_name =
            sec_var_config.getConfigAttribute<std::string>("internal_name");
        auto const output_name =
            sec_var_config.getConfigAttribute<std::string>("output_name");
 
        secondary_variables.addNameMapping(internal_name, output_name);
    }
}

References ProcessLib::SecondaryVariableCollection::addNameMapping(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and WARN().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), ProcessLib::PhaseField::createPhaseFieldProcess(), ProcessLib::RichardsComponentTransport::createRichardsComponentTransportProcess(), ProcessLib::RichardsFlow::createRichardsFlowProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(), ProcessLib::StokesFlow::createStokesFlowProcess(), ProcessLib::TES::createTESProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowWithPrhoProcess().

createSolutionDependentDirichletBoundaryCondition()

std::unique_ptr< SolutionDependentDirichletBoundaryCondition > ProcessLib::createSolutionDependentDirichletBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__SolutionDependentDirichlet__property_name

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__SolutionDependentDirichlet__initial_value_parameter

Definition at line 100 of file SolutionDependentDirichletBoundaryCondition.cpp.

{
    DBUG(
        "Constructing SolutionDependentDirichletBoundaryCondition from "
        "config.");
    config.checkConfigParameter("type", "SolutionDependentDirichlet");
 
    auto property_name =
        config.getConfigParameter<std::string>("property_name");
 
    auto& initial_value_parameter = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("initial_value_parameter"),
        parameters, 1, &bc_mesh);
 
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<SolutionDependentDirichletBoundaryCondition>(
        std::move(property_name), initial_value_parameter, bc_mesh,
        dof_table_bulk, variable_id, component_id);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getNumberOfElements(), and MeshLib::Mesh::getNumberOfNodes().

Referenced by createBoundaryCondition().

createSourceTerm()

std::unique_ptr< SourceTerm > ProcessLib::createSourceTerm	(	const SourceTermConfig &	config,
		const NumLib::LocalToGlobalIndexMap &	dof_table_bulk,
		const MeshLib::Mesh &	source_term_mesh,
		const int	variable_id,
		const unsigned	integration_order,
		const unsigned	shapefunction_order,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Definition at line 23 of file CreateSourceTerm.cpp.

{
    auto const type = config.config.peekConfigParameter<std::string>("type");
 
    // check basic data consistency
    if (variable_id >=
            static_cast<int>(dof_table_bulk.getNumberOfVariables()) ||
        *config.component_id >=
            dof_table_bulk.getNumberOfVariableComponents(variable_id))
    {
        OGS_FATAL(
            "Variable id or component id too high. Actual values: ({:d}, "
            "{:d}), maximum values: ({:d}, {:d}).",
            variable_id, *config.component_id,
            dof_table_bulk.getNumberOfVariables(),
            dof_table_bulk.getNumberOfVariableComponents(variable_id));
    }
 
    if (!source_term_mesh.getProperties()
             .template existsPropertyVector<std::size_t>("bulk_node_ids"))
    {
        OGS_FATAL(
            "The required bulk node ids map does not exist in the source term "
            "mesh '{:s}'.",
            source_term_mesh.getName());
    }
    std::vector<MeshLib::Node*> const& source_term_nodes =
        source_term_mesh.getNodes();
    DBUG(
        "Found {:d} nodes for source term at mesh '{:s}' for the variable {:d} "
        "and component {:d}",
        source_term_nodes.size(), source_term_mesh.getName(), variable_id,
        *config.component_id);
 
    MeshLib::MeshSubset source_term_mesh_subset(source_term_mesh,
                                                source_term_nodes);
 
    if (type == "Nodal")
    {
        std::unique_ptr<NumLib::LocalToGlobalIndexMap> dof_table_source_term(
            dof_table_bulk.deriveBoundaryConstrainedMap(
                variable_id, {*config.component_id},
                std::move(source_term_mesh_subset)));
        return ProcessLib::createNodalSourceTerm(
            config.config, config.mesh, std::move(dof_table_source_term),
            source_term_mesh.getID(), variable_id, *config.component_id,
            parameters);
    }
 
    if (type == "Line" || type == "Volumetric")
    {
        std::unique_ptr<NumLib::LocalToGlobalIndexMap> dof_table_source_term(
            dof_table_bulk.deriveBoundaryConstrainedMap(
                variable_id, {*config.component_id},
                std::move(source_term_mesh_subset)));
        auto const& bulk_mesh_dimension =
            dof_table_bulk.getMeshSubset(variable_id, *config.component_id)
                .getMesh()
                .getDimension();
        return ProcessLib::createVolumetricSourceTerm(
            config.config, bulk_mesh_dimension, config.mesh,
            std::move(dof_table_source_term), parameters, integration_order,
            shapefunction_order);
    }
 
    if (type == "Python")
    {
#ifdef OGS_USE_PYTHON
        std::unique_ptr<NumLib::LocalToGlobalIndexMap> dof_table_source_term(
            dof_table_bulk.deriveBoundaryConstrainedMap(
                std::move(source_term_mesh_subset)));
 
        return ProcessLib::createPythonSourceTerm(
            config.config, config.mesh, std::move(dof_table_source_term),
            variable_id, *config.component_id, integration_order,
            shapefunction_order, source_term_mesh.getDimension());
#else
        OGS_FATAL("OpenGeoSys has not been built with Python support.");
#endif
    }
 
    OGS_FATAL("Unknown source term type: `{:s}'.", type);
}

References ProcessLib::SourceTermConfig::component_id, ProcessLib::SourceTermConfig::config, createNodalSourceTerm(), createPythonSourceTerm(), createVolumetricSourceTerm(), DBUG(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getID(), MeshLib::MeshSubset::getMesh(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), MeshLib::Mesh::getProperties(), ProcessLib::SourceTermConfig::mesh, OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::ProcessVariable::createSourceTerms().

createTimeLoop()

std::unique_ptr< TimeLoop > ProcessLib::createTimeLoop	(	BaseLib::ConfigTree const &	config,
		std::string const &	output_directory,
		const std::vector< std::unique_ptr< Process >> &	processes,
		const std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase >> &	nonlinear_solvers,
		std::vector< std::unique_ptr< MeshLib::Mesh >> const &	meshes
	)

Builds a TimeLoop from the given configuration.

Input File Parameter:

prj__time_loop__global_process_coupling

Input File Parameter:

prj__time_loop__global_process_coupling__max_iter

Input File Parameter:

prj__time_loop__global_process_coupling__convergence_criteria

Input File Parameter:

prj__time_loop__global_process_coupling__convergence_criteria__convergence_criterion

Input File Parameter:

prj__time_loop__output

Input File Parameter:

prj__time_loop__processes

Definition at line 21 of file CreateTimeLoop.cpp.

{
    auto const& coupling_config
        = config.getConfigSubtreeOptional("global_process_coupling");
 
    std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
        global_coupling_conv_criteria;
    int max_coupling_iterations = 1;
    if (coupling_config)
    {
        max_coupling_iterations
            = coupling_config->getConfigParameter<int>("max_iter");
 
        auto const& coupling_convergence_criteria_config =
            coupling_config->getConfigSubtree("convergence_criteria");
 
        for (
            auto coupling_convergence_criterion_config :
            coupling_convergence_criteria_config.getConfigSubtreeList(
                "convergence_criterion"))
        {
            global_coupling_conv_criteria.push_back(
                NumLib::createConvergenceCriterion(
                    coupling_convergence_criterion_config));
        }
    }
 
    auto output =
        createOutput(config.getConfigSubtree("output"), output_directory,
                     meshes);
 
    auto per_process_data = createPerProcessData(
        config.getConfigSubtree("processes"), processes, nonlinear_solvers);
 
    if (coupling_config)
    {
        if (global_coupling_conv_criteria.size() != per_process_data.size())
        {
            OGS_FATAL(
                "The number of convergence criteria of the global staggered "
                "coupling loop is not identical to the number of the "
                "processes! Please check the element by tag "
                "global_process_coupling in the project file.");
        }
    }
 
    const auto minmax_iter = std::minmax_element(
        per_process_data.begin(),
        per_process_data.end(),
        [](std::unique_ptr<ProcessData> const& a,
           std::unique_ptr<ProcessData> const& b)
        { return (a->timestepper->end() < b->timestepper->end()); });
    const double start_time =
        per_process_data[minmax_iter.first - per_process_data.begin()]
            ->timestepper->begin();
    const double end_time =
        per_process_data[minmax_iter.second - per_process_data.begin()]
            ->timestepper->end();
 
    return std::make_unique<TimeLoop>(
        std::move(output), std::move(per_process_data), max_coupling_iterations,
        std::move(global_coupling_conv_criteria), start_time, end_time);
}

References NumLib::createConvergenceCriterion(), createOutput(), createPerProcessData(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and OGS_FATAL.

Referenced by ProjectData::parseTimeLoop().

createVariableDependentNeumannBoundaryCondition()

std::unique_ptr< VariableDependentNeumannBoundaryCondition > ProcessLib::createVariableDependentNeumannBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__type

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__VariableDependentNeumann__constant_name

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__VariableDependentNeumann__coefficient_current_variable_name

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__VariableDependentNeumann__coefficient_other_variable_name

Input File Parameter:

prj__process_variables__process_variable__boundary_conditions__boundary_condition__VariableDependentNeumann__coefficient_mixed_variables_name

Definition at line 18 of file VariableDependentNeumannBoundaryCondition.cpp.

{
    DBUG("Constructing VariableDependentNeumann BC from config.");
    config.checkConfigParameter("type", "VariableDependentNeumann");
    if (dof_table.getNumberOfVariables() != 2)
    {
        OGS_FATAL(
            "VariableDependentNeumann BC only implemented for 2 variable "
            "processes.");
    }
    assert(variable_id == 0 || variable_id == 1);
 
    if (bc_mesh.getDimension() + 1 != global_dim)
    {
        OGS_FATAL(
            "The dimension ({:d}) of the given boundary mesh '{:s}' is not by "
            "one "
            "lower than the bulk dimension ({:d}).",
            bc_mesh.getDimension(), bc_mesh.getName(), global_dim);
    }
 
    auto const constant_name =
        config.getConfigParameter<std::string>("constant_name");
    auto const& constant = ParameterLib::findParameter<double>(
        constant_name, parameters, 1, &bc_mesh);
 
    auto const coefficient_current_variable_name =
        config.getConfigParameter<std::string>(
            "coefficient_current_variable_name");
    auto const& coefficient_current_variable =
        ParameterLib::findParameter<double>(coefficient_current_variable_name,
                                            parameters, 1, &bc_mesh);
 
    auto const coefficient_other_variable_name =
        config.getConfigParameter<std::string>(
            "coefficient_other_variable_name");
    auto const& coefficient_other_variable =
        ParameterLib::findParameter<double>(coefficient_other_variable_name,
                                            parameters, 1, &bc_mesh);
 
    auto const coefficient_mixed_variables_name =
        config.getConfigParameter<std::string>(
            "coefficient_mixed_variables_name");
    auto const& coefficient_mixed_variables =
        ParameterLib::findParameter<double>(coefficient_mixed_variables_name,
                                            parameters, 1, &bc_mesh);
 
    std::vector<MeshLib::Node*> const& bc_nodes = bc_mesh.getNodes();
    MeshLib::MeshSubset bc_mesh_subset(bc_mesh, bc_nodes);
    auto const& dof_table_boundary_other_variable =
        *dof_table.deriveBoundaryConstrainedMap(
            (variable_id + 1) % 2, {component_id}, std::move(bc_mesh_subset));
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // This can be extracted to createBoundaryCondition() but then the config
    // parameters are not read and will cause an error.
    // TODO (naumov): Add a function to ConfigTree for skipping the tags of the
    // subtree and move the code up in createBoundaryCondition().
    if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
        bc_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
#endif  // USE_PETSC
 
    return std::make_unique<VariableDependentNeumannBoundaryCondition>(
        integration_order, shapefunction_order, dof_table, variable_id,
        component_id, global_dim, bc_mesh,
        VariableDependentNeumannBoundaryConditionData{
            constant, coefficient_current_variable, coefficient_other_variable,
            coefficient_mixed_variables, dof_table_boundary_other_variable});
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), and OGS_FATAL.

Referenced by createBoundaryCondition().

createVolumetricSourceTerm()

std::unique_ptr< SourceTerm > ProcessLib::createVolumetricSourceTerm	(	BaseLib::ConfigTree const &	config,
		unsigned const	bulk_mesh_dimension,
		MeshLib::Mesh const &	source_term_mesh,
		std::unique_ptr< NumLib::LocalToGlobalIndexMap >	source_term_dof_table,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	integration_order,
		unsigned const	shapefunction_order
	)

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__Volumetric__parameter

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__Line__parameter

Definition at line 22 of file CreateVolumetricSourceTerm.cpp.

{
    auto const type = config.peekConfigParameter<std::string>("type");
    if (type == "Line")
    {
        config.checkConfigParameter("type", "Line");
        DBUG("Constructing LineSourceTerm from config.");
    }
    else
    {
        config.checkConfigParameter("type", "Volumetric");
        DBUG("Constructing VolumetricSourceTerm from config.");
    }
 
    // source term field name
    auto const& volumetric_source_term_parameter_name =
        config.getConfigParameter<std::string>("parameter");
    auto& volumetric_source_term = ParameterLib::findParameter<double>(
        volumetric_source_term_parameter_name, parameters, 1,
        &source_term_mesh);
 
    // instruction to create documentation for the parameter
 
    DBUG("Using '{:s}' as volumetric source term parameter.",
         volumetric_source_term.name);
 
    return std::make_unique<VolumetricSourceTerm>(
        bulk_mesh_dimension, source_term_mesh, std::move(source_term_dof_table),
        integration_order, shapefunction_order, volumetric_source_term);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by createSourceTerm().

extractInnerAndOuterNodes()

template<typename IsActive >

static std::pair<std::vector<MeshLib::Node*>, std::vector<MeshLib::Node*> > ProcessLib::extractInnerAndOuterNodes ( MeshLib::Mesh const &  mesh, MeshLib::Mesh const &  sub_mesh, IsActive  is_active  )

static

Definition at line 27 of file CreateDeactivatedSubdomain.cpp.

{
    auto* const bulk_node_ids =
        sub_mesh.getProperties().template getPropertyVector<std::size_t>(
            "bulk_node_ids", MeshLib::MeshItemType::Node, 1);
    if (bulk_node_ids == nullptr)
    {
        OGS_FATAL(
            "Bulk node ids map is not available in the deactivate subdomain "
            "mesh.");
    }
 
    std::vector<MeshLib::Node*> inner_nodes;
    // Reserve for more than needed, but not much, because almost all nodes will
    // be the inner nodes.
    inner_nodes.reserve(sub_mesh.getNumberOfNodes());
 
    std::vector<MeshLib::Node*> outer_nodes;
 
    std::partition_copy(
        begin(sub_mesh.getNodes()), end(sub_mesh.getNodes()),
        back_inserter(inner_nodes), back_inserter(outer_nodes),
        [&](MeshLib::Node* const n)
        {
            auto const bulk_node = mesh.getNode((*bulk_node_ids)[n->getID()]);
            const auto& connected_elements =
                mesh.getElementsConnectedToNode(*bulk_node);
            // elements. Then it is an inner node, and outer otherwise.
            return std::all_of(begin(connected_elements),
                               end(connected_elements), is_active);
        });
 
    return {std::move(inner_nodes), std::move(outer_nodes)};
}

References MeshLib::Mesh::getElementsConnectedToNode(), MathLib::Point3dWithID::getID(), MeshLib::Mesh::getNode(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::Node, and OGS_FATAL.

Referenced by createDeactivatedSubdomainMesh().

findProcessVariable()

ProcessVariable& ProcessLib::findProcessVariable	(	std::vector< ProcessVariable > const &	variables,
		BaseLib::ConfigTree const &	pv_config,
		std::string const &	tag
	)

Input File Parameter:

special OGS input file parameter

Definition at line 45 of file ProcessUtils.cpp.

{
    // Find process variable name in process config.
    std::string const name = pv_config.getConfigParameter<std::string>(tag);
    return findVariableByName(variables, name, tag);
}

References anonymous_namespace{ProcessUtils.cpp}::findVariableByName(), BaseLib::ConfigTree::getConfigParameter(), and MaterialPropertyLib::name.

findProcessVariables() [1/2]

std::vector< std::reference_wrapper< ProcessVariable > > ProcessLib::findProcessVariables	(	std::vector< ProcessVariable > const &	variables,
		BaseLib::ConfigTree const &	pv_config,
		std::initializer_list< std::string >	tags
	)

Find process variables in variables whose names match the settings under the given tag_names in the process_config.

In the process config a process variable is referenced by a name. For example it will be looking for a variable named "H" in the list of process variables when the tag is "hydraulic_head":

<process>
    ...
    <process_variables>
        <hydraulic_head>H</hydraulic_head>
        ...
    </process_variables>
    ...
</process>

Returns

a vector of references to the found variable(s).

Definition at line 55 of file ProcessUtils.cpp.

{
    std::vector<std::reference_wrapper<ProcessVariable>> vars;
    vars.reserve(variables.size());
 
    if (variables.size() > tags.size())
        DBUG("Found multiple process variables with a same tag.");
 
    for (auto& tag : tags)
    {
        auto vars_per_tag = findProcessVariables(variables, pv_config, tag);
        vars.insert(vars.end(), vars_per_tag.begin(), vars_per_tag.end());
    }
 
    return vars;
}

References DBUG().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), ProcessLib::PhaseField::createPhaseFieldProcess(), ProcessLib::RichardsComponentTransport::createRichardsComponentTransportProcess(), ProcessLib::RichardsFlow::createRichardsFlowProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(), ProcessLib::StokesFlow::createStokesFlowProcess(), ProcessLib::TES::createTESProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowWithPrhoProcess().

findProcessVariables() [2/2]

std::vector< std::reference_wrapper< ProcessVariable > > ProcessLib::findProcessVariables	(	std::vector< ProcessVariable > const &	variables,
		BaseLib::ConfigTree const &	pv_config,
		std::string const &	tag
	)

Input File Parameter:

special OGS input file parameter

Definition at line 76 of file ProcessUtils.cpp.

{
    std::vector<std::reference_wrapper<ProcessVariable>> vars;
 
    auto var_names = pv_config.getConfigParameterList<std::string>(tag);
 
    if (var_names.empty())
    {
        OGS_FATAL("No entity is found with config tag <{:s}>.", tag);
    }
 
    std::vector<std::string> cached_var_names;
 
    for (std::string const& var_name : var_names)
    {
        vars.emplace_back(findVariableByName(variables, var_name, tag));
        cached_var_names.push_back(var_name);
    }
 
    // Eliminate duplicates in the set of variable names
    BaseLib::makeVectorUnique(cached_var_names);
 
    if (cached_var_names.size() != var_names.size())
    {
        OGS_FATAL("Found duplicates with config tag <{:s}>.", tag);
    }
 
    return vars;
}

References anonymous_namespace{ProcessUtils.cpp}::findVariableByName(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::makeVectorUnique(), and OGS_FATAL.

getCoupledLocalSolutions()

std::vector< double > ProcessLib::getCoupledLocalSolutions	(	std::vector< GlobalVector * > const &	global_solutions,
		std::vector< std::vector< GlobalIndexType >> const &	indices
	)

Fetch the nodal solutions of all coupled processes from the given vector of global solutions for each process into a flat vector.

Definition at line 32 of file CoupledSolutionsForStaggeredScheme.cpp.

{
    if (global_solutions.empty())
    {
        return {};
    }
 
    std::size_t const local_solutions_size =
        std::accumulate(cbegin(indices),
                        cend(indices),
                        std::size_t(0),
                        [](GlobalIndexType const size,
                           std::vector<GlobalIndexType> const& process_indices)
                        { return size + process_indices.size(); });
    std::vector<double> local_solutions;
    local_solutions.reserve(local_solutions_size);
 
    int number_of_processes = static_cast<int>(global_solutions.size());
    for (int process_id = 0; process_id < number_of_processes; ++process_id)
    {
        auto values = global_solutions[process_id]->get(indices[process_id]);
        local_solutions.insert(cend(local_solutions),
                               std::make_move_iterator(begin(values)),
                               std::make_move_iterator(end(values)));
    }
    return local_solutions;
}

Referenced by ProcessLib::VectorMatrixAssembler::assemble(), ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::computeCrackIntegral(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::computeEnergy(), ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), and ProcessLib::HT::StaggeredHTFEM< ShapeFunction, IntegrationMethod, GlobalDim >::getIntPtDarcyVelocity().

getEssentialBCValuesLocal()

void ProcessLib::getEssentialBCValuesLocal	(	ParameterLib::Parameter< double > const &	parameter,
		MeshLib::Mesh const &	bc_mesh,
		std::vector< MeshLib::Node * > const &	nodes_in_bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_boundary,
		int const	variable_id,
		int const	component_id,
		const double	t,
		GlobalVector const &	,
		NumLib::IndexValueVector< GlobalIndexType > &	bc_values
	)

Definition at line 58 of file DirichletBoundaryConditionAuxiliaryFunctions.cpp.

{
    ParameterLib::SpatialPosition pos;
 
    bc_values.ids.clear();
    bc_values.values.clear();
 
    // convert mesh node ids to global index for the given component
    bc_values.ids.reserve(nodes_in_bc_mesh.size());
    bc_values.values.reserve(nodes_in_bc_mesh.size());
    for (auto const* const node : nodes_in_bc_mesh)
    {
        auto const id = node->getID();
        // TODO: that might be slow, but only done once
        auto const global_index = dof_table_boundary.getGlobalIndex(
            {bc_mesh.getID(), MeshLib::MeshItemType::Node, id}, variable_id,
            component_id);
        if (global_index == NumLib::MeshComponentMap::nop)
        {
            continue;
        }
        // For the DDC approach (e.g. with PETSc option), the negative
        // index of global_index means that the entry by that index is a ghost
        // one, which should be dropped. Especially for PETSc routines
        // MatZeroRows and MatZeroRowsColumns, which are called to apply the
        // Dirichlet BC, the negative index is not accepted like other matrix or
        // vector PETSc routines. Therefore, the following if-condition is
        // applied.
        if (global_index >= 0)
        {
            pos.setNodeID(id);
            pos.setCoordinates(*node);
            bc_values.ids.emplace_back(global_index);
            bc_values.values.emplace_back(parameter(t, pos).front());
        }
    }
}

References NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), NumLib::IndexValueVector< IndexType >::ids, MeshLib::Node, NumLib::MeshComponentMap::nop, ParameterLib::SpatialPosition::setCoordinates(), ParameterLib::SpatialPosition::setNodeID(), and NumLib::IndexValueVector< IndexType >::values.

Referenced by ProcessLib::DeactivatedSubdomainDirichlet::getEssentialBCValues(), ProcessLib::DirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::DirichletBoundaryConditionWithinTimeInterval::getEssentialBCValues(), and ProcessLib::SolutionDependentDirichletBoundaryCondition::getEssentialBCValues().

getIntegrationPointDataMaterialStateVariables()

template<typename IntegrationPointData , typename MemberType , typename MaterialStateVariables >

std::vector<double> ProcessLib::getIntegrationPointDataMaterialStateVariables	(	std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &	ip_data_vector,
		MemberType	member,
		std::function< BaseLib::DynamicSpan< double >(MaterialStateVariables &)>	get_values_span,
		int const	n_components
	)

Definition at line 141 of file SetOrGetIntegrationPointData.h.

{
    std::vector<double> result;
    result.reserve(ip_data_vector.size() * n_components);
 
    for (auto& ip_data : ip_data_vector)
    {
        auto const values_span = get_values_span(*(ip_data.*member));
        assert(values_span.size == static_cast<std::size_t>(n_components));
 
        result.insert(end(result), values_span.data,
                      values_span.data + values_span.size);
    }
 
    return result;
}

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getMaterialStateVariableInternalState().

getIntegrationPointKelvinVectorData() [1/2]

template<int DisplacementDim, typename IntegrationPointData , typename MemberType >

std::vector<double> ProcessLib::getIntegrationPointKelvinVectorData	(	std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &	ip_data,
		MemberType	member
	)

Definition at line 51 of file SetOrGetIntegrationPointData.h.

{
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    auto const n_integration_points = ip_data.size();
 
    std::vector<double> ip_kelvin_vector_values;
    auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
        double, Eigen::Dynamic, kelvin_vector_size, Eigen::RowMajor>>(
        ip_kelvin_vector_values, n_integration_points, kelvin_vector_size);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        auto const& ip_member = ip_data[ip].*member;
        cache_mat.row(ip) =
            MathLib::KelvinVector::kelvinVectorToSymmetricTensor(ip_member);
    }
 
    return ip_kelvin_vector_values;
}

References MathLib::createZeroedMatrix(), MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::kelvinVectorToSymmetricTensor().

getIntegrationPointKelvinVectorData() [2/2]

template<int DisplacementDim, typename IntegrationPointData , typename MemberType >

std::vector<double> const& ProcessLib::getIntegrationPointKelvinVectorData	(	std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &	ip_data,
		MemberType	member,
		std::vector< double > &	cache
	)

Definition at line 25 of file SetOrGetIntegrationPointData.h.

{
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    auto const n_integration_points = ip_data.size();
 
    cache.clear();
    auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
        double, kelvin_vector_size, Eigen::Dynamic, Eigen::RowMajor>>(
        cache, kelvin_vector_size, n_integration_points);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        auto const& kelvin_vector = ip_data[ip].*member;
        cache_mat.col(ip) =
            MathLib::KelvinVector::kelvinVectorToSymmetricTensor(kelvin_vector);
    }
 
    return cache;
}

References MathLib::createZeroedMatrix(), MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::kelvinVectorToSymmetricTensor().

getIntegrationPointMetaData()

IntegrationPointMetaData ProcessLib::getIntegrationPointMetaData	(	MeshLib::Mesh const &	mesh,
		std::string const &	name
	)

Returns integration point meta data for the given field name.

The data is read from a JSON encoded string stored in field data array.

Definition at line 108 of file IntegrationPointWriter.cpp.

{
    if (!mesh.getProperties().existsPropertyVector<char>(
            "IntegrationPointMetaData"))
    {
        OGS_FATAL(
            "Integration point data '{:s}' is present in the vtk field data "
            "but the required 'IntegrationPointMetaData' array is not "
            "available.",
            name);
    }
    auto const& mesh_property_ip_meta_data =
        *mesh.getProperties().template getPropertyVector<char>(
            "IntegrationPointMetaData");
 
    if (mesh_property_ip_meta_data.getMeshItemType() !=
        MeshLib::MeshItemType::IntegrationPoint)
    {
        OGS_FATAL("IntegrationPointMetaData array must be field data.");
    }
 
    // Find the current integration point data entry and extract the
    // meta data.
    auto const ip_meta_data = extractIntegrationPointMetaData(
        json::parse(mesh_property_ip_meta_data.begin(),
                    mesh_property_ip_meta_data.end()),
        name);
 
    return ip_meta_data;
}

References MeshLib::Properties::existsPropertyVector(), extractIntegrationPointMetaData(), MeshLib::Mesh::getProperties(), MeshLib::IntegrationPoint, MaterialPropertyLib::name, and OGS_FATAL.

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess().

getIntegrationPointScalarData()

template<typename IntegrationPointData , typename MemberType >

std::vector<double> const& ProcessLib::getIntegrationPointScalarData	(	std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> const &	ip_data,
		MemberType	member,
		std::vector< double > &	cache
	)

Definition at line 103 of file SetOrGetIntegrationPointData.h.

{
    auto const n_integration_points = ip_data.size();
 
    cache.clear();
    auto cache_mat = MathLib::createZeroedMatrix<
        Eigen::Matrix<double, 1, Eigen::Dynamic, Eigen::RowMajor>>(
        cache, 1, n_integration_points);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        cache_mat[ip] = ip_data[ip].*member;
    }
 
    return cache;
}

References MathLib::createZeroedMatrix().

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtDamage(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtDryDensitySolid(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::getIntPtDryDensitySolid(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtDryDensitySolid(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtEnthalpyGas(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtEnthalpyLiquid(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtEnthalpySolid(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtGasDensity(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtLiquidDensity(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtMassFractionGas(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtMassFractionLiquid(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtMicroPressure(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtMicroSaturation(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtMoleFractionGas(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtPorosity(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::getIntPtPorosity(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtPorosity(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtPorosity(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtRelativePermeabilityGas(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtRelativePermeabilityLiquid(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtSaturation(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::getIntPtSaturation(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtSaturation(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtSaturation(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtSolidDensity(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtTransportPorosity(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtTransportPorosity(), and ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtVapourPressure().

makeExtrapolator()

template<typename LocalAssemblerCollection >

SecondaryVariableFunctions ProcessLib::makeExtrapolator	(	const unsigned	num_components,
		NumLib::Extrapolator &	extrapolator,
		LocalAssemblerCollection const &	local_assemblers,
		typename NumLib::ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection >::IntegrationPointValuesMethod	integration_point_values_method
	)

Creates an object that computes a secondary variable via extrapolation of integration point values.

Parameters

num_components	The number of components of the secondary variable.
extrapolator	The extrapolator used for extrapolation.
local_assemblers	The collection of local assemblers whose integration point values will be extrapolated.
integration_point_values_method	The member function of the local assembler returning/computing the integration point values of the specific property being extrapolated.

Definition at line 163 of file SecondaryVariable.h.

{
    auto const eval_field =
        [num_components, &extrapolator, &local_assemblers,
         integration_point_values_method](
            const double t,
            std::vector<GlobalVector*> const& x,
            std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
            std::unique_ptr<GlobalVector> & /*result_cache*/
            ) -> GlobalVector const& {
        auto const extrapolatables = NumLib::makeExtrapolatable(
            local_assemblers, integration_point_values_method);
        extrapolator.extrapolate(num_components, extrapolatables, t, x,
                                 dof_table);
        return extrapolator.getNodalValues();
    };
 
    auto const eval_residuals =
        [num_components, &extrapolator, &local_assemblers,
         integration_point_values_method](
            const double t,
            std::vector<GlobalVector*> const& x,
            std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
            std::unique_ptr<GlobalVector> & /*result_cache*/
            ) -> GlobalVector const& {
        auto const extrapolatables = NumLib::makeExtrapolatable(
            local_assemblers, integration_point_values_method);
        extrapolator.calculateResiduals(num_components, extrapolatables, t, x,
                                        dof_table);
        return extrapolator.getElementResiduals();
    };
    return {num_components, eval_field, eval_residuals};
}

References NumLib::Extrapolator::calculateResiduals(), NumLib::Extrapolator::extrapolate(), NumLib::Extrapolator::getElementResiduals(), NumLib::Extrapolator::getNodalValues(), and NumLib::makeExtrapolatable().

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

makeOutput()

void ProcessLib::makeOutput	(	std::string const &	file_name,
		MeshLib::Mesh const &	mesh,
		bool const	compress_output,
		int const	data_mode
	)

Definition at line 298 of file ProcessOutput.cpp.

{
    // Write output file
    DBUG("Writing output to '{:s}'.", file_name);
 
    // Store floating-point exception handling. Output of NaN's triggers
    // floating point exceptions. Because we are not debugging VTK (or other
    // libraries) at this point, the possibly set exceptions are temporary
    // disabled and restored before end of the function.
#ifndef _WIN32
#ifndef __APPLE__
    fenv_t fe_env;
    fegetenv(&fe_env);
    fesetenv(FE_DFL_ENV);  // Set default environment effectively disabling
                           // exceptions.
#endif                     //_WIN32
#endif                     //__APPLE__
 
    MeshLib::IO::VtuInterface vtu_interface(&mesh, data_mode, compress_output);
    vtu_interface.writeToFile(file_name);
 
    // Restore floating-point exception handling.
#ifndef _WIN32
#ifndef __APPLE__
    fesetenv(&fe_env);
#endif  //_WIN32
#endif  //__APPLE__
}

References DBUG(), and MeshLib::IO::VtuInterface::writeToFile().

Referenced by ProcessLib::Output::doOutputNonlinearIteration(), and ProcessLib::Output::outputMesh().

makeProcessData()

static std::unique_ptr<ProcessData> ProcessLib::makeProcessData ( std::unique_ptr< NumLib::TimeStepAlgorithm > &&  timestepper, NumLib::NonlinearSolverBase &  nonlinear_solver, int const  process_id, Process &  process, std::unique_ptr< NumLib::TimeDiscretization > &&  time_disc, std::unique_ptr< NumLib::ConvergenceCriterion > &&  conv_crit, bool const  compensate_non_equilibrium_initial_residuum  )

static

Definition at line 21 of file CreateProcessData.cpp.

{
    using Tag = NumLib::NonlinearSolverTag;
 
    if (auto* nonlinear_solver_picard =
            dynamic_cast<NumLib::NonlinearSolver<Tag::Picard>*>(
                &nonlinear_solver))
    {
        nonlinear_solver_picard->compensateNonEquilibriumInitialResiduum(
            compensate_non_equilibrium_initial_residuum);
        return std::make_unique<ProcessData>(
            std::move(timestepper), Tag::Picard, *nonlinear_solver_picard,
            std::move(conv_crit), std::move(time_disc), process_id, process);
    }
    if (auto* nonlinear_solver_newton =
            dynamic_cast<NumLib::NonlinearSolver<Tag::Newton>*>(
                &nonlinear_solver))
    {
        nonlinear_solver_newton->compensateNonEquilibriumInitialResiduum(
            compensate_non_equilibrium_initial_residuum);
        return std::make_unique<ProcessData>(
            std::move(timestepper), Tag::Newton, *nonlinear_solver_newton,
            std::move(conv_crit), std::move(time_disc), process_id, process);
    }
#ifdef USE_PETSC
    if (auto* nonlinear_solver_petsc =
            dynamic_cast<NumLib::PETScNonlinearSolver*>(&nonlinear_solver))
    {
        return std::make_unique<ProcessData>(
            std::move(timestepper), Tag::Newton, *nonlinear_solver_petsc,
            std::move(conv_crit), std::move(time_disc), process_id, process);
    }
#endif  // USE_PETSC
 
    OGS_FATAL("Encountered unknown nonlinear solver type. Aborting");
}

References OGS_FATAL.

Referenced by createPerProcessData().

parseLineSegment()

static std::pair<Eigen::Vector3d, Eigen::Vector3d> ProcessLib::parseLineSegment ( BaseLib::ConfigTree const &  config )

static

Returns a line segment represented by its begin and end points.

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__line_segment__start

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__line_segment__end

Definition at line 142 of file CreateDeactivatedSubdomain.cpp.

{
    DBUG("Constructing line segment");
    auto const start =
        config.getConfigParameter<std::vector<double>>("start");
    if (start.size() != 3)
    {
        OGS_FATAL(
            "For construction of a line segment the start point must be a 3D "
            "point. Got a vector of size {}.",
            start.size());
    }
 
    auto const end =
        config.getConfigParameter<std::vector<double>>("end");
 
    if (end.size() != 3)
    {
        OGS_FATAL(
            "For construction of a line segment the end point must be a 3D "
            "point. Got a vector of size {}.",
            end.size());
    }
    return {Eigen::Vector3d{start[0], start[1], start[2]},
            Eigen::Vector3d{end[0], end[1], end[2]}};
}

References DBUG(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createDeactivatedSubdomain().

parseTimeIntervalOrCurve()

static MathLib::PiecewiseLinearInterpolation ProcessLib::parseTimeIntervalOrCurve ( std::optional< BaseLib::ConfigTree > const &  time_interval_config, std::optional< std::string > const &  curve_name, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &  curves  )

static

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__time_interval__start

Input File Parameter:

prj__process_variables__process_variable__deactivated_subdomains__deactivated_subdomain__time_interval__end

Definition at line 89 of file CreateDeactivatedSubdomain.cpp.

{
    // Check for the error case first: only one of the configs must be used.
    if (time_interval_config && curve_name)
    {
        OGS_FATAL(
            "In the deactivate subdomain either a time interval or a curve "
            "must be given, not both.");
    }
 
    // Parse time interval and return a curve
    if (time_interval_config)
    {
        DBUG("Constructing time interval");
        auto const start_time =
            time_interval_config->getConfigParameter<double>("start");
 
        auto const end_time =
            time_interval_config->getConfigParameter<double>("end");
 
        // Using very large value for the curve's value, s.t. for any time from
        // start to end the whole subdomain is deactivated at once.
        return {{start_time, end_time},
                {std::numeric_limits<double>::max(),
                 std::numeric_limits<double>::max()},
                false};
    }
 
    // Try to find the curve.
    if (curve_name)
    {
        DBUG("Using curve '{:s}'", *curve_name);
        // Return a copy of the curve because the time interval in the other
        // branch returns a temporary.
        return *BaseLib::getOrError(curves, *curve_name,
                                    "Could not find curve.");
    }
 
    // If we got so far, there is an error: one of the configs must be
    // available.
    OGS_FATAL(
        "In the deactivate subdomain neither a time interval nor a curve are "
        "given. One of them must be specified.");
}

References DBUG(), BaseLib::getOrError(), and OGS_FATAL.

Referenced by createDeactivatedSubdomain().

postTimestepForAllProcesses()

void ProcessLib::postTimestepForAllProcesses	(	double const	t,
		double const	dt,
		std::vector< std::unique_ptr< ProcessData >> const &	per_process_data,
		std::vector< GlobalVector * > const &	process_solutions,
		std::vector< GlobalVector * > const &	process_solutions_prev,
		std::vector< std::size_t > &	xdot_vector_ids
	)

Definition at line 103 of file TimeLoop.cpp.

{
    std::vector<GlobalVector*> x_dots;
    x_dots.reserve(per_process_data.size());
    xdot_vector_ids.resize(per_process_data.size());
 
    std::size_t cnt = 0;
    for (auto& process_data : per_process_data)
    {
        auto const process_id = process_data->process_id;
        auto const& ode_sys = *process_data->tdisc_ode_sys;
        auto const& time_discretization = *process_data->time_disc;
 
        x_dots.emplace_back(&NumLib::GlobalVectorProvider::provider.getVector(
            ode_sys.getMatrixSpecifications(process_id), xdot_vector_ids[cnt]));
        cnt++;
 
        time_discretization.getXdot(*process_solutions[process_id],
                                    *process_solutions_prev[process_id],
                                    *x_dots[process_id]);
    }
 
    // All _per_process_data share the first process.
    bool const is_staggered_coupling =
        !isMonolithicProcess(*per_process_data[0]);
 
    for (auto& process_data : per_process_data)
    {
        auto const process_id = process_data->process_id;
        auto& pcs = process_data->process;
 
        if (is_staggered_coupling)
        {
            CoupledSolutionsForStaggeredScheme coupled_solutions(
                process_solutions);
            pcs.setCoupledSolutionsForStaggeredScheme(&coupled_solutions);
        }
        auto& x_dot = *x_dots[process_id];
        pcs.computeSecondaryVariable(t, dt, process_solutions, x_dot,
                                     process_id);
        pcs.postTimestep(process_solutions, t, dt, process_id);
    }
    for (auto& x_dot : x_dots)
    {
        NumLib::GlobalVectorProvider::provider.releaseVector(*x_dot);
    }
}

References anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess(), NumLib::GlobalVectorProvider::provider, and NumLib::VectorProvider::releaseVector().

Referenced by ProcessLib::TimeLoop::loop().

preTimestepForAllProcesses()

void ProcessLib::preTimestepForAllProcesses	(	double const	t,
		double const	dt,
		std::vector< std::unique_ptr< ProcessData >> const &	per_process_data,
		std::vector< GlobalVector * > const &	_process_solutions
	)

Definition at line 90 of file TimeLoop.cpp.

{
    for (auto& process_data : per_process_data)
    {
        auto const process_id = process_data->process_id;
        auto& pcs = process_data->process;
        pcs.preTimestep(_process_solutions, t, dt, process_id);
    }
}

Referenced by ProcessLib::TimeLoop::loop().

pythonBindBoundaryCondition()

OGS_EXPORT_SYMBOL void ProcessLib::pythonBindBoundaryCondition

(

pybind11::module &

m

)

Creates Python bindings for the Python BC class.

Definition at line 49 of file PythonBoundaryConditionModule.cpp.

{
    namespace py = pybind11;
 
    py::class_<PythonBoundaryConditionPythonSideInterface,
               PythonBoundaryConditionPythonSideInterfaceTrampoline>
        pybc(m, "BoundaryCondition");
 
    pybc.def(py::init());
 
    pybc.def("getDirichletBCValue",
             &PythonBoundaryConditionPythonSideInterface::getDirichletBCValue);
    pybc.def("getFlux", &PythonBoundaryConditionPythonSideInterface::getFlux);
}

References ProcessLib::PythonBoundaryConditionPythonSideInterface::getDirichletBCValue(), and ProcessLib::PythonBoundaryConditionPythonSideInterface::getFlux().

Referenced by PYBIND11_EMBEDDED_MODULE().

setInitialConditions()

std::pair<std::vector<GlobalVector*>, std::vector<GlobalVector*> > ProcessLib::setInitialConditions	(	double const	t0,
		std::vector< std::unique_ptr< ProcessData >> const &	per_process_data
	)

Definition at line 216 of file TimeLoop.cpp.

{
    std::vector<GlobalVector*> process_solutions;
    std::vector<GlobalVector*> process_solutions_prev;
 
    for (auto& process_data : per_process_data)
    {
        auto const process_id = process_data->process_id;
        auto& ode_sys = *process_data->tdisc_ode_sys;
 
        // append a solution vector of suitable size
        process_solutions.emplace_back(
            &NumLib::GlobalVectorProvider::provider.getVector(
                ode_sys.getMatrixSpecifications(process_id)));
        process_solutions_prev.emplace_back(
            &NumLib::GlobalVectorProvider::provider.getVector(
                ode_sys.getMatrixSpecifications(process_id)));
    }
 
    for (auto& process_data : per_process_data)
    {
        auto& pcs = process_data->process;
        auto const process_id = process_data->process_id;
        pcs.setInitialConditions(process_solutions, process_solutions_prev, t0,
                                 process_id);
 
        auto& time_disc = *process_data->time_disc;
        time_disc.setInitialState(t0);  // push IC
    }
 
    return {process_solutions, process_solutions_prev};
}

References NumLib::GlobalVectorProvider::provider.

Referenced by ProcessLib::TimeLoop::initialize(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::setInitialConditionsConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::setInitialConditionsConcreteProcess(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::setInitialConditionsConcreteProcess().

setIntegrationPointDataMaterialStateVariables()

template<typename IntegrationPointData , typename MemberType , typename MaterialStateVariables >

std::size_t ProcessLib::setIntegrationPointDataMaterialStateVariables	(	double const *	values,
		std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &	ip_data_vector,
		MemberType	member,
		std::function< BaseLib::DynamicSpan< double >(MaterialStateVariables &)>	get_values_span
	)

Definition at line 167 of file SetOrGetIntegrationPointData.h.

{
    auto const n_integration_points = ip_data_vector.size();
 
    std::size_t position = 0;
    for (auto& ip_data : ip_data_vector)
    {
        auto const values_span = get_values_span(*(ip_data.*member));
        std::copy_n(values + position, values_span.size, values_span.data);
        position += values_span.size;
    }
    return n_integration_points;
}

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions().

setIntegrationPointKelvinVectorData()

template<int DisplacementDim, typename IntegrationPointData , typename MemberType >

std::size_t ProcessLib::setIntegrationPointKelvinVectorData	(	double const *	values,
		std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &	ip_data,
		MemberType	member
	)

Definition at line 77 of file SetOrGetIntegrationPointData.h.

{
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    auto const n_integration_points = ip_data.size();
 
    auto kelvin_vector_values =
        Eigen::Map<Eigen::Matrix<double, kelvin_vector_size, Eigen::Dynamic,
                                 Eigen::ColMajor> const>(
            values, kelvin_vector_size, n_integration_points);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        ip_data[ip].*member =
            MathLib::KelvinVector::symmetricTensorToKelvinVector(
                kelvin_vector_values.col(ip));
    }
 
    return n_integration_points;
}

References MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

setIntegrationPointScalarData()

template<typename IntegrationPointData , typename MemberType >

std::size_t ProcessLib::setIntegrationPointScalarData	(	double const *	values,
		std::vector< IntegrationPointData, Eigen::aligned_allocator< IntegrationPointData >> &	ip_data,
		MemberType	member
	)

Definition at line 124 of file SetOrGetIntegrationPointData.h.

{
    auto const n_integration_points = ip_data.size();
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        ip_data[ip].*member = values[ip];
    }
    return n_integration_points;
}

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::setIPDataInitialConditions(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions().

setTimeDiscretizedODESystem() [1/2]

void ProcessLib::setTimeDiscretizedODESystem

(

ProcessData &

process_data

)

Definition at line 210 of file TimeLoop.cpp.

{
    setTimeDiscretizedODESystem(process_data, process_data.process);
}

References ProcessLib::ProcessData::process, and setTimeDiscretizedODESystem().

setTimeDiscretizedODESystem() [2/2]

template<NumLib::ODESystemTag ODETag>

void ProcessLib::setTimeDiscretizedODESystem	(	ProcessData &	process_data,
		NumLib::ODESystem< ODETag, NumLib::NonlinearSolverTag::Picard > &	ode_sys
	)

Definition at line 157 of file TimeLoop.cpp.

{
    using Tag = NumLib::NonlinearSolverTag;
    // A concrete Picard solver
    using NonlinearSolverPicard = NumLib::NonlinearSolver<Tag::Picard>;
    // A concrete Newton solver
    using NonlinearSolverNewton = NumLib::NonlinearSolver<Tag::Newton>;
 
    if (dynamic_cast<NonlinearSolverPicard*>(&process_data.nonlinear_solver))
    {
        // The Picard solver can also work with a Newton-ready ODE,
        // because the Newton ODESystem derives from the Picard ODESystem.
        // So no further checks are needed here.
 
        process_data.tdisc_ode_sys = std::make_unique<
            NumLib::TimeDiscretizedODESystem<ODETag, Tag::Picard>>(
            process_data.process_id, ode_sys, *process_data.time_disc);
    }
    // TODO (naumov) Provide a function to nonlinear_solver to distinguish the
    // types. Could be handy, because a nonlinear solver could handle both types
    // like PETScSNES.
    else if ((dynamic_cast<NonlinearSolverNewton*>(
                  &process_data.nonlinear_solver) != nullptr)
#ifdef USE_PETSC
             || (dynamic_cast<NumLib::PETScNonlinearSolver*>(
                     &process_data.nonlinear_solver) != nullptr)
#endif  // USE_PETSC
    )
    {
        // The Newton-Raphson method needs a Newton-ready ODE.
 
        using ODENewton = NumLib::ODESystem<ODETag, Tag::Newton>;
        if (auto* ode_newton = dynamic_cast<ODENewton*>(&ode_sys))
        {
            process_data.tdisc_ode_sys = std::make_unique<
                NumLib::TimeDiscretizedODESystem<ODETag, Tag::Newton>>(
                process_data.process_id, *ode_newton, *process_data.time_disc);
        }
        else
        {
            OGS_FATAL(
                "You are trying to solve a non-Newton-ready ODE with the"
                " Newton-Raphson method. Aborting");
        }
    }
    else
    {
        OGS_FATAL("Encountered unknown nonlinear solver type. Aborting");
    }
}

References ProcessLib::ProcessData::nonlinear_solver, OGS_FATAL, ProcessLib::ProcessData::process_id, ProcessLib::ProcessData::tdisc_ode_sys, and ProcessLib::ProcessData::time_disc.

Referenced by ProcessLib::TimeLoop::initialize(), and setTimeDiscretizedODESystem().

solveMonolithicProcess()

static NumLib::NonlinearSolverStatus ProcessLib::solveMonolithicProcess ( const double  t, const double  dt, const std::size_t  timestep_id, ProcessData const &  process_data, std::vector< GlobalVector * > &  x, std::vector< GlobalVector * > const &  x_prev, Output &  output, std::size_t &  xdot_id  )

static

Definition at line 685 of file TimeLoop.cpp.

{
    BaseLib::RunTime time_timestep_process;
    time_timestep_process.start();
 
    auto const nonlinear_solver_status = solveOneTimeStepOneProcess(
        x, x_prev, timestep_id, t, dt, process_data, output, xdot_id);
 
    INFO("[time] Solving process #{:d} took {:g} s in time step #{:d} ",
         process_data.process_id, time_timestep_process.elapsed(), timestep_id);
 
    return nonlinear_solver_status;
}

References BaseLib::RunTime::elapsed(), INFO(), ProcessLib::ProcessData::process_id, solveOneTimeStepOneProcess(), and BaseLib::RunTime::start().

Referenced by ProcessLib::TimeLoop::solveUncoupledEquationSystems().

solveOneTimeStepOneProcess()

NumLib::NonlinearSolverStatus ProcessLib::solveOneTimeStepOneProcess	(	std::vector< GlobalVector * > &	x,
		std::vector< GlobalVector * > const &	x_prev,
		std::size_t const	timestep,
		double const	t,
		double const	delta_t,
		ProcessData const &	process_data,
		Output &	output_control,
		std::size_t &	xdot_id
	)

Definition at line 279 of file TimeLoop.cpp.

{
    auto& process = process_data.process;
    int const process_id = process_data.process_id;
    auto& time_disc = *process_data.time_disc;
    auto& conv_crit = *process_data.conv_crit;
    auto& ode_sys = *process_data.tdisc_ode_sys;
    auto& nonlinear_solver = process_data.nonlinear_solver;
    auto const nl_tag = process_data.nonlinear_solver_tag;
 
    setEquationSystem(nonlinear_solver, ode_sys, conv_crit, nl_tag);
 
    // Note: Order matters!
    // First advance to the next timestep, then set known solutions at that
    // time, afterwards pass the right solution vector and time to the
    // preTimestep() hook.
 
    time_disc.nextTimestep(t, delta_t);
 
    auto const post_iteration_callback =
        [&](int iteration, std::vector<GlobalVector*> const& x)
    {
        output_control.doOutputNonlinearIteration(process, process_id, timestep,
                                                  t, iteration, x);
    };
 
    auto const nonlinear_solver_status =
        nonlinear_solver.solve(x, x_prev, post_iteration_callback, process_id);
 
    if (!nonlinear_solver_status.error_norms_met)
    {
        return nonlinear_solver_status;
    }
 
    GlobalVector& x_dot = NumLib::GlobalVectorProvider::provider.getVector(
        ode_sys.getMatrixSpecifications(process_id), xdot_id);
 
    time_disc.getXdot(*x[process_id], *x_prev[process_id], x_dot);
 
    process.postNonLinearSolver(*x[process_id], x_dot, t, delta_t, process_id);
    NumLib::GlobalVectorProvider::provider.releaseVector(x_dot);
 
    return nonlinear_solver_status;
}

References ProcessLib::ProcessData::conv_crit, ProcessLib::Output::doOutputNonlinearIteration(), NumLib::VectorProvider::getVector(), ProcessLib::ProcessData::nonlinear_solver, ProcessLib::ProcessData::nonlinear_solver_tag, ProcessLib::ProcessData::process, ProcessLib::ProcessData::process_id, NumLib::GlobalVectorProvider::provider, NumLib::VectorProvider::releaseVector(), anonymous_namespace{TimeLoop.cpp}::setEquationSystem(), ProcessLib::ProcessData::tdisc_ode_sys, and ProcessLib::ProcessData::time_disc.

Referenced by ProcessLib::TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(), and solveMonolithicProcess().

transposeInPlace()

template<int Components, typename StoreValuesFunction >

std::vector<double> ProcessLib::transposeInPlace

(

StoreValuesFunction const &

store_values_function

)

In-place transpose. A helper function for the integration point data getters. For time being Eigen's transposeInPlace doesn't work for non-square mapped matrices.

Definition at line 23 of file TransposeInPlace.h.

{
    std::vector<double> result;
    store_values_function(result);
    MathLib::toMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Components, Eigen::RowMajor>>(
        result, result.size() / Components, Components) =
        MathLib::toMatrix<
            Eigen::Matrix<double, Components, Eigen::Dynamic, Eigen::RowMajor>>(
            result, Components, result.size() / Components)
            .transpose()
            .eval();
 
    return result;
}

References MathLib::toMatrix().

Variable Documentation

timestepper_cannot_reduce_dt

constexpr std::string_view ProcessLib::timestepper_cannot_reduce_dt

staticconstexpr

Initial value:

=
    "Time stepper cannot reduce the time step size further."

Definition at line 703 of file TimeLoop.cpp.

Referenced by ProcessLib::TimeLoop::solveUncoupledEquationSystems().