ProcessLib Namespace Reference

Detailed Description

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
namespace	Assembly
namespace	BoundaryConditionAndSourceTerm
namespace	ComponentTransport
namespace	Deformation
namespace	detail
namespace	HeatConduction
namespace	HeatTransportBHE
namespace	HT
namespace	HydroMechanics
namespace	LargeDeformation
namespace	LIE
namespace	LinearBMatrix
namespace	LiquidFlow
namespace	NonLinearBMatrix
namespace	NormalTractionBoundaryCondition
namespace	PhaseField
namespace	Reflection
namespace	RichardsComponentTransport
namespace	RichardsFlow
namespace	RichardsMechanics
namespace	SmallDeformation
namespace	SmallDeformationNonlocal
namespace	SourceTerms
namespace	SteadyStateDiffusion
namespace	StokesFlow
namespace	TES
namespace	TH2M
namespace	ThermalTwoPhaseFlowWithPP
namespace	ThermoHydroMechanics
namespace	ThermoMechanicalPhaseField
namespace	ThermoMechanics
namespace	ThermoRichardsFlow
namespace	ThermoRichardsMechanics
namespace	TwoPhaseFlowWithPP
namespace	TwoPhaseFlowWithPrho

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

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	EnabledElementTraitsLagrange = decltype(BaseLib::TMP::filter< NumLib::AllElementTraitsLagrange >(detail::isElementEnabled))
template<typename LocalAssemblerInterface , template< typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>
using	LocalAssemblerFactory = LocalAssemblerFactoryForDimGreaterEqualN< 1, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs... >
	By default processes in OGS are defined in 1D, 2D and 3D.
template<typename LocalAssemblerInterface , template< typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>
using	LocalAssemblerFactorySD = LocalAssemblerFactoryForDimGreaterEqualN< 2, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs... >
	Mechanics processes in OGS are defined in 2D and 3D only.
template<typename LocalAssemblerInterface , template< typename, typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>
using	LocalAssemblerFactoryHM = LocalAssemblerFactoryTaylorHood< 1, 2, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs... >
	HM processes in OGS are defined for linear and higher order elements.
template<typename LocalAssemblerInterface , template< typename, typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>
using	LocalAssemblerFactoryStokes = LocalAssemblerFactoryTaylorHood< 2, 2, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs... >
	Stokes flow in OGS is defined for higher order elements only.
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::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &)
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::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process)
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< std::size_t > 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)
void	getEssentialBCValuesLocal (ParameterLib::Parameter< double > const &parameter, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_boundary, int const variable_id, int const component_id, const double t, GlobalVector const &x, 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.
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::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process)
std::unique_ptr< PythonBoundaryCondition >	createPythonBoundaryCondition (BaseLib::ConfigTree const &config, MeshLib::Mesh const &boundary_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, MeshLib::Mesh const &bulk_mesh, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, std::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process)
	Creates a new PythonBoundaryCondition object.
void	pythonBindBoundaryCondition (pybind11::module &m)
	Creates Python bindings for the Python BC class.
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< std::size_t >, std::vector< std::size_t > >	extractInnerAndOuterNodes (MeshLib::Mesh const &mesh, MeshLib::Mesh const &sub_mesh, IsActive is_active)
static std::vector< std::vector< std::size_t > >	extractElementsAlongOuterNodes (MeshLib::Mesh const &mesh, MeshLib::Mesh const &sub_mesh, std::vector< std::size_t > const &outer_nodes)
static DeactivatedSubdomainMesh	createDeactivatedSubdomainMesh (MeshLib::Mesh const &mesh, std::unordered_set< int > const &deactivated_subdomain_material_ids)
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.
DeactivatedSubdomain	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< DeactivatedSubdomain >	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 >	createForwardDifferencesJacobianAssembler (BaseLib::ConfigTree const &config)
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, bool const compensate_non_equilibrium_initial_residuum, std::vector< double > const &fixed_times_for_output, std::map< std::string, int > &local_coupling_processes)
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 > > &meshes, bool const compensate_non_equilibrium_initial_residuum)
	Builds a TimeLoop from the given configuration.
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.
void	addProcessDataToMesh (const double t, std::vector< GlobalVector * > const &xs, int const process_id, ProcessOutputData const &process_output_data, bool const output_secondary_variables, OutputDataSpecification const &process_output)
std::unique_ptr< OutputFormat >	createOutputFormat (std::string const &output_directory, OutputType const output_type, std::string prefix, std::string suffix, std::string const &data_mode, bool const compress_output, unsigned int const number_of_files, unsigned int const chunk_size_bytes)
Output	createOutput (OutputConfig &&oc, std::string const &output_directory, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)
std::vector< Output >	createOutput (const BaseLib::ConfigTree &config, std::string const &output_directory, std::vector< std::unique_ptr< MeshLib::Mesh > > &meshes)
std::vector< Output >	createOutputs (const BaseLib::ConfigTree &output_configs, std::string const &output_directory, std::vector< std::unique_ptr< MeshLib::Mesh > > &meshes)
OutputConfig	createOutputConfig (const BaseLib::ConfigTree &config, std::vector< std::unique_ptr< MeshLib::Mesh > > &meshes)
void	createSecondaryVariables (BaseLib::ConfigTree const &config, SecondaryVariableCollection &secondary_variables)
void	addBulkMeshPropertyToSubMesh (MeshLib::Mesh const &bulk_mesh, MeshLib::Mesh &sub_mesh, std::string const &property_name)
std::vector< double >	calculateUniqueFixedTimesForAllOutputs (std::vector< Output > const &outputs)
std::ostream &	operator<< (std::ostream &os, Output const &output)
std::ostream &	operator<< (std::ostream &os, PairRepeatEachSteps const &pair)
std::ostream &	operator<< (std::ostream &os, OutputDataSpecification const &o)
void	outputMeshVtk (std::string const &file_name, MeshLib::Mesh const &mesh, bool const compress_output, int const data_mode)
void	outputMeshVtk (OutputVTKFormat const &output_file, MeshLib::IO::PVDFile &pvd_file, MeshLib::Mesh const &mesh, double const t, int const timestep, int const iteration)
std::ostream &	operator<< (std::ostream &os, OutputFormat const &of)
ProcessOutputData	createProcessOutputData (Process const &process, std::size_t const n_processes, MeshLib::Mesh &output_mesh)
	Extracts data necessary for output from the given process.
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)
template<typename LocalAssemblerCollection , typename IPDataAccessor >
SecondaryVariableFunctions	makeExtrapolator2 (const unsigned num_components, NumLib::Extrapolator &extrapolator, LocalAssemblerCollection const &local_assemblers, IPDataAccessor &&accessor)
SubmeshResiduumOutputConfig	createSubmeshResiduumOutputConfig (BaseLib::ConfigTree const &config, std::string const &output_directory, std::vector< std::unique_ptr< MeshLib::Mesh > > &meshes)
void	setEquationSystem (ProcessData const &process_data)
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)
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 * > const &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, std::vector< Output > const &outputs)
bool	computationOfChangeNeeded (NumLib::TimeStepAlgorithm const &timestep_algorithm, double const time)
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, std::vector< Output > const &outputs)
GlobalVector	computeResiduum (double const dt, GlobalVector const &x, GlobalVector const &x_prev, GlobalMatrix const &M, GlobalMatrix const &K, GlobalVector const &b)
template<int GlobalDim, template< typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, ProviderOrOrder const &provider_or_order, ExtraCtorArgs &&... extra_ctor_args)
template<template< typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>
void	createLocalAssemblers (const unsigned dimension, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, ProviderOrOrder const &provider_or_order, ExtraCtorArgs &&... extra_ctor_args)
template<int GlobalDim, template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>
void	createLocalAssemblersHM (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, ProviderOrOrder const &provider_or_order, ExtraCtorArgs &&... extra_ctor_args)
template<int GlobalDim, template< typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>
void	createLocalAssemblersStokes (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, ProviderOrOrder const &provider_or_order, 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)
std::string	removeIPFieldDataNameSuffix (std::string const &name)
	Removes the suffix '_ip' from the passed field name.
template<typename LocalAssemblersVector >
void	setIPDataInitialConditions (std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &_integration_point_writer, MeshLib::Properties const &mesh_properties, LocalAssemblersVector &local_assemblers, bool const remove_name_suffix=false)
template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >
std::vector< double > const &	getIntegrationPointDimMatrixData (IntegrationPointDataVector const &ip_data_vector, MemberType IpData::*const member, std::vector< double > &cache)
template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >
std::vector< double > const &	getIntegrationPointDimMatrixData (IntegrationPointDataVector const &ip_data_vector, Accessor &&accessor, std::vector< double > &cache)
template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >
std::vector< double > const &	getIntegrationPointKelvinVectorData (IntegrationPointDataVector const &ip_data_vector, MemberType IpData::*const member, std::vector< double > &cache)
template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >
std::vector< double > const &	getIntegrationPointKelvinVectorData (IntegrationPointDataVector const &ip_data_vector, Accessor &&accessor, std::vector< double > &cache)
template<int DisplacementDim, typename IntegrationPointDataVector , typename MemberType >
std::vector< double >	getIntegrationPointKelvinVectorData (IntegrationPointDataVector const &ip_data_vector, MemberType member)
template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >
std::size_t	setIntegrationPointKelvinVectorData (double const *values, IntegrationPointDataVector &ip_data_vector, MemberType IpData::*const member)
template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >
std::size_t	setIntegrationPointKelvinVectorData (double const *values, IntegrationPointDataVector &ip_data_vector, Accessor &&accessor)
template<typename IntegrationPointDataVector , typename IpData , typename MemberType >
std::vector< double > const &	getIntegrationPointScalarData (IntegrationPointDataVector const &ip_data_vector, MemberType IpData::*const member, std::vector< double > &cache)
template<typename IntegrationPointDataVector , typename Accessor >
std::vector< double > const &	getIntegrationPointScalarData (IntegrationPointDataVector const &ip_data_vector, Accessor &&accessor, std::vector< double > &cache)
template<typename IntegrationPointDataVector , typename IpData , typename MemberType >
std::size_t	setIntegrationPointScalarData (double const *values, IntegrationPointDataVector &ip_data_vector, MemberType IpData::*const member)
template<typename IntegrationPointDataVector , typename Accessor >
std::size_t	setIntegrationPointScalarData (double const *values, IntegrationPointDataVector &ip_data_vector, Accessor &&accessor)
template<typename IntegrationPointDataVector , typename MemberType , typename MaterialStateVariables >
std::vector< double >	getIntegrationPointDataMaterialStateVariables (IntegrationPointDataVector const &ip_data_vector, MemberType member, std::function< std::span< double >(MaterialStateVariables &)> get_values_span, int const n_components)
template<typename IntegrationPointDataVector , typename MemberType , typename MaterialStateVariables >
std::size_t	setIntegrationPointDataMaterialStateVariables (double const *values, IntegrationPointDataVector &ip_data_vector, MemberType member, std::function< std::span< double >(MaterialStateVariables &)> get_values_span)
template<int Components, typename StoreValuesFunction >
std::vector< double >	transposeInPlace (StoreValuesFunction const &store_values_function)
template<int Components>
void	transposeInPlace (std::vector< double > &values)
void	transposeInPlace (std::vector< double > &values, unsigned const num_components)

Variables
static constexpr std::string_view	timestepper_cannot_reduce_dt

Typedef Documentation

EnabledElementTraitsLagrange

using ProcessLib::EnabledElementTraitsLagrange = typedef decltype(BaseLib::TMP::filter<NumLib::AllElementTraitsLagrange>( detail::isElementEnabled))

List of all element types for which the local assemblers of OGS processes will be compiled.

Definition at line 119 of file EnabledElements.h.

HCNonAdvectiveFreeComponentFlowBoundaryCondition

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

Definition at line 19 of file HCNonAdvectiveFreeComponentFlowBoundaryCondition.h.

LocalAssemblerFactory

template<typename LocalAssemblerInterface , template< typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>

using ProcessLib::LocalAssemblerFactory = typedef LocalAssemblerFactoryForDimGreaterEqualN<1, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs...>

By default processes in OGS are defined in 1D, 2D and 3D.

Definition at line 89 of file LocalAssemblerFactoryForDimGreaterEqualN.h.

LocalAssemblerFactoryHM

template<typename LocalAssemblerInterface , template< typename, typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>

using ProcessLib::LocalAssemblerFactoryHM = typedef LocalAssemblerFactoryTaylorHood<1 , 2 , LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs...>

HM processes in OGS are defined for linear and higher order elements.

Definition at line 169 of file LocalAssemblerFactoryTaylorHood.h.

LocalAssemblerFactorySD

template<typename LocalAssemblerInterface , template< typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>

using ProcessLib::LocalAssemblerFactorySD = typedef LocalAssemblerFactoryForDimGreaterEqualN<2, LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs...>

Mechanics processes in OGS are defined in 2D and 3D only.

Definition at line 104 of file LocalAssemblerFactoryForDimGreaterEqualN.h.

LocalAssemblerFactoryStokes

template<typename LocalAssemblerInterface , template< typename, typename, int > class LocalAssemblerImplementation, NumLib::IntegrationMethodProvider IntegrationMethodProvider, int GlobalDim, typename... ConstructorArgs>

using ProcessLib::LocalAssemblerFactoryStokes = typedef LocalAssemblerFactoryTaylorHood<2 , 2 , LocalAssemblerInterface, LocalAssemblerImplementation, IntegrationMethodProvider, GlobalDim, ConstructorArgs...>

Stokes flow in OGS is defined for higher order elements only.

Definition at line 187 of file LocalAssemblerFactoryTaylorHood.h.

LocalAssemblerTraits

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

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

Definition at line 185 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 class ProcessLib::OutputType : uint8_t

strong

Enumerator
vtk
xdmf

Definition at line 21 of file OutputConfig.h.

{
    vtk,
    xdmf
};

Function Documentation

addBulkMeshPropertyToSubMesh()

void ProcessLib::addBulkMeshPropertyToSubMesh	(	MeshLib::Mesh const &	bulk_mesh,
		MeshLib::Mesh &	sub_mesh,
		std::string const &	property_name
	)

Definition at line 30 of file Output.cpp.

{
    if (bulk_mesh == sub_mesh)
    {
        return;
    }
 
    if (!bulk_mesh.getProperties().existsPropertyVector<double>(
            std::string_view(property_name)))
    {
        return;
    }
    auto const& bulk_mesh_property =
        *bulk_mesh.getProperties().getPropertyVector<double>(
            std::string_view(property_name));
    auto const mesh_item_type = bulk_mesh_property.getMeshItemType();
 
    std::string_view mesh_item_type_string =
        [mesh_item_type, &property_name]() -> std::string_view
    {
        switch (mesh_item_type)
        {
            case MeshLib::MeshItemType::Node:
                return MeshLib::getBulkIDString(MeshLib::MeshItemType::Node);
                break;
            case MeshLib::MeshItemType::Cell:
                return MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell);
                break;
            case MeshLib::MeshItemType::Edge:
                WARN(
                    "Property '{}' is assigned to edges. But mappings from the "
                    "bulk edges to submesh edges isn't implemented. Mesh item "
                    "type 'Edge' is not supported, only 'Node' and 'Cell' are "
                    "implemented at the moment.",
                    property_name);
                return "";
                break;
            case MeshLib::MeshItemType::Face:
                WARN(
                    "Property '{}' is assigned to faces. But mappings from the "
                    "bulk faces to submesh faces isn't implemented. Mesh item "
                    "type 'Face' is not supported, only 'Node' and 'Cell' are "
                    "implemented at the moment.",
                    property_name);
                return "";
                break;
            case MeshLib::MeshItemType::IntegrationPoint:
                WARN(
                    "Property '{}' is assigned to integration points. But "
                    "mappings from the bulk integration points to submesh "
                    "integration points isn't implemented. Mesh item type "
                    "'IntegrationPoint' is not supported, only 'Node' and "
                    "'Cell' are implemented at the moment.",
                    property_name);
                return "";
                break;
            default:
                OGS_FATAL("Unknown mesh item type '{}'.",
                          static_cast<int>(mesh_item_type));
                return "";
        }
    }();
 
    if (mesh_item_type_string.empty())
    {
        return;
    }
    if (!sub_mesh.getProperties().existsPropertyVector<std::size_t>(
            mesh_item_type_string, mesh_item_type, 1))
    {
        WARN(
            "The property {} is required for output on the mesh {}, but it "
            "doesn't exist.",
            mesh_item_type_string, sub_mesh.getName());
        return;
    }
 
    auto const& bulk_ids =
        *sub_mesh.getProperties().getPropertyVector<std::size_t>(
            mesh_item_type_string);
 
    auto const number_of_components =
        bulk_mesh_property.getNumberOfGlobalComponents();
    auto& sub_mesh_property = *MeshLib::getOrCreateMeshProperty<double>(
        sub_mesh, property_name, mesh_item_type, number_of_components);
 
    for (std::size_t sub_mesh_node_id = 0;
         sub_mesh_node_id < bulk_ids.getNumberOfTuples();
         ++sub_mesh_node_id)
    {
        auto const& bulk_id = bulk_ids[sub_mesh_node_id];
        for (std::remove_cv_t<decltype(number_of_components)> c = 0;
             c < number_of_components;
             ++c)
        {
            sub_mesh_property.getComponent(sub_mesh_node_id, c) =
                bulk_mesh_property.getComponent(bulk_id, c);
        }
    }
}

References MeshLib::Cell, MeshLib::Edge, MeshLib::Properties::existsPropertyVector(), MeshLib::Face, MeshLib::getBulkIDString(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::Mesh::getName(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), MeshLib::IntegrationPoint, MeshLib::Node, OGS_FATAL, and WARN().

Referenced by ProcessLib::Output::prepareSubmesh().

addProcessDataToMesh()

void ProcessLib::addProcessDataToMesh	(	const double	t,
		std::vector< GlobalVector * > const &	xs,
		int const	process_id,
		ProcessOutputData const &	process_output_data,
		bool const	output_secondary_variables,
		OutputDataSpecification const &	process_output
	)

Adds output data to a mesh.

Note

The mesh is passed via process_output_data.

Definition at line 374 of file AddProcessDataToMesh.cpp.

{
    DBUG("Process output data.");
 
    auto const& pod = process_output_data;
    auto const& process_variables = pod.getProcessVariables(process_id);
    auto const& secondary_variables = pod.getSecondaryVariables();
    auto const* const integration_point_writers =
        pod.getIntegrationPointWriters();
    auto const& bulk_mesh_dof_table = pod.getBulkMeshDofTable(process_id);
    auto const& output_mesh_dof_table = pod.getOutputMeshDofTable(process_id);
    auto& output_mesh = pod.getOutputMesh();
 
    auto const& output_variables = process_output.output_variables;
 
    addOgsVersion(output_mesh);
 
    auto names_of_already_output_variables = addPrimaryVariablesToMesh(
        output_mesh, *xs[process_id], process_variables, output_variables,
        output_mesh_dof_table, bulk_mesh_dof_table);
 
    if (output_secondary_variables)
    {
        auto const& output_mesh_dof_tables =
            pod.getOutputMeshDofTablesOfAllProcesses();
 
        addSecondaryVariablesToMesh(secondary_variables,
                                    names_of_already_output_variables, t, xs,
                                    output_mesh, output_mesh_dof_tables,
                                    process_output.output_residuals);
    }
 
    if (integration_point_writers)
    {
        addIntegrationPointDataToMesh(output_mesh, *integration_point_writers);
    }
}

References addOgsVersion(), addPrimaryVariablesToMesh(), addSecondaryVariablesToMesh(), DBUG(), ProcessLib::ProcessOutputData::getProcessVariables(), ProcessLib::OutputDataSpecification::output_residuals, and ProcessLib::OutputDataSpecification::output_variables.

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

bheInflowpythonBindBoundaryCondition()

OGS_EXPORT_SYMBOL void ProcessLib::bheInflowpythonBindBoundaryCondition

(

pybind11::module &

m

)

Creates BHE Inflow Python bindings for the Python BC class.

Definition at line 76 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("serverCommunicationPreTimestep",
             &BHEInflowPythonBoundaryConditionPythonSideInterface::
                 serverCommunicationPreTimestep);
 
    pybc.def("serverCommunicationPostTimestep",
             &BHEInflowPythonBoundaryConditionPythonSideInterface::
                 serverCommunicationPostTimestep);
}

References ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::tespySolver().

Referenced by PYBIND11_EMBEDDED_MODULE(), and PYBIND11_MODULE().

calculateNonEquilibriumInitialResiduum()

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

Definition at line 204 of file TimeLoop.cpp.

{
    for (auto const& process_data : per_process_data)
    {
        auto& nonlinear_solver = process_data->nonlinear_solver;
 
        setEquationSystem(*process_data);
        nonlinear_solver.calculateNonEquilibriumInitialResiduum(
            process_solutions, process_solutions_prev,
            process_data->process_id);
    }
}

References setEquationSystem().

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

calculateUniqueFixedTimesForAllOutputs()

std::vector< double > ProcessLib::calculateUniqueFixedTimesForAllOutputs

(

std::vector< Output > const &

outputs

)

Definition at line 435 of file Output.cpp.

{
    std::vector<double> fixed_times;
    for (auto const& output : outputs)
    {
        auto const& output_fixed_times = output.getFixedOutputTimes();
        fixed_times.insert(fixed_times.end(), output_fixed_times.begin(),
                           output_fixed_times.end());
    }
    BaseLib::makeVectorUnique(fixed_times);
    return fixed_times;
}

References BaseLib::makeVectorUnique().

Referenced by ProcessLib::TimeLoop::calculateNextTimeStep(), createTimeLoop(), and ProcessLib::TimeLoop::initialize().

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 25 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().hasPropertyVector(
            std::string(MeshLib::getBulkIDString(MeshLib::MeshItemType::Node))))
    {
        OGS_FATAL(
            "The required bulk node ids map does not exist in the boundary "
            "mesh '{:s}'.",
            bc_mesh.getName());
    }
 
    if (!bc_mesh.getProperties().existsPropertyVector<std::size_t>(
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Node)))
    {
        OGS_FATAL(
            "The required bulk node ids map exists in the boundary mesh '{:s}' "
            "but has 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::getBulkIDString(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), MeshLib::Mesh::getProperties(), MeshLib::Properties::hasPropertyVector(), MeshLib::Node, and OGS_FATAL.

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

computationOfChangeNeeded()

bool ProcessLib::computationOfChangeNeeded	(	NumLib::TimeStepAlgorithm const &	timestep_algorithm,
		double const	time
	)

Definition at line 297 of file TimeLoop.cpp.

{
    // for the first time step we can't compute the changes to the previous
    // time step
    if (time == timestep_algorithm.begin())
    {
        return false;
    }
    return timestep_algorithm.isSolutionErrorComputationNeeded();
}

References NumLib::TimeStepAlgorithm::begin(), and NumLib::TimeStepAlgorithm::isSolutionErrorComputationNeeded().

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

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, GlobalDim >::HydroMechanicsLocalAssemblerFracture(), and ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerFracture().

computeResiduum()

GlobalVector ProcessLib::computeResiduum	(	double const	dt,
		GlobalVector const &	x,
		GlobalVector const &	x_prev,
		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;
    GlobalVector x_dot;
    copy(x, x_dot);                        // tmp = x
    axpy(x_dot, -1., x_prev);              // tmp = x - x_prev
    scale(x_dot, 1. / dt);                 // tmp = (x - x_prev)/dt
    matMult(M, x_dot, residuum);           // r = M*x_dot
    matMultAdd(K, x, residuum, residuum);  // r = M*x_dot + K*x
    axpy(residuum, -1., b);                // r = M*x_dot + K*x - b
    scale(residuum, -1.);                  // r = -r
    return residuum;
}

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

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 94 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,
		std::vector< std::reference_wrapper< ProcessVariable > > const &	all_process_variables_for_this_process,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &
	)

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 31 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 (bool const component_id_required = type != "NormalTraction";
        component_id_required && !config.component_id.has_value())
    {
        OGS_FATAL(
            "Specifying the component id (<component>) for a boundary "
            "condition of type {} is mandatory.",
            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")
    {
        return ProcessLib::createPythonBoundaryCondition(
            config.config, config.boundary_mesh, dof_table, bulk_mesh,
            variable_id, *config.component_id, integration_order,
            shapefunction_order, all_process_variables_for_this_process);
    }
 
    //
    // 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::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 171 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 411 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 224 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()

DeactivatedSubdomain 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 214 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 an empty optional line segment is
    // used *internally* because the whole selected material ids subdomain will
    // be deactivated.
    std::optional<std::pair<Eigen::Vector3d, Eigen::Vector3d>> line_segment;
    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>{}) |
        ranges::to<std::unordered_set>();
 
    if (deactivated_subdomain_material_ids.empty())
    {
        OGS_FATAL(
            "The material IDs of the deactivated subdomains are not given. The "
            "program terminates now.");
    }
 
    if (materialIDs(mesh) == nullptr)
    {
        OGS_FATAL(
            "The mesh doesn't contain materialIDs for subdomain deactivation. "
            "The program terminates now.");
    }
 
    auto deactivated_subdomain_mesh = createDeactivatedSubdomainMesh(
        mesh, deactivated_subdomain_material_ids);
 
    return {std::move(time_interval), line_segment,
            std::move(deactivated_subdomain_mesh), boundary_value_parameter};
}

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

Referenced by createDeactivatedSubdomains().

createDeactivatedSubdomainMesh()

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

static

Definition at line 92 of file CreateDeactivatedSubdomain.cpp.

{
    // An element is active if its material id matches one of the deactivated
    // subdomain material ids.
    auto is_active =
        [&deactivated_subdomain_material_ids,
         &material_ids = *materialIDs(mesh)](std::size_t element_id)
    {
        return deactivated_subdomain_material_ids.contains(
            material_ids[element_id]);
    };
 
    auto const& elements = mesh.getElements();
    std::vector<MeshLib::Element*> deactivated_elements;
    ranges::copy_if(elements, back_inserter(deactivated_elements), is_active,
                    [](auto const e) { return e->getID(); });
 
    auto bulk_element_ids = deactivated_elements | MeshLib::views::ids |
                            ranges::to<std::unordered_set>;
 
    static int mesh_number = 0;
    // Subdomain mesh consisting of deactivated elements.
    auto sub_mesh = MeshLib::createMeshFromElementSelection(
        "deactivate_subdomain_" + std::to_string(mesh_number++),
        MeshLib::cloneElements(deactivated_elements));
 
    auto [inner_nodes, outer_nodes] =
        extractInnerAndOuterNodes(mesh, *sub_mesh, is_active);
 
    auto outer_nodes_elements =
        extractElementsAlongOuterNodes(mesh, *sub_mesh, outer_nodes);
 
    return {std::move(*sub_mesh), std::move(bulk_element_ids),
            std::move(inner_nodes), std::move(outer_nodes),
            std::move(outer_nodes_elements)};
}

References MeshLib::cloneElements(), MeshLib::createMeshFromElementSelection(), extractElementsAlongOuterNodes(), extractInnerAndOuterNodes(), MeshLib::Mesh::getElements(), and MeshLib::views::ids.

Referenced by createDeactivatedSubdomain().

createDeactivatedSubdomains()

std::vector< DeactivatedSubdomain > 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 295 of file CreateDeactivatedSubdomain.cpp.

{
    std::vector<DeactivatedSubdomain> 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(std::begin(deactivated_subdomain_configs),
                       std::end(deactivated_subdomain_configs),
                       std::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 56 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().

createForwardDifferencesJacobianAssembler()

std::unique_ptr< AbstractJacobianAssembler > ProcessLib::createForwardDifferencesJacobianAssembler

(

BaseLib::ConfigTree const &

config

)

Input File Parameter:

prj__processes__process__jacobian_assembler__type

Input File Parameter:

prj__processes__process__jacobian_assembler__ForwardDifferences__relative_epsilons

Input File Parameter:

prj__processes__process__jacobian_assembler__ForwardDifferences__component_magnitudes

Definition at line 19 of file CreateForwardDifferencesJacobianAssembler.cpp.

{
    config.checkConfigParameter("type", "ForwardDifferences");
 
    // 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.has_value() != comp_mag.has_value())
    {
        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<ForwardDifferencesJacobianAssembler>(
        std::move(abs_eps));
}

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

Referenced by createJacobianAssembler().

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>(
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell),
            MeshLib::MeshItemType::Cell, 1);
    auto const bulk_face_ids =
        bc_mesh.getProperties().template getPropertyVector<std::size_t>(
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Face),
            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(), MeshLib::Face, MeshLib::getBulkIDString(), 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 22 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);
    }
    if (type == "ForwardDifferences")
    {
        return createForwardDifferencesJacobianAssembler(*config);
    }
 
    OGS_FATAL("Unknown Jacobian assembler type: `{:s}'.", type);
}

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

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

createLocalAssemblers() [1/2]

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

void ProcessLib::createLocalAssemblers	(	const unsigned	dimension,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > &	local_assemblers,
		ProviderOrOrder const &	provider_or_order,
		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 74 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    switch (dimension)
    {
        case 1:
            createLocalAssemblers<1, LocalAssemblerImplementation>(
                mesh_elements, dof_table, local_assemblers, provider_or_order,
                std::forward<ExtraCtorArgs>(extra_ctor_args)...);
            break;
        case 2:
            createLocalAssemblers<2, LocalAssemblerImplementation>(
                mesh_elements, dof_table, local_assemblers, provider_or_order,
                std::forward<ExtraCtorArgs>(extra_ctor_args)...);
            break;
        case 3:
            createLocalAssemblers<3, LocalAssemblerImplementation>(
                mesh_elements, dof_table, local_assemblers, provider_or_order,
                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, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>

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

Definition at line 27 of file CreateLocalAssemblers.h.

{
    static_assert(
        GlobalDim == 1 || GlobalDim == 2 || GlobalDim == 3,
        "Meshes with dimension greater than three are not supported.");
 
    DBUG("Create local assemblers.");
 
    auto const& integration_method_provider =
        getIntegrationMethodProvider(provider_or_order);
 
    using IntegrationMethodProvider =
        std::remove_cvref_t<decltype(integration_method_provider)>;
    using LocAsmFac = LocalAssemblerFactory<
        LocalAssemblerInterface, LocalAssemblerImplementation,
        IntegrationMethodProvider, GlobalDim, ExtraCtorArgs...>;
 
    LocAsmFac factory(dof_table, integration_method_provider);
    local_assemblers.resize(mesh_elements.size());
 
    DBUG("Calling local assembler builder for all mesh elements.");
    GlobalExecutor::transformDereferenced(
        factory, mesh_elements, local_assemblers,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

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

createLocalAssemblersHM()

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

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

Definition at line 85 of file CreateLocalAssemblersTaylorHood.h.

{
    detail::createLocalAssemblersTaylorHood<LocalAssemblerFactoryHM, GlobalDim,
                                            LocalAssemblerImplementation,
                                            LocalAssemblerInterface>(
        mesh_elements, dof_table, local_assemblers, provider_or_order,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

Referenced by ProcessLib::ThermoRichardsMechanics::createLocalAssemblers(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess().

createLocalAssemblersStokes()

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

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

Definition at line 106 of file CreateLocalAssemblersTaylorHood.h.

{
    detail::createLocalAssemblersTaylorHood<
        LocalAssemblerFactoryStokes, GlobalDim, LocalAssemblerImplementation,
        LocalAssemblerInterface>(
        mesh_elements, dof_table, local_assemblers, provider_or_order,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

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() [1/2]

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

Definition at line 102 of file CreateOutput.cpp.

{
    std::vector<Output> outputs;
    auto oc = createOutputConfig(config, meshes);
    outputs.push_back(createOutput(std::move(oc), output_directory, meshes));
    return outputs;
}

References createOutput(), and createOutputConfig().

createOutput() [2/2]

Output ProcessLib::createOutput	(	OutputConfig &&	oc,
		std::string const &	output_directory,
		std::vector< std::unique_ptr< MeshLib::Mesh > > const &	meshes
	)

Definition at line 85 of file CreateOutput.cpp.

{
    auto output_format = createOutputFormat(
        output_directory, oc.output_type, std::move(oc.prefix),
        std::move(oc.suffix), oc.data_mode, oc.compress_output,
        oc.number_of_files, oc.chunk_size_bytes);
 
    OutputDataSpecification output_data_specification{
        std::move(oc.output_variables), std::move(oc.fixed_output_times),
        std::move(oc.repeats_each_steps), oc.output_extrapolation_residuals};
 
    return {std::move(output_format), oc.output_iteration_results,
            std::move(output_data_specification),
            std::move(oc.mesh_names_for_output), meshes};
}

References createOutputFormat().

Referenced by createOutput(), createOutputs(), createSubmeshResiduumOutputConfig(), and createTimeLoop().

createOutputConfig()

OutputConfig ProcessLib::createOutputConfig	(	const BaseLib::ConfigTree &	config,
		std::vector< std::unique_ptr< MeshLib::Mesh > > &	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__hdf__chunk_size_bytes

Input File Parameter:

prj__time_loop__output__data_mode

Input File Parameter:

prj__time_loop__output__fixed_output_times

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__geometrical_sets

Input File Parameter:

prj__time_loop__output__geometrical_sets__geometrical_set

Input File Parameter:

prj__time_loop__output__geometrical_sets__geometrical_set__name

Input File Parameter:

prj__time_loop__output__geometrical_sets__geometrical_set__geometry

Input File Parameter:

prj__time_loop__output__output_iteration_results

Definition at line 81 of file CreateOutputConfig.cpp.

{
    OutputConfig output_config;
 
    output_config.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"));
 
    output_config.prefix =
        config.getConfigParameter<std::string>("prefix", "{:meshname}");
 
    output_config.suffix =
        config.getConfigParameter<std::string>("suffix",
                                               "_ts_{:timestep}_t_{:time}");
 
    output_config.compress_output =
        config.getConfigParameter("compress_output", true);
 
    auto const hdf =
        config.getConfigSubtreeOptional("hdf");
 
    output_config.number_of_files = [&hdf]() -> unsigned int
    {
        if (hdf)
        {
            return hdf->getConfigParameter<unsigned int>("number_of_files");
        }
        return 1;
    }();
    output_config.chunk_size_bytes = [&hdf]() -> unsigned int
    {
        if (hdf)
        {
            return hdf->getConfigParameter<unsigned int>("chunk_size_bytes");
        }
        return 1048576;  // default chunk size in bytes according to
                         // https://www.hdfgroup.org/2022/10/improve-hdf5-performance-using-caching/
    }();
 
    output_config.data_mode =
        config.getConfigParameter<std::string>("data_mode", "Appended");
 
    //
    // Construction of output times
    //
 
    output_config.fixed_output_times =
        config.getConfigParameter<std::vector<double>>("fixed_output_times",
                                                       {});
    // Remove possible duplicated elements and sort.
    BaseLib::makeVectorUnique(output_config.fixed_output_times);
 
    auto& repeats_each_steps = output_config.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.");
        }
    }
    // In case nothing was specified, i.e. no explicit time steps or fixed
    // output times, every time step will be written.
    if (output_config.fixed_output_times.empty() &&
        output_config.repeats_each_steps.empty())
    {
        repeats_each_steps.emplace_back(1, 1);
    }
 
    auto const out_vars = config.getConfigSubtree("variables");
 
    auto& output_variables = output_config.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);
    }
 
    output_config.output_extrapolation_residuals =
        config.getConfigParameter<bool>("output_extrapolation_residuals",
                                        false);
 
    auto& mesh_names_for_output = output_config.mesh_names_for_output;
    if (auto const meshes_config = config.getConfigSubtreeOptional("meshes"))
    {
        if (output_config.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(
                parseOutputMeshConfig(mesh_config, meshes));
            INFO("Configure mesh '{:s}' for output.",
                 mesh_names_for_output.back());
        }
    }
 
    if (auto const geometrical_sets_config =
        config.getConfigSubtreeOptional("geometrical_sets"))
    {
        for (
            auto geometrical_set_config :
            geometrical_sets_config->getConfigSubtreeList("geometrical_set"))
        {
            auto const geometrical_set_name =
                geometrical_set_config.getConfigParameter<std::string>("name",
                                                                       "");
            auto const geometry_name =
                geometrical_set_config.getConfigParameter<std::string>(
                    "geometry");
            mesh_names_for_output.push_back(geometrical_set_name + "_" +
                                            geometry_name);
        }
    }
 
    output_config.output_iteration_results =
        config.getConfigParameter<bool>("output_iteration_results", false);
 
    return output_config;
}

References ProcessLib::OutputConfig::chunk_size_bytes, ProcessLib::OutputConfig::compress_output, ProcessLib::OutputConfig::data_mode, DBUG(), ProcessLib::OutputConfig::fixed_output_times, BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), BaseLib::makeVectorUnique(), ProcessLib::OutputConfig::mesh_names_for_output, ProcessLib::OutputConfig::number_of_files, OGS_FATAL, ProcessLib::OutputConfig::output_extrapolation_residuals, ProcessLib::OutputConfig::output_iteration_results, ProcessLib::OutputConfig::output_type, ProcessLib::OutputConfig::output_variables, parseOutputMeshConfig(), ProcessLib::OutputConfig::prefix, ProcessLib::OutputConfig::repeats_each_steps, ProcessLib::OutputConfig::suffix, vtk, and xdmf.

Referenced by createOutput(), createOutputs(), and createSubmeshResiduumOutputConfig().

createOutputFormat()

std::unique_ptr< OutputFormat > ProcessLib::createOutputFormat	(	std::string const &	output_directory,
		OutputType const	output_type,
		std::string	prefix,
		std::string	suffix,
		std::string const &	data_mode,
		bool const	compress_output,
		unsigned int const	number_of_files,
		unsigned int const	chunk_size_bytes
	)

Definition at line 61 of file CreateOutput.cpp.

{
    switch (output_type)
    {
        case OutputType::vtk:
            return std::make_unique<OutputVTKFormat>(
                output_directory, std::move(prefix), std::move(suffix),
                compress_output, convertVtkDataMode(data_mode));
        case OutputType::xdmf:
            return std::make_unique<OutputXDMFHDF5Format>(
                output_directory, std::move(prefix), std::move(suffix),
                compress_output, number_of_files, chunk_size_bytes);
        default:
            OGS_FATAL(
                "No supported file type provided. Read '{}' from "
                "<output><type> in prj file. Supported: VTK, XDMF.",
                BaseLib::to_underlying(output_type));
    }
}

References OGS_FATAL, BaseLib::to_underlying(), vtk, and xdmf.

Referenced by createOutput().

createOutputs()

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

Input File Parameter:

prj__time_loop__outputs__output

Definition at line 113 of file CreateOutput.cpp.

{
    DBUG("Parse outputs configuration:");
    std::vector<Output> outputs;
    for (auto const& output_config :
         output_configs.getConfigSubtreeList("output"))
    {
        auto oc = createOutputConfig(output_config, meshes);
        outputs.push_back(
            createOutput(std::move(oc), output_directory, meshes));
    }
    if (areOutputNamesUnique(outputs))
    {
        return outputs;
    }
    else
    {
        OGS_FATAL(
            "Output configuration paths are not unique. This will lead to "
            "overwritten results or invalid / corrupted data within the "
            "files.");
    }
}

References createOutput(), createOutputConfig(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), and OGS_FATAL.

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,
		bool const	compensate_non_equilibrium_initial_residuum,
		std::vector< double > const &	fixed_times_for_output,
		std::map< std::string, int > &	local_coupling_processes
	)

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__process_name

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__output

Definition at line 68 of file CreateProcessData.cpp.

{
    std::vector<std::unique_ptr<ProcessData>> per_process_data;
    std::vector<std::string> process_names;
    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 process_name =
            pcs_config.getConfigParameterOptional<std::string>("process_name");
        if (process_name)
        {
            if (!local_coupling_processes.contains(*process_name))
            {
                OGS_FATAL(
                    "The given process name '{}' for the element "
                    "'time_loop/processes/process/process_name' is not found "
                    "in the element "
                    "'time_loop/global_process_coupling/"
                    "local_coupling_processes/process_name' in the project "
                    "file.",
                    *process_name);
            }
 
            if (ranges::contains(process_names, *process_name))
            {
                OGS_FATAL(
                    "The given process name '{}' for the element "
                    "'time_loop/processes/process/process_name' is not unique! "
                    "Please check this in the project file.",
                    *process_name);
            }
            process_names.emplace_back(*process_name);
            local_coupling_processes[*process_name] = process_id;
        }
 
        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"),
            fixed_times_for_output);
 
        auto conv_crit = NumLib::createConvergenceCriterion(
            pcs_config.getConfigSubtree("convergence_criterion"));
 
        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.");
        }
    }
 
    if (process_names.size() != local_coupling_processes.size())
    {
        OGS_FATAL(
            "The number of the given process names for the element "
            "'time_loop/processes/process/process_name' is not equal to that "
            "in the element "
            "'time_loop/global_process_coupling/local_coupling_processes/"
            "process_name' in the project file.");
    }
 
    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 74 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().

createProcessOutputData()

ProcessOutputData ProcessLib::createProcessOutputData	(	Process const &	process,
		std::size_t const	n_processes,
		MeshLib::Mesh &	output_mesh
	)

Extracts data necessary for output from the given process.

Definition at line 143 of file ProcessOutputData.cpp.

{
    auto bulk_mesh_dof_tables =
        getDofTablesOfAllProcesses(process, n_processes);
 
    auto [output_mesh_dof_tables, container_that_owns_output_mesh_dof_tables] =
        computeOutputMeshDofTables(process, output_mesh, bulk_mesh_dof_tables);
 
    return {getProcessVariablesOfAllProcesses(process, n_processes),
            process.getSecondaryVariables(),
            ::getIntegrationPointWriters(process, output_mesh),
            std::move(bulk_mesh_dof_tables),
            std::move(output_mesh_dof_tables),
            std::move(container_that_owns_output_mesh_dof_tables),
            output_mesh};
}

References ProcessLib::Process::getSecondaryVariables().

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

createPythonBoundaryCondition()

std::unique_ptr< PythonBoundaryCondition > ProcessLib::createPythonBoundaryCondition	(	BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	boundary_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		MeshLib::Mesh const &	bulk_mesh,
		int const	variable_id,
		int const	component_id,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		std::vector< std::reference_wrapper< ProcessVariable > > const &	all_process_variables_for_this_process
	)

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 256 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_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));
    }
 
    // 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>(
        PythonBcData{
            {bc, dof_table_bulk.getGlobalComponent(variable_id, component_id),
             boundary_mesh, all_process_variables_for_this_process,
             shapefunction_order}},
        integration_order, flush_stdout, bulk_mesh.getDimension(),
        dof_table_bulk);
}

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,
		std::vector< std::reference_wrapper< ProcessVariable > > const &	all_process_variables_for_this_process
	)

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::PythonStData{
            {source_term, global_component_id, source_term_mesh,
             all_process_variables_for_this_process, shapefunction_order}},
        integration_order, global_dim, flush_stdout);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getDimension(), 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 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::LargeDeformation::createLargeDeformationProcess(), 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::createThermoRichardsMechanicsProcessStage2(), 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,
		std::vector< std::reference_wrapper< ProcessVariable > > const &	all_process_variables_for_this_process
	)

Input File Parameter:

prj__process_variables__process_variable__source_terms__source_term__type

Definition at line 21 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>(
                 MeshLib::getBulkIDString(MeshLib::MeshItemType::Node)))
    {
        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")
    {
        auto 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")
    {
        auto 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")
    {
        auto 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(),
            all_process_variables_for_this_process);
    }
 
    OGS_FATAL("Unknown source term type: `{:s}'.", type);
}

References ProcessLib::SourceTermConfig::component_id, ProcessLib::SourceTermConfig::config, createNodalSourceTerm(), createPythonSourceTerm(), createVolumetricSourceTerm(), DBUG(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), MeshLib::getBulkIDString(), 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, MeshLib::Node, OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

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

createSubmeshResiduumOutputConfig()

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

Definition at line 205 of file SubmeshResiduumOutputConfig.cpp.

{
    auto oc = createOutputConfig(config, meshes);
 
    if (oc.mesh_names_for_output.empty())
    {
        OGS_FATAL(
            "You did not specify any meshes for submesh residuum output.");
    }
 
    if (!areElementsUnique(oc.mesh_names_for_output))
    {
        OGS_FATAL("The mesh names for submesh residuum output are not unique.");
    }
 
    auto const meshes_filtered =
        filterMeshesForResiduumOutput(meshes, oc.mesh_names_for_output);
 
    for (auto const& mesh : meshes_filtered)
    {
        checkBulkIDMappingsPresent(mesh.get());
    }
 
    auto const& bulk_mesh =
        *meshes.front();  // convention: the first mesh is the bulk mesh
    checkNonOverlappingCover(bulk_mesh, meshes_filtered);
 
    return {createOutput(std::move(oc), output_directory, meshes),
            std::move(meshes_filtered)};
}

References createOutput(), createOutputConfig(), and OGS_FATAL.

Referenced by createTimeLoop().

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 > > &	meshes,
		bool const	compensate_non_equilibrium_initial_residuum
	)

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__global_process_coupling__local_coupling_processes

Input File Parameter:

prj__time_loop__global_process_coupling__local_coupling_processes__process_name

Input File Parameter:

prj__time_loop__output

Input File Parameter:

prj__time_loop__outputs

Input File Parameter:

prj__time_loop__submesh_residuum_output

Input File Parameter:

prj__time_loop__processes

Definition at line 24 of file CreateTimeLoop.cpp.

{
    auto const& coupling_config
        = config.getConfigSubtreeOptional("global_process_coupling");
 
    std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
        global_coupling_conv_criteria;
    std::map<std::string, int> local_coupling_processes;
    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");
 
        auto coupling_convergence_criterion_config =
            coupling_convergence_criteria_config.getConfigSubtreeList(
                "convergence_criterion");
        std::transform(coupling_convergence_criterion_config.begin(),
                       coupling_convergence_criterion_config.end(),
                       std::back_inserter(global_coupling_conv_criteria),
                       [](BaseLib::ConfigTree const& c)
                       { return NumLib::createConvergenceCriterion(c); });
 
        auto const& local_coupling_processes_config =
            coupling_config
                ->getConfigSubtreeOptional("local_coupling_processes");
        if (local_coupling_processes_config)
        {
            for (
                auto name :
                local_coupling_processes_config
                    ->getConfigParameterList<std::string>("process_name"))
            {
                BaseLib::insertIfKeyUniqueElseError(
                    local_coupling_processes, name, -1,
                    "The name of locally coupled process is not unique.");
            }
 
            static std::string const error_info =
                "Please check the number of elements in the tag "
                "'time_loop/global_process_coupling/"
                "local_coupling_processes' in the project file.";
            if (local_coupling_processes.size() >
                global_coupling_conv_criteria.size() - 1)
            {
                OGS_FATAL(
                    "The number of the locally coupled processes is greater "
                    "than or equal to the number of total coupled processes. "
                    "{}",
                    error_info);
            }
 
            INFO("There are {:d} locally coupled processes.",
                 local_coupling_processes.size());
 
            if (local_coupling_processes.size() < 2)
            {
                OGS_FATAL(
                    "At least two locally coupled processes are required for "
                    "the local iteration solution! {} ",
                    error_info);
            }
        }
    }
 
    auto output_config_tree = config.getConfigSubtreeOptional("output");
    if (!output_config_tree)
    {
        INFO("No output section found.");
    }
    auto outputs =
        output_config_tree
            ? createOutput(*output_config_tree, output_directory, meshes)
            : createOutputs(config.getConfigSubtree("outputs"),
                            output_directory, meshes);
    auto const fixed_times_for_output =
        calculateUniqueFixedTimesForAllOutputs(outputs);
 
    if (auto const submesh_residuum_output_config_tree =
        config.getConfigSubtreeOptional("submesh_residuum_output");
        submesh_residuum_output_config_tree)
    {
        auto smroc = createSubmeshResiduumOutputConfig(
            *submesh_residuum_output_config_tree, output_directory, meshes);
 
        for (auto& process : processes)
        {
            auto const& residuum_vector_names =
                process->initializeAssemblyOnSubmeshes(smroc.meshes);
 
            for (auto const& name : residuum_vector_names)
            {
                smroc.output.doNotProjectFromBulkMeshToSubmeshes(
                    name, MeshLib::MeshItemType::Node);
            }
        }
 
        outputs.push_back(std::move(smroc.output));
    }
    else
    {
        // Submesh assembly must always be initialized.
        for (auto& process : processes)
        {
            process->initializeAssemblyOnSubmeshes({});
        }
    }
 
    auto per_process_data = createPerProcessData(
        config.getConfigSubtree("processes"), processes, nonlinear_solvers,
        compensate_non_equilibrium_initial_residuum, fixed_times_for_output,
        local_coupling_processes);
 
    const bool use_staggered_scheme =
        ranges::any_of(processes.begin(), processes.end(),
                       [](auto const& process)
                       { return !(process->isMonolithicSchemeUsed()); });
 
    if (!use_staggered_scheme && per_process_data.size() > 1)
    {
        OGS_FATAL(
            "The monolithic scheme is used. However more than one process data "
            "tags (by name \"process\") inside tag \"time_loop\" are defined "
            "for the staggered scheme. If you want to use staggered scheme, "
            "please set the element of tag \"<coupling_scheme>\" to "
            "\"staggered\".");
    }
 
    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->timestep_algorithm->end() <
                                        b->timestep_algorithm->end());
                            });
    const double start_time =
        per_process_data[minmax_iter.first - per_process_data.begin()]
            ->timestep_algorithm->begin();
    const double end_time =
        per_process_data[minmax_iter.second - per_process_data.begin()]
            ->timestep_algorithm->end();
 
    return std::make_unique<TimeLoop>(
        std::move(outputs), std::move(per_process_data),
        max_coupling_iterations, std::move(global_coupling_conv_criteria),
        std::move(local_coupling_processes), start_time, end_time);
}

References calculateUniqueFixedTimesForAllOutputs(), createOutput(), createOutputs(), createPerProcessData(), createSubmeshResiduumOutputConfig(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), BaseLib::insertIfKeyUniqueElseError(), MeshLib::Node, 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 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,
            std::move(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().

extractElementsAlongOuterNodes()

static std::vector< std::vector< std::size_t > > ProcessLib::extractElementsAlongOuterNodes ( MeshLib::Mesh const &  mesh, MeshLib::Mesh const &  sub_mesh, std::vector< std::size_t > const &  outer_nodes  )

static

Definition at line 69 of file CreateDeactivatedSubdomain.cpp.

{
    auto const& bulk_node_ids =
        *sub_mesh.getProperties().template getPropertyVector<std::size_t>(
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
            MeshLib::MeshItemType::Node, 1);
 
    auto to_bulk_node_id =
        ranges::views::transform([&bulk_node_ids](std::size_t const node_id)
                                 { return bulk_node_ids[node_id]; });
    auto connected_elements = ranges::views::transform(
        [&mesh](std::size_t const node_id)
        {
            return mesh.getElementsConnectedToNode(node_id) |
                   MeshLib::views::ids | ranges::to<std::vector>;
        });
 
    return outer_nodes | to_bulk_node_id | connected_elements |
           ranges::to<std::vector>;
}

References MeshLib::getBulkIDString(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getProperties(), MeshLib::views::ids, and MeshLib::Node.

Referenced by createDeactivatedSubdomainMesh().

extractInnerAndOuterNodes()

template<typename IsActive >

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

static

Definition at line 32 of file CreateDeactivatedSubdomain.cpp.

{
    auto* const bulk_node_ids = MeshLib::bulkNodeIDs(sub_mesh);
    if (bulk_node_ids == nullptr)
    {
        OGS_FATAL(
            "Bulk node ids map is not available in the deactivate subdomain "
            "mesh.");
    }
 
    std::vector<std::size_t> 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<std::size_t> outer_nodes;
 
    ranges::partition_copy(
        sub_mesh.getNodes() | MeshLib::views::ids,
        back_inserter(inner_nodes),
        back_inserter(outer_nodes),
        [&](std::size_t const n)
        {
            auto const bulk_node = mesh.getNode((*bulk_node_ids)[n]);
            const auto& connected_elements =
                mesh.getElementsConnectedToNode(*bulk_node);
            // Check whether this node is connected only to an active
            // elements. Then it is an inner node, and outer otherwise.
            return ranges::all_of(connected_elements | MeshLib::views::ids,
                                  is_active);
        });
 
    return {std::move(inner_nodes), std::move(outer_nodes)};
}

References MeshLib::bulkNodeIDs(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNode(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::views::ids, 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 47 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 BaseLib::ConfigTree::getConfigParameter().

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 57 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 const& 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(), and findProcessVariables().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LargeDeformation::createLargeDeformationProcess(), 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::createThermoRichardsMechanicsProcessStage2(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowWithPrhoProcess(), and findProcessVariables().

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 78 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 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 21 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, DisplacementDim >::computeCrackIntegral(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::computeEnergy(), ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), and ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity().

getEssentialBCValuesLocal() [1/2]

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

Definition at line 113 of file DirichletBoundaryConditionAuxiliaryFunctions.cpp.

{
    getEssentialBCValuesLocal(
        parameter, bc_mesh,
        bc_mesh.getNodes() | MeshLib::views::ids | ranges::to<std::vector>,
        dof_table_boundary, variable_id, component_id, t, x, bc_values);
}

References getEssentialBCValuesLocal(), MeshLib::Mesh::getNodes(), and MeshLib::views::ids.

getEssentialBCValuesLocal() [2/2]

void ProcessLib::getEssentialBCValuesLocal	(	ParameterLib::Parameter< double > const &	parameter,
		MeshLib::Mesh const &	bc_mesh,
		std::vector< std::size_t > 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 69 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 node_id : nodes_in_bc_mesh)
    {
        // TODO: that might be slow, but only done once
        auto const global_index = dof_table_boundary.getGlobalIndex(
            {bc_mesh.getID(), MeshLib::MeshItemType::Node, 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(node_id);
            pos.setCoordinates(*bc_mesh.getNode(node_id));
            bc_values.ids.emplace_back(global_index);
            bc_values.values.emplace_back(parameter(t, pos).front());
        }
    }
}

References NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), MeshLib::Mesh::getNode(), 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(), ProcessLib::SolutionDependentDirichletBoundaryCondition::getEssentialBCValues(), and getEssentialBCValuesLocal().

getIntegrationPointDataMaterialStateVariables()

template<typename IntegrationPointDataVector , typename MemberType , typename MaterialStateVariables >

std::vector< double > ProcessLib::getIntegrationPointDataMaterialStateVariables	(	IntegrationPointDataVector const &	ip_data_vector,
		MemberType	member,
		std::function< std::span< double >(MaterialStateVariables &)>	get_values_span,
		int const	n_components
	)

Definition at line 247 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.begin(), values_span.end());
    }
 
    return result;
}

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssemblerInterface< DisplacementDim >::getMaterialStateVariableInternalState(), ProcessLib::SmallDeformation::SmallDeformationLocalAssemblerInterface< DisplacementDim >::getMaterialStateVariableInternalState(), ProcessLib::ThermoRichardsMechanics::LocalAssemblerInterface< DisplacementDim, ConstitutiveTraits >::getMaterialStateVariableInternalState(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::getMaterialStateVariableInternalState(), and ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::getMaterialStateVariableInternalState().

getIntegrationPointDimMatrixData() [1/2]

template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >

std::vector< double > const & ProcessLib::getIntegrationPointDimMatrixData	(	IntegrationPointDataVector const &	ip_data_vector,
		Accessor &&	accessor,
		std::vector< double > &	cache
	)

Definition at line 39 of file SetOrGetIntegrationPointData.h.

{
    using AccessorResult = decltype(std::declval<Accessor>()(
        std::declval<IntegrationPointDataVector>()[0]));
    static_assert(std::is_lvalue_reference_v<AccessorResult>,
                  "The ip data accessor should return a reference. This check "
                  "prevents accidental copies.");
 
    auto const n_integration_points = ip_data_vector.size();
    constexpr int size = DisplacementDim * DisplacementDim;
 
    cache.clear();
    auto cache_mat = MathLib::createZeroedMatrix<
        Eigen::Matrix<double, size, Eigen::Dynamic, Eigen::RowMajor>>(
        cache, size, n_integration_points);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        auto const& dim_matix = accessor(ip_data_vector[ip]);
        cache_mat.col(ip) = dim_matix.template reshaped<Eigen::RowMajor>();
    }
 
    return cache;
}

References MathLib::createZeroedMatrix().

getIntegrationPointDimMatrixData() [2/2]

template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >

std::vector< double > const & ProcessLib::getIntegrationPointDimMatrixData	(	IntegrationPointDataVector const &	ip_data_vector,
		MemberType IpData::*const	member,
		std::vector< double > &	cache
	)

Definition at line 26 of file SetOrGetIntegrationPointData.h.

{
    return getIntegrationPointDimMatrixData<DisplacementDim>(
        ip_data_vector,
        [member](IpData const& ip_data) -> auto const&
        { return ip_data.*member; },
        cache);
}

getIntegrationPointKelvinVectorData() [1/3]

template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >

std::vector< double > const & ProcessLib::getIntegrationPointKelvinVectorData	(	IntegrationPointDataVector const &	ip_data_vector,
		Accessor &&	accessor,
		std::vector< double > &	cache
	)

Definition at line 81 of file SetOrGetIntegrationPointData.h.

{
    using AccessorResult = decltype(std::declval<Accessor>()(
        std::declval<IntegrationPointDataVector>()[0]));
    static_assert(std::is_lvalue_reference_v<AccessorResult>,
                  "The ip data accessor should return a reference. This check "
                  "prevents accidental copies.");
 
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    auto const n_integration_points = ip_data_vector.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 = accessor(ip_data_vector[ip]);
        cache_mat.col(ip) =
            MathLib::KelvinVector::kelvinVectorToSymmetricTensor(kelvin_vector);
    }
 
    return cache;
}

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

getIntegrationPointKelvinVectorData() [2/3]

template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >

std::vector< double > const & ProcessLib::getIntegrationPointKelvinVectorData	(	IntegrationPointDataVector const &	ip_data_vector,
		MemberType IpData::*const	member,
		std::vector< double > &	cache
	)

Definition at line 68 of file SetOrGetIntegrationPointData.h.

{
    return getIntegrationPointKelvinVectorData<DisplacementDim>(
        ip_data_vector,
        [member](IpData const& ip_data) -> auto const&
        { return ip_data.*member; },
        cache);
}

getIntegrationPointKelvinVectorData() [3/3]

template<int DisplacementDim, typename IntegrationPointDataVector , typename MemberType >

std::vector< double > ProcessLib::getIntegrationPointKelvinVectorData	(	IntegrationPointDataVector const &	ip_data_vector,
		MemberType	member
	)

Overload without cache argument.

Note

This function returns the data in transposed storage order compared to the overloads that have a cache argument.

Definition at line 116 of file SetOrGetIntegrationPointData.h.

{
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
 
    return transposeInPlace<kelvin_vector_size>(
        [&](std::vector<double>& values)
        {
            return getIntegrationPointKelvinVectorData<DisplacementDim>(
                ip_data_vector, member, values);
            ;
        });
}

References MathLib::KelvinVector::kelvin_vector_dimensions().

getIntegrationPointScalarData() [1/2]

template<typename IntegrationPointDataVector , typename Accessor >

std::vector< double > const & ProcessLib::getIntegrationPointScalarData	(	IntegrationPointDataVector const &	ip_data_vector,
		Accessor &&	accessor,
		std::vector< double > &	cache
	)

Definition at line 188 of file SetOrGetIntegrationPointData.h.

{
    using AccessorResult = decltype(std::declval<Accessor>()(
        std::declval<IntegrationPointDataVector>()[0]));
    static_assert(std::is_lvalue_reference_v<AccessorResult>,
                  "The ip data accessor should return a reference. This check "
                  "prevents accidental copies.");
 
    auto const n_integration_points = ip_data_vector.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] = accessor(ip_data_vector[ip]);
    }
 
    return cache;
}

References MathLib::createZeroedMatrix().

getIntegrationPointScalarData() [2/2]

template<typename IntegrationPointDataVector , typename IpData , typename MemberType >

std::vector< double > const & ProcessLib::getIntegrationPointScalarData	(	IntegrationPointDataVector const &	ip_data_vector,
		MemberType IpData::*const	member,
		std::vector< double > &	cache
	)

Definition at line 176 of file SetOrGetIntegrationPointData.h.

{
    return getIntegrationPointScalarData(
        ip_data_vector,
        [member](IpData const& ip_data) -> auto const&
        { return ip_data.*member; },
        cache);
}

References getIntegrationPointScalarData().

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

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 164 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_tables,
            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_tables);
        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_tables,
            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_tables);
        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::LargeDeformation::LargeDeformationProcess< 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, ConstitutiveTraits >::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::initializeConcreteProcess(), ProcessLib::TES::TESProcess::initializeSecondaryVariables(), and makeExtrapolator2().

makeExtrapolator2()

template<typename LocalAssemblerCollection , typename IPDataAccessor >

SecondaryVariableFunctions ProcessLib::makeExtrapolator2	(	const unsigned	num_components,
		NumLib::Extrapolator &	extrapolator,
		LocalAssemblerCollection const &	local_assemblers,
		IPDataAccessor &&	accessor
	)

A variant that takes an accessor function as a callback.

The accessor must take a local assembler by const reference as its only argument and must return a std::vector<double> of integration point data. The data returned by the accessor must be in "integration point writer order", which is transposed compared to "extrapolator order".

Definition at line 213 of file SecondaryVariable.h.

{
    using LocalAssemblerInterface = std::remove_cvref_t<
        decltype(*std::declval<LocalAssemblerCollection>()[0])>;
    static_assert(std::is_invocable_r_v<std::vector<double>, IPDataAccessor,
                                        LocalAssemblerInterface const&>);
 
    if (num_components == 1)
    {
        auto method_wrapped =
            [accessor](
                LocalAssemblerInterface const& loc_asm, const double /*t*/,
                std::vector<GlobalVector*> const& /*x*/,
                std::vector<
                    NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
                std::vector<double>& cache) -> std::vector<double> const&
        {
            cache = accessor(loc_asm);
            return cache;
        };
 
        return makeExtrapolator(num_components, extrapolator, local_assemblers,
                                method_wrapped);
    }
 
    auto method_wrapped =
        [accessor, num_components](
            LocalAssemblerInterface const& loc_asm, const double /*t*/,
            std::vector<GlobalVector*> const& /*x*/,
            std::vector<
                NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
            std::vector<double>& cache) -> std::vector<double> const&
    {
        cache = accessor(loc_asm);
        transposeInPlace(cache, cache.size() / num_components);
        return cache;
    };
 
    return makeExtrapolator(num_components, extrapolator, local_assemblers,
                            method_wrapped);
}

References makeExtrapolator(), and transposeInPlace().

Referenced by ProcessLib::Reflection::addReflectedSecondaryVariables().

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

operator<<() [1/4]

std::ostream & ProcessLib::operator<<	(	std::ostream &	os,
		Output const &	output
	)

Definition at line 449 of file Output.cpp.

{
    os << "Output::_output_data_specification:\t"
       << output._output_data_specification;
    os << "Output::_output_format:\t" << *(output._output_format);
    return os;
}

operator<<() [2/4]

std::ostream & ProcessLib::operator<<	(	std::ostream &	os,
		OutputDataSpecification const &	o
	)

Definition at line 90 of file OutputDataSpecification.cpp.

{
    os << "OuputDataSpecification" << std::endl;
    os << "\toutput_variables: ";
    std::copy(o.output_variables.begin(), o.output_variables.end(),
              std::ostream_iterator<std::string>(os, " "));
    os << "\n";
    os << "\tfixed_output_times: ";
    std::copy(o.fixed_output_times.begin(), o.fixed_output_times.end(),
              std::ostream_iterator<double>(os, " "));
    os << "\n";
    os << "\trepeats_each_steps: ";
    std::copy(o.repeats_each_steps.begin(), o.repeats_each_steps.end(),
              std::ostream_iterator<PairRepeatEachSteps>(os, " "));
    os << "\n";
    os << "\toutput_residual: " << o.output_residuals << "\n";
    return os;
}

References ProcessLib::OutputDataSpecification::fixed_output_times, ProcessLib::OutputDataSpecification::output_residuals, ProcessLib::OutputDataSpecification::output_variables, and ProcessLib::OutputDataSpecification::repeats_each_steps.

operator<<() [3/4]

std::ostream & ProcessLib::operator<< ( std::ostream &  os, OutputFormat const &  of  )

inline

Definition at line 50 of file OutputFormat.h.

{
    os << "OutputFormat::directory:" << of.directory << std::endl;
    os << "OutputFormat::prefix:" << of.prefix << std::endl;
    os << "OutputFormat::suffix:" << of.suffix << std::endl;
    os << "OutputFormat::compression:" << of.compression << std::endl;
    return os;
}

References ProcessLib::OutputFormat::compression, ProcessLib::OutputFormat::directory, ProcessLib::OutputFormat::prefix, and ProcessLib::OutputFormat::suffix.

operator<<() [4/4]

std::ostream & ProcessLib::operator<<	(	std::ostream &	os,
		PairRepeatEachSteps const &	pair
	)

Definition at line 83 of file OutputDataSpecification.cpp.

{
    os << "Output " << pair.repeat << " times every " << pair.each_steps
       << " timestep.\n";
    return os;
}

References ProcessLib::PairRepeatEachSteps::each_steps, and ProcessLib::PairRepeatEachSteps::repeat.

outputMeshVtk() [1/2]

void ProcessLib::outputMeshVtk	(	OutputVTKFormat const &	output_file,
		MeshLib::IO::PVDFile &	pvd_file,
		MeshLib::Mesh const &	mesh,
		double const	t,
		int const	timestep,
		int const	iteration
	)

Definition at line 57 of file OutputFormat.cpp.

{
    auto const name =
        output_file.constructFilename(mesh.getName(), timestep, t, iteration);
    pvd_file.addVTUFile(name, t);
 
    auto const path = BaseLib::joinPaths(output_file.directory, name);
    // 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 temporarily disabled and are restored at the end of the
    // function.
    [[maybe_unused]] DisableFPE disable_fpe;
    outputMeshVtk(path, mesh, output_file.compression, output_file.data_mode);
}

References MeshLib::IO::PVDFile::addVTUFile(), ProcessLib::OutputFormat::compression, ProcessLib::OutputVTKFormat::constructFilename(), ProcessLib::OutputVTKFormat::data_mode, ProcessLib::OutputFormat::directory, MeshLib::Mesh::getName(), BaseLib::joinPaths(), and outputMeshVtk().

outputMeshVtk() [2/2]

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

Definition at line 48 of file OutputFormat.cpp.

{
    DBUG("Writing output to '{:s}'.", file_name);
 
    MeshLib::IO::VtuInterface vtu_interface(&mesh, data_mode, compress_output);
    vtu_interface.writeToFile(file_name);
}

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

Referenced by ProcessLib::Output::doOutputNonlinearIteration(), ProcessLib::OutputVTKFormat::outputMeshes(), and outputMeshVtk().

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 184 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 131 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
	)

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.computeSecondaryVariable(t, dt, process_solutions,
                                     *process_solutions_prev[process_id],
                                     process_id);
        pcs.postTimestep(process_solutions, process_solutions_prev, t, dt,
                         process_id);
    }
}

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

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 77 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::preTsNonlinearSolvePostTs().

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(), and PYBIND11_MODULE().

removeIPFieldDataNameSuffix()

std::string ProcessLib::removeIPFieldDataNameSuffix ( std::string const &  name )

inline

Removes the suffix '_ip' from the passed field name.

Definition at line 20 of file SetIPDataInitialConditions.h.

{
    if (!name.ends_with("_ip"))
    {
        OGS_FATAL(
            "The name of integration point data must end with '_ip'. '{}' "
            "does not.",
            name);
    }
 
    return name.substr(0, name.size() - 3);
}

References OGS_FATAL.

Referenced by setIPDataInitialConditions().

setEquationSystem()

void ProcessLib::setEquationSystem

(

ProcessData const &

process_data

)

Definition at line 17 of file ProcessData.cpp.

{
    auto& conv_crit = *process_data.conv_crit;
    auto& nonlinear_solver = process_data.nonlinear_solver;
 
    using Tag = NumLib::NonlinearSolverTag;
    switch (process_data.nonlinear_solver_tag)
    {
        case Tag::Picard:
        {
            using EqSys = NumLib::NonlinearSystem<Tag::Picard>;
            auto& eq_sys_ = static_cast<EqSys&>(*process_data.tdisc_ode_sys);
            if (auto* nl_solver =
                    dynamic_cast<NumLib::NonlinearSolver<Tag::Picard>*>(
                        &nonlinear_solver);
                nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
            else
            {
                OGS_FATAL(
                    "Could not cast nonlinear solver to Picard type solver.");
            }
            break;
        }
        case Tag::Newton:
        {
            using EqSys = NumLib::NonlinearSystem<Tag::Newton>;
            auto& eq_sys_ = static_cast<EqSys&>(*process_data.tdisc_ode_sys);
 
            if (auto* nl_solver =
                    dynamic_cast<NumLib::NonlinearSolver<Tag::Newton>*>(
                        &nonlinear_solver);
                nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
#ifdef USE_PETSC
            else if (auto* nl_solver =
                         dynamic_cast<NumLib::PETScNonlinearSolver*>(
                             &nonlinear_solver);
                     nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
#endif  // USE_PETSC
            else
            {
                OGS_FATAL(
                    "Could not cast nonlinear solver to Newton type solver.");
            }
            break;
        }
    }
}

References ProcessLib::ProcessData::conv_crit, ProcessLib::ProcessData::nonlinear_solver, ProcessLib::ProcessData::nonlinear_solver_tag, OGS_FATAL, and ProcessLib::ProcessData::tdisc_ode_sys.

Referenced by calculateNonEquilibriumInitialResiduum(), and solveOneTimeStepOneProcess().

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 169 of file TimeLoop.cpp.

{
    std::vector<GlobalVector*> process_solutions;
    std::vector<GlobalVector*> process_solutions_prev;
 
    for (auto const& 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 const& 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().

setIntegrationPointDataMaterialStateVariables()

template<typename IntegrationPointDataVector , typename MemberType , typename MaterialStateVariables >

std::size_t ProcessLib::setIntegrationPointDataMaterialStateVariables	(	double const *	values,
		IntegrationPointDataVector &	ip_data_vector,
		MemberType	member,
		std::function< std::span< double >(MaterialStateVariables &)>	get_values_span
	)

Definition at line 270 of file SetOrGetIntegrationPointData.h.

{
    auto const n_integration_points = ip_data_vector.size();
 
    std::size_t position = 0;
    for (auto const& 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.begin());
        position += values_span.size();
    }
    return n_integration_points;
}

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssemblerInterface< DisplacementDim >::setIPDataInitialConditions(), ProcessLib::SmallDeformation::SmallDeformationLocalAssemblerInterface< DisplacementDim >::setIPDataInitialConditions(), ProcessLib::ThermoRichardsMechanics::LocalAssemblerInterface< DisplacementDim, ConstitutiveTraits >::setIPDataInitialConditions(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setIPDataInitialConditions(), and ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setIPDataInitialConditions().

setIntegrationPointKelvinVectorData() [1/2]

template<int DisplacementDim, typename IntegrationPointDataVector , typename Accessor >

std::size_t ProcessLib::setIntegrationPointKelvinVectorData	(	double const *	values,
		IntegrationPointDataVector &	ip_data_vector,
		Accessor &&	accessor
	)

Definition at line 145 of file SetOrGetIntegrationPointData.h.

{
    using AccessorResult = decltype(std::declval<Accessor>()(
        std::declval<IntegrationPointDataVector>()[0]));
    static_assert(std::is_lvalue_reference_v<AccessorResult>,
                  "The ip data accessor must return a reference.");
 
    constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    auto const n_integration_points = ip_data_vector.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)
    {
        accessor(ip_data_vector[ip]) =
            MathLib::KelvinVector::symmetricTensorToKelvinVector(
                kelvin_vector_values.col(ip));
    }
 
    return n_integration_points;
}

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

setIntegrationPointKelvinVectorData() [2/2]

template<int DisplacementDim, typename IntegrationPointDataVector , typename IpData , typename MemberType >

std::size_t ProcessLib::setIntegrationPointKelvinVectorData	(	double const *	values,
		IntegrationPointDataVector &	ip_data_vector,
		MemberType IpData::*const	member
	)

Definition at line 133 of file SetOrGetIntegrationPointData.h.

{
    return setIntegrationPointKelvinVectorData<DisplacementDim>(
        values, ip_data_vector,
        [member](IpData& ip_data) -> auto& { return ip_data.*member; });
}

setIntegrationPointScalarData() [1/2]

template<typename IntegrationPointDataVector , typename Accessor >

std::size_t ProcessLib::setIntegrationPointScalarData	(	double const *	values,
		IntegrationPointDataVector &	ip_data_vector,
		Accessor &&	accessor
	)

Definition at line 226 of file SetOrGetIntegrationPointData.h.

{
    using AccessorResult = decltype(std::declval<Accessor>()(
        std::declval<IntegrationPointDataVector>()[0]));
    static_assert(std::is_lvalue_reference_v<AccessorResult>,
                  "The ip data accessor must return a reference.");
 
    auto const n_integration_points = ip_data_vector.size();
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        accessor(ip_data_vector[ip]) = values[ip];
    }
    return n_integration_points;
}

setIntegrationPointScalarData() [2/2]

template<typename IntegrationPointDataVector , typename IpData , typename MemberType >

std::size_t ProcessLib::setIntegrationPointScalarData	(	double const *	values,
		IntegrationPointDataVector &	ip_data_vector,
		MemberType IpData::*const	member
	)

Definition at line 215 of file SetOrGetIntegrationPointData.h.

{
    return setIntegrationPointScalarData(values, ip_data_vector,
                                         [member](IpData& ip_data) -> auto&
                                         { return ip_data.*member; });
}

References setIntegrationPointScalarData().

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

setIPDataInitialConditions()

template<typename LocalAssemblersVector >

void ProcessLib::setIPDataInitialConditions	(	std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &	_integration_point_writer,
		MeshLib::Properties const &	mesh_properties,
		LocalAssemblersVector &	local_assemblers,
		bool const	remove_name_suffix = false
	)

Definition at line 34 of file SetIPDataInitialConditions.h.

{
    for (auto const& ip_writer : _integration_point_writer)
    {
        // Find the mesh property with integration point writer's name.
        auto const& name = ip_writer->name();
        if (!mesh_properties.existsPropertyVector<double>(name))
        {
            continue;
        }
        auto const& mesh_property =
            *mesh_properties.template getPropertyVector<double>(name);
 
        // The mesh property must be defined on integration points.
        if (mesh_property.getMeshItemType() !=
            MeshLib::MeshItemType::IntegrationPoint)
        {
            continue;
        }
 
        auto const ip_meta_data =
            getIntegrationPointMetaData(mesh_properties, name);
 
        // Check the number of components.
        if (ip_meta_data.n_components !=
            mesh_property.getNumberOfGlobalComponents())
        {
            OGS_FATAL(
                "Different number of components in meta data ({:d}) than in "
                "the integration point field data for '{:s}': {:d}.",
                ip_meta_data.n_components, name,
                mesh_property.getNumberOfGlobalComponents());
        }
 
        INFO("Setting initial integration point data for '{}'", name);
 
        auto const& name_transformed =
            remove_name_suffix ? removeIPFieldDataNameSuffix(name) : name;
 
        // Now we have a properly named vtk's field data array and the
        // corresponding meta data.
        std::size_t position = 0;
        for (auto& local_asm : local_assemblers)
        {
            std::size_t const integration_points_read =
                local_asm->setIPDataInitialConditions(
                    name_transformed, &mesh_property[position],
                    ip_meta_data.integration_order);
            // The number of read integration points could be zero in case there
            // are e.g. multiple materials with different sets of internal state
            // variables.
 
            position += integration_points_read * ip_meta_data.n_components;
        }
    }
}

References MeshLib::Properties::existsPropertyVector(), INFO(), MeshLib::IntegrationPoint, OGS_FATAL, and removeIPFieldDataNameSuffix().

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< 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, ConstitutiveTraits >::initializeConcreteProcess().

setTimeDiscretizedODESystem() [1/2]

void ProcessLib::setTimeDiscretizedODESystem

(

ProcessData &

process_data

)

Definition at line 163 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 110 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, std::vector< Output > const &  outputs  )

static

Definition at line 654 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, outputs);
 
    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,
		std::vector< Output > const &	outputs
	)

Definition at line 220 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& nonlinear_solver = process_data.nonlinear_solver;
 
    setEquationSystem(process_data);
 
    // 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)
    {
        // Note: We don't call the postNonLinearSolver(), preOutput(),
        // computeSecondaryVariable() and postTimestep() hooks here. This might
        // lead to some inconsistencies in the data compared to regular output.
        for (auto const& output : outputs)
        {
            output.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;
    }
 
    process.postNonLinearSolver(x, x_prev, t, delta_t, process_id);
 
    return nonlinear_solver_status;
}

References ProcessLib::ProcessData::nonlinear_solver, ProcessLib::ProcessData::process, ProcessLib::ProcessData::process_id, setEquationSystem(), and ProcessLib::ProcessData::time_disc.

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

transposeInPlace() [1/3]

template<int Components>

void ProcessLib::transposeInPlace

(

std::vector< double > &

values

)

Definition at line 41 of file TransposeInPlace.h.

{
    MathLib::toMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Components, Eigen::RowMajor>>(
        values, values.size() / Components, Components) =
        MathLib::toMatrix<
            Eigen::Matrix<double, Components, Eigen::Dynamic, Eigen::RowMajor>>(
            values, Components, values.size() / Components)
            .transpose()
            .eval();
}

References MathLib::toMatrix().

transposeInPlace() [2/3]

void ProcessLib::transposeInPlace ( std::vector< double > &  values, unsigned const  num_components  )

inline

Definition at line 53 of file TransposeInPlace.h.

{
    MathLib::toMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>(
        values, values.size() / num_components, num_components) =
        MathLib::toMatrix<Eigen::Matrix<double,
                                        Eigen::Dynamic,
                                        Eigen::Dynamic,
                                        Eigen::RowMajor>>(
            values, num_components, values.size() / num_components)
            .transpose()
            .eval();
}

References MathLib::toMatrix().

transposeInPlace() [3/3]

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

Referenced by makeExtrapolator2().

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 672 of file TimeLoop.cpp.

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