Detailed Description

The numerical algorithms used in OpenGeoSys

Namespaces
	anonymous_namespace{DOFTableUtil.cpp}

	anonymous_namespace{LocalToGlobalIndexMap.cpp}

	detail

Classes
struct	SerialExecutor

struct	GlobalVectorProvider

struct	GlobalMatrixProvider

class	LocalToGlobalIndexMap

class	MatrixProvider

class	MeshComponentMap
	Multidirectional mapping between mesh entities and degrees of freedom. More...

class	SimpleMatrixVectorProvider

class	VectorProvider

struct	AssemblyException

class	ExtrapolatableElement

class	ExtrapolatableElementCollection

class	ExtrapolatableLocalAssemblerCollection

class	Extrapolator

class	LocalLinearLeastSquaresExtrapolator

struct	NaturalCoordinatesMapping

struct	NaturalCoordinates

struct	NaturalCoordinates< MeshLib::Line >

struct	NaturalCoordinates< MeshLib::Line3 >

struct	NaturalCoordinates< MeshLib::Tri >

struct	NaturalCoordinates< MeshLib::Tri6 >

struct	NaturalCoordinates< MeshLib::Quad >

struct	NaturalCoordinates< MeshLib::Quad8 >

struct	NaturalCoordinates< MeshLib::Quad9 >

struct	NaturalCoordinates< MeshLib::Tet >

struct	NaturalCoordinates< MeshLib::Tet10 >

struct	NaturalCoordinates< MeshLib::Prism >

struct	NaturalCoordinates< MeshLib::Prism15 >

struct	NaturalCoordinates< MeshLib::Pyramid >

struct	NaturalCoordinates< MeshLib::Pyramid13 >

struct	NaturalCoordinates< MeshLib::Hex >

struct	NaturalCoordinates< MeshLib::Hex20 >

struct	ShapeMatrices
	Coordinates mapping matrices at particular location. More...

struct	FePOINT1

struct	FeLINE2

struct	FeLINE3

struct	FeTRI3

struct	FeTRI6

struct	FeQUAD4

struct	FeQUAD8

struct	FeQUAD9

struct	FeHEX8

struct	FeHEX20

struct	FeTET4

struct	FeTET10

struct	FePRISM6

struct	FePRISM15

struct	FePYRA5

struct	FePYRA13

struct	LowerDim

struct	LowerDim< NumLib::ShapeLine3 >

struct	LowerDim< NumLib::ShapeQuad8 >

struct	LowerDim< NumLib::ShapeQuad9 >

struct	LowerDim< NumLib::ShapeHex20 >

struct	LowerDim< NumLib::ShapeTri6 >

struct	LowerDim< NumLib::ShapeTet10 >

struct	LowerDim< NumLib::ShapePrism15 >

struct	LowerDim< NumLib::ShapePyra13 >

class	TemplateIsoparametric
	Template class for isoparametric elements. More...

struct	GaussLegendreIntegrationPolicy

struct	GaussLegendreIntegrationPolicy< MeshLib::Point >

struct	GaussLegendreIntegrationPolicy< MeshLib::Tri >

struct	GaussLegendreIntegrationPolicy< MeshLib::Tri6 >

struct	GaussLegendreIntegrationPolicy< MeshLib::Tet >

struct	GaussLegendreIntegrationPolicy< MeshLib::Tet10 >

struct	GaussLegendreIntegrationPolicy< MeshLib::Prism >

struct	GaussLegendreIntegrationPolicy< MeshLib::Prism15 >

struct	GaussLegendreIntegrationPolicy< MeshLib::Pyramid >

struct	GaussLegendreIntegrationPolicy< MeshLib::Pyramid13 >

class	IntegrationGaussLegendrePrism
	Gauss-Legendre quadrature rule for prisms. More...

class	IntegrationGaussLegendrePyramid
	Gauss-Legendre quadrature rule for pyramid. More...

class	IntegrationGaussLegendreRegular

class	IntegrationGaussLegendreTet
	Gauss-Legendre quadrature rule for tetrahedrals. More...

class	IntegrationGaussLegendreTri
	Gauss-Legendre quadrature rule for triangles. More...

class	IntegrationPoint

class	ShapeHex20

class	ShapeHex8

class	ShapeLine2

class	ShapeLine3

class	ShapePoint1
	Shape function for a point element in natural coordinates. More...

class	ShapePrism15

class	ShapePrism6

class	ShapePyra13

class	ShapePyra5

class	ShapeQuad4

class	ShapeQuad8

class	ShapeQuad9

class	ShapeTet10

class	ShapeTet4

class	ShapeTri3

class	ShapeTri6

class	ISpatialFunction
	Interface class for any functions of spatial coordinates \(f(x,y,z)\). More...

struct	IndexValueVector

struct	NewtonRaphsonSolverParameters

class	NewtonRaphson

class	ConvergenceCriterion

class	ConvergenceCriterionDeltaX

class	ConvergenceCriterionPerComponent

class	ConvergenceCriterionPerComponentDeltaX

class	ConvergenceCriterionPerComponentResidual

class	ConvergenceCriterionResidual

class	EquationSystem

class	MatrixTranslator

class	MatrixTranslator< ODESystemTag::FirstOrderImplicitQuasilinear >

class	MatrixTranslatorGeneral

class	MatrixTranslatorGeneral< ODESystemTag::FirstOrderImplicitQuasilinear >

class	NonlinearSolverBase

class	NonlinearSolver

class	NonlinearSolver< NonlinearSolverTag::Newton >

class	NonlinearSolver< NonlinearSolverTag::Picard >

struct	NonlinearSolverStatus
	Status of the non-linear solver. More...

class	NonlinearSystem

class	NonlinearSystem< NonlinearSolverTag::Newton >

class	NonlinearSystem< NonlinearSolverTag::Picard >

class	ODESystem

class	ODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Picard >

class	ODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Newton >

class	PETScNonlinearSolver

class	TimeDiscretization

class	BackwardEuler
	Backward Euler scheme. More...

class	TimeDiscretizedODESystemBase

class	TimeDiscretizedODESystem

class	TimeDiscretizedODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Newton >

class	TimeDiscretizedODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Picard >

class	EvolutionaryPIDcontroller

class	FixedTimeStepping
	Fixed time stepping algorithm. More...

class	IterationNumberBasedTimeStepping
	Iteration number based adaptive time stepping. More...

class	TimeStepAlgorithm
	Interface of time stepping algorithms. More...

class	TimeStep
	Time step object. More...

Enumerations
enum class	ComponentOrder { BY_COMPONENT , BY_LOCATION }
	Ordering of components in global matrix/vector. More...

enum class	ShapeMatrixType { N , DNDR , N_J , DNDR_J , DNDX , ALL }
	Shape matrix type to be calculated. More...

enum class	IterationResult : char { SUCCESS , FAILURE , REPEAT_ITERATION }
	Status flags telling the NonlinearSolver if an iteration succeeded. More...

enum class	NonlinearSolverTag : bool { Picard , Newton }
	Tag used to specify which nonlinear solver will be used. More...

enum class	ODESystemTag : char { FirstOrderImplicitQuasilinear , NeumannBC }
	Tag used to specify the type of ODE. More...

Functions
NewtonRaphsonSolverParameters	createNewtonRaphsonSolverParameters (BaseLib::ConfigTree const &config)

GlobalSparsityPattern	computeSparsityPattern (LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh)
	Computes a sparsity pattern for the given inputs. More...

double	getNonGhostNodalValue (GlobalVector const &x, MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const node_id, std::size_t const global_component_id)

double	getNodalValue (GlobalVector const &x, MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const node_id, std::size_t const global_component_id)

std::vector< GlobalIndexType >	getIndices (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)

NumLib::LocalToGlobalIndexMap::RowColumnIndices	getRowColumnIndices (std::size_t const id, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< GlobalIndexType > &indices)

double	norm (GlobalVector const &x, unsigned const global_component, MathLib::VecNormType norm_type, LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh)

template<typename Functor >
void	transformVariableFromGlobalVector (GlobalVector const &input_vector, int const variable_id, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, MeshLib::PropertyVector< double > &output_vector, Functor mapFunction)

void	cleanupGlobalMatrixProviders ()

std::ostream &	operator<< (std::ostream &os, LocalToGlobalIndexMap const &map)

template<typename LocalAssemblerCollection , typename IntegrationPointValuesMethod >
ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection >	makeExtrapolatable (LocalAssemblerCollection const &local_assemblers, IntegrationPointValuesMethod integration_point_values_method)

template<class T_N , class T_DNDR , class T_J , class T_DNDX >
std::ostream &	operator<< (std::ostream &os, const ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape)

template<typename ShapeFunction , typename ShapeMatricesType >
NumLib::TemplateIsoparametric< ShapeFunction, ShapeMatricesType >	createIsoparametricFiniteElement (MeshLib::Element const &e)

template<typename ShapeFunction , typename ShapeMatricesType , int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename PointContainer >
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > >	computeShapeMatrices (MeshLib::Element const &e, bool const is_axially_symmetric, PointContainer const &points)

template<typename ShapeFunction , typename ShapeMatricesType , int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename IntegrationMethod >
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > >	initShapeMatrices (MeshLib::Element const &e, bool const is_axially_symmetric, IntegrationMethod const &integration_method)

template<typename ShapeFunction , typename ShapeMatricesType >
double	interpolateXCoordinate (MeshLib::Element const &e, typename ShapeMatricesType::ShapeMatrices::ShapeType const &N)

template<typename ShapeFunction , typename ShapeMatricesType >
std::array< double, 3 >	interpolateCoordinates (MeshLib::Element const &e, typename ShapeMatricesType::ShapeMatrices::ShapeType const &N)

template<typename NodalValues , typename ShapeMatrix , typename... ScalarTypes>
void	shapeFunctionInterpolate (const NodalValues &nodal_values, const ShapeMatrix &shape_matrix_N, double &interpolated_value, ScalarTypes &... interpolated_values)

template<typename LowerOrderShapeFunction , typename HigherOrderMeshElementType , int GlobalDim, typename EigenMatrixType >
void	interpolateToHigherOrderNodes (MeshLib::Element const &element, bool const is_axially_symmetric, Eigen::MatrixBase< EigenMatrixType > const &node_values, MeshLib::PropertyVector< double > &interpolated_values_global_vector)

std::unique_ptr< ConvergenceCriterion >	createConvergenceCriterion (BaseLib::ConfigTree const &config)
	Creates a convergence criterion from the given configuration. More...

bool	checkRelativeTolerance (const double reltol, const double numerator, const double denominator)

std::unique_ptr< ConvergenceCriterionDeltaX >	createConvergenceCriterionDeltaX (const BaseLib::ConfigTree &config)

std::unique_ptr< ConvergenceCriterionPerComponentDeltaX >	createConvergenceCriterionPerComponentDeltaX (const BaseLib::ConfigTree &config)

std::unique_ptr< ConvergenceCriterionPerComponentResidual >	createConvergenceCriterionPerComponentResidual (const BaseLib::ConfigTree &config)

std::unique_ptr< ConvergenceCriterionResidual >	createConvergenceCriterionResidual (const BaseLib::ConfigTree &config)

template<ODESystemTag ODETag>
std::unique_ptr< MatrixTranslator< ODETag > >	createMatrixTranslator (TimeDiscretization const &timeDisc)

std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag >	createNonlinearSolver (GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)

std::unique_ptr< TimeDiscretization >	createTimeDiscretization (BaseLib::ConfigTree const &config)

std::unique_ptr< TimeStepAlgorithm >	createEvolutionaryPIDcontroller (BaseLib::ConfigTree const &config)

std::unique_ptr< TimeStepAlgorithm >	createFixedTimeStepping (BaseLib::ConfigTree const &config)

std::unique_ptr< TimeStepAlgorithm >	createIterationNumberBasedTimeStepping (BaseLib::ConfigTree const &config)

double	possiblyClampDtToNextFixedTime (double const t, double const dt, std::vector< double > const &fixed_output_times)

std::unique_ptr< TimeStepAlgorithm >	createTimeStepper (BaseLib::ConfigTree const &config)

Enumeration Type Documentation

◆ ComponentOrder

enum NumLib::ComponentOrder

strong

Ordering of components in global matrix/vector.

Enumerator
BY_COMPONENT	Ordering data by component type.
BY_LOCATION	Ordering data by spatial location.

Definition at line 22 of file MeshComponentMap.h.

 {
     BY_COMPONENT,  
     BY_LOCATION    
 };

◆ ShapeMatrixType

enum NumLib::ShapeMatrixType

strong

Shape matrix type to be calculated.

Enumerator
N	calculates N
DNDR	calculates dNdr
N_J	calculates N, dNdr, J, and detJ
DNDR_J	calculates dNdr, J, and detJ
DNDX	calculates dNdr, J, detJ, invJ, and dNdx
ALL	calculates all

Definition at line 23 of file ShapeMatrices.h.

 {
     N,       
     DNDR,    
     N_J,     
     DNDR_J,  
     DNDX,    
     ALL      
 };

Function Documentation

◆ checkRelativeTolerance()

bool NumLib::checkRelativeTolerance	(	double const	reltol,
		double const	numerator,
		double const	denominator
	)

Returns if |numerator/denominator| < |reltol|. This method copes with the case that denominator = 0 by always adding epsilon to the denominator.

Definition at line 48 of file ConvergenceCriterion.cpp.

 {
     auto const eps = std::numeric_limits<double>::epsilon();
     return std::abs(numerator) <
            std::abs(reltol) * (std::abs(denominator) + eps);
 }

Referenced by NumLib::ConvergenceCriterionDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkResidual(), and NumLib::ConvergenceCriterionResidual::checkResidual().

◆ cleanupGlobalMatrixProviders()

void NumLib::cleanupGlobalMatrixProviders ( )

Definition at line 34 of file GlobalMatrixProviders.cpp.

 {
     globalSetupGlobalMatrixVectorProvider.reset();
 }

Referenced by ApplicationsLib::LinearSolverLibrarySetup::~LinearSolverLibrarySetup().

◆ computeShapeMatrices()

template<typename ShapeFunction , typename ShapeMatricesType , int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename PointContainer >

std::vector<typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator<typename ShapeMatricesType::ShapeMatrices> > NumLib::computeShapeMatrices	(	MeshLib::Element const &	e,
		bool const	is_axially_symmetric,
		PointContainer const &	points
	)

Definition at line 24 of file InitShapeMatrices.h.

 {
     std::vector<
         typename ShapeMatricesType::ShapeMatrices,
         Eigen::aligned_allocator<typename ShapeMatricesType::ShapeMatrices>>
         shape_matrices;
  
     auto const fe =
         createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
  
     shape_matrices.reserve(points.size());
     for (auto const& p : points)
     {
         shape_matrices.emplace_back(ShapeFunction::DIM, e.getDimension(),
                                     ShapeFunction::NPOINTS);
         fe.template computeShapeFunctions<SelectedShapeMatrixType>(
             p.getCoords(), shape_matrices.back(), GlobalDim,
             is_axially_symmetric);
     }
  
     return shape_matrices;
 }

References MeshLib::Element::getDimension().

Referenced by NumLib::TemplateIsoparametric< ShapeFunctionType_, ShapeMatrixTypes_ >::computeShapeFunctions(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::getFlux(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, IntegrationMethod, GlobalDim >::getFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, IntegrationMethod, GlobalDim >::getFlux(), ProcessLib::HT::HTFEM< ShapeFunction, IntegrationMethod, GlobalDim >::getFlux(), initShapeMatrices(), and interpolateToHigherOrderNodes().

◆ computeSparsityPattern()

GlobalSparsityPattern NumLib::computeSparsityPattern	(	LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh
	)

Computes a sparsity pattern for the given inputs.

Parameters

dof_table	maps mesh nodes to global indices
mesh	mesh for which the two parameters above are defined

Returns: The computed sparsity pattern.

Definition at line 74 of file ComputeSparsityPattern.cpp.

 {
 #ifdef USE_PETSC
     return computeSparsityPatternPETSc(dof_table, mesh);
 #else
     return computeSparsityPatternNonPETSc(dof_table, mesh);
 #endif
 }

References computeSparsityPatternPETSc().

Referenced by ProcessLib::Process::computeSparsityPattern(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::constructDofTable(), and ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::constructDofTable().

◆ createConvergenceCriterion()

std::unique_ptr< ConvergenceCriterion > NumLib::createConvergenceCriterion ( const BaseLib::ConfigTree & config )

Creates a convergence criterion from the given configuration.

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__type

Definition at line 22 of file ConvergenceCriterion.cpp.

 {
     auto const type = config.peekConfigParameter<std::string>("type");
  
     if (type == "DeltaX")
     {
         return createConvergenceCriterionDeltaX(config);
     }
     if (type == "Residual")
     {
         return createConvergenceCriterionResidual(config);
     }
     if (type == "PerComponentDeltaX")
     {
         return createConvergenceCriterionPerComponentDeltaX(config);
     }
     if (type == "PerComponentResidual")
     {
         return createConvergenceCriterionPerComponentResidual(config);
     }
  
     OGS_FATAL("There is no convergence criterion of type `{:s}'.", type);
 }

References createConvergenceCriterionDeltaX(), createConvergenceCriterionPerComponentDeltaX(), createConvergenceCriterionPerComponentResidual(), createConvergenceCriterionResidual(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::createPerProcessData(), and ProcessLib::createTimeLoop().

◆ createConvergenceCriterionDeltaX()

std::unique_ptr< ConvergenceCriterionDeltaX > NumLib::createConvergenceCriterionDeltaX ( const BaseLib::ConfigTree & config )

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__DeltaX__abstol

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__DeltaX__reltol

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__DeltaX__norm_type

Definition at line 61 of file ConvergenceCriterionDeltaX.cpp.

 {
     config.checkConfigParameter("type", "DeltaX");
  
     auto abstol = config.getConfigParameterOptional<double>("abstol");
     auto reltol = config.getConfigParameterOptional<double>("reltol");
     auto const norm_type_str =
         config.getConfigParameter<std::string>("norm_type");
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
  
     if (norm_type == MathLib::VecNormType::INVALID)
     {
         OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
     }
  
     return std::make_unique<ConvergenceCriterionDeltaX>(
         std::move(abstol), std::move(reltol), norm_type);
 }

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionPerComponentDeltaX()

std::unique_ptr< ConvergenceCriterionPerComponentDeltaX > NumLib::createConvergenceCriterionPerComponentDeltaX ( const BaseLib::ConfigTree & config )

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__abstols

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__reltols

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__norm_type

Definition at line 91 of file ConvergenceCriterionPerComponentDeltaX.cpp.

 {
     config.checkConfigParameter("type", "PerComponentDeltaX");
  
     auto abstols =
         config.getConfigParameterOptional<std::vector<double>>("abstols");
     auto reltols =
         config.getConfigParameterOptional<std::vector<double>>("reltols");
     auto const norm_type_str =
         config.getConfigParameter<std::string>("norm_type");
  
     if ((!abstols) && (!reltols))
     {
         OGS_FATAL(
             "At least one of absolute or relative tolerance has to be "
             "specified.");
     }
     if (!abstols)
     {
         abstols = std::vector<double>(reltols->size());
     }
     else if (!reltols)
     {
         reltols = std::vector<double>(abstols->size());
     }
  
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
  
     if (norm_type == MathLib::VecNormType::INVALID)
     {
         OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
     }
  
     return std::make_unique<ConvergenceCriterionPerComponentDeltaX>(
         std::move(*abstols), std::move(*reltols), norm_type);
 }

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionPerComponentResidual()

std::unique_ptr< ConvergenceCriterionPerComponentResidual > NumLib::createConvergenceCriterionPerComponentResidual ( const BaseLib::ConfigTree & config )

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__abstols

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__reltols

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__norm_type

Definition at line 128 of file ConvergenceCriterionPerComponentResidual.cpp.

 {
     config.checkConfigParameter("type", "PerComponentResidual");
  
     auto abstols =
         config.getConfigParameterOptional<std::vector<double>>("abstols");
     auto reltols =
         config.getConfigParameterOptional<std::vector<double>>("reltols");
     auto const norm_type_str =
         config.getConfigParameter<std::string>("norm_type");
  
     if ((!abstols) && (!reltols))
     {
         OGS_FATAL(
             "At least one of absolute or relative tolerance has to be "
             "specified.");
     }
     if (!abstols)
     {
         abstols = std::vector<double>(reltols->size());
     }
     else if (!reltols)
     {
         reltols = std::vector<double>(abstols->size());
     }
  
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
  
     if (norm_type == MathLib::VecNormType::INVALID)
     {
         OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
     }
  
     return std::make_unique<ConvergenceCriterionPerComponentResidual>(
         std::move(*abstols), std::move(*reltols), norm_type);
 }

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionResidual()

std::unique_ptr< ConvergenceCriterionResidual > NumLib::createConvergenceCriterionResidual ( const BaseLib::ConfigTree & config )

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__Residual__abstol

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__Residual__reltol

Input File Parameter:: prj__time_loop__processes__process__convergence_criterion__Residual__norm_type

Definition at line 95 of file ConvergenceCriterionResidual.cpp.

 {
     config.checkConfigParameter("type", "Residual");
  
     auto abstol = config.getConfigParameterOptional<double>("abstol");
     auto reltol = config.getConfigParameterOptional<double>("reltol");
     auto const norm_type_str =
         config.getConfigParameter<std::string>("norm_type");
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
  
     if (norm_type == MathLib::VecNormType::INVALID)
     {
         OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
     }
  
     return std::make_unique<ConvergenceCriterionResidual>(
         std::move(abstol), std::move(reltol), norm_type);
 }

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createEvolutionaryPIDcontroller()

std::unique_ptr< TimeStepAlgorithm > NumLib::createEvolutionaryPIDcontroller ( BaseLib::ConfigTree const & config )

Create an EvolutionaryPIDcontroller time stepper from the given configuration

Input File Parameter:: prj__time_loop__processes__process__time_stepping__type

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__t_initial

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__t_end

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_guess

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_min

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_max

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__rel_dt_min

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__rel_dt_max

Input File Parameter:: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__tol

Definition at line 22 of file CreateEvolutionaryPIDcontroller.cpp.

 {
     config.checkConfigParameter("type", "EvolutionaryPIDcontroller");
  
     auto const t0 = config.getConfigParameter<double>("t_initial");
     auto const t_end = config.getConfigParameter<double>("t_end");
     auto const h0 = config.getConfigParameter<double>("dt_guess");
  
     auto const h_min = config.getConfigParameter<double>("dt_min");
     auto const h_max = config.getConfigParameter<double>("dt_max");
     auto const rel_h_min = config.getConfigParameter<double>("rel_dt_min");
     auto const rel_h_max = config.getConfigParameter<double>("rel_dt_max");
  
     auto const tol = config.getConfigParameter<double>("tol");
  
     return std::make_unique<EvolutionaryPIDcontroller>(
         t0, t_end, h0, h_min, h_max, rel_h_min, rel_h_max, tol);
 }

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

Referenced by createTimeStepper().

◆ createFixedTimeStepping()

std::unique_ptr< TimeStepAlgorithm > NumLib::createFixedTimeStepping ( BaseLib::ConfigTree const & config )

Create a FixedTimeStepping time stepper from the given configuration

Input File Parameter:: prj__time_loop__processes__process__time_stepping__type

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__t_initial

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__t_end

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair__repeat

Input File Parameter:: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair__delta_t

Definition at line 24 of file CreateFixedTimeStepping.cpp.

 {
     config.checkConfigParameter("type", "FixedTimeStepping");
  
     auto const t_initial = config.getConfigParameter<double>("t_initial");
     auto const t_end = config.getConfigParameter<double>("t_end");
     auto const delta_ts = config.getConfigSubtree("timesteps");
  
     std::vector<double> timesteps;
     double t_curr = t_initial;
     double delta_t = 0.0;
  
     // TODO: consider adding call "listNonEmpty" to config tree
     auto const range = delta_ts.getConfigSubtreeList("pair");
     if (range.begin() == range.end())
     {
         OGS_FATAL("no timesteps have been given");
     }
     for (auto const pair : range)
     {
         auto const repeat = pair.getConfigParameter<std::size_t>("repeat");
         delta_t = pair.getConfigParameter<double>("delta_t");
  
         if (repeat == 0)
         {
             OGS_FATAL("<repeat> is zero.");
         }
         if (delta_t <= 0.0)
         {
             OGS_FATAL("timestep <delta_t> is <= 0.0.");
         }
  
         if (t_curr <= t_end)
         {
             auto const new_size = timesteps.size() + repeat;
             try
             {
                 timesteps.resize(new_size, delta_t);
             }
             catch (std::length_error const& e)
             {
                 OGS_FATAL(
                     "Resize of the time steps vector failed for the requested "
                     "new size {:d}. Probably there is not enough memory ({:g} "
                     "GiB requested).\n"
                     "Thrown exception: {:s}",
                     new_size,
                     new_size * sizeof(double) / 1024. / 1024. / 1024.,
                     e.what());
             }
             catch (std::bad_alloc const& e)
             {
                 OGS_FATAL(
                     "Resize of the time steps vector failed for the requested "
                     "new size {:d}. Probably there is not enough memory ({:g} "
                     "GiB requested).\n"
                     "Thrown exception: {:s}",
                     new_size, new_size * sizeof(double) / 1024. / 1024. / 1024.,
                     e.what());
             }
  
             t_curr += repeat * delta_t;
         }
     }
  
     // append last delta_t until t_end is reached
     if (t_curr <= t_end)
     {
         auto const repeat =
             static_cast<std::size_t>(std::ceil((t_end - t_curr) / delta_t));
         auto const new_size = timesteps.size() + repeat;
         try
         {
             timesteps.resize(new_size, delta_t);
         }
         catch (std::length_error const& e)
         {
             OGS_FATAL(
                 "Resize of the time steps vector failed for the requested new "
                 "size {:d}. Probably there is not enough memory ({:g} GiB "
                 "requested).\n"
                 "Thrown exception: {:s}",
                 new_size,
                 new_size * sizeof(double) / 1024. / 1024. / 1024.,
                 e.what());
         }
         catch (std::bad_alloc const& e)
         {
             OGS_FATAL(
                 "Resize of the time steps vector failed for the requested new "
                 "size {:d}. Probably there is not enough memory ({:g} GiB "
                 "requested).\n"
                 "Thrown exception: {:s}",
                 new_size, new_size * sizeof(double) / 1024. / 1024. / 1024.,
                 e.what());
         }
     }
  
     return std::make_unique<FixedTimeStepping>(t_initial, t_end, timesteps);
 }

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

Referenced by createTimeStepper().

◆ createIsoparametricFiniteElement()

template<typename ShapeFunction , typename ShapeMatricesType >

NumLib::TemplateIsoparametric<ShapeFunction, ShapeMatricesType> NumLib::createIsoparametricFiniteElement ( MeshLib::Element const & e )

Creates a TemplateIsoparametric element for the given shape functions and the underlying mesh element.

Definition at line 168 of file TemplateIsoparametric.h.

 {
     using FemType =
         NumLib::TemplateIsoparametric<ShapeFunction, ShapeMatricesType>;
  
     return FemType{
         *static_cast<const typename ShapeFunction::MeshElement*>(&e)};
 }

Referenced by ProcessLib::PythonBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), and ProcessLib::SourceTerms::Python::PythonSourceTermLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble().

◆ createIterationNumberBasedTimeStepping()

std::unique_ptr< TimeStepAlgorithm > NumLib::createIterationNumberBasedTimeStepping ( BaseLib::ConfigTree const & config )

Create a IterationNumberBasedTimeStepping time stepper from the given configuration.

Input File Parameter:: prj__time_loop__processes__process__time_stepping__type

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__t_initial

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__t_end

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__initial_dt

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__minimum_dt

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__maximum_dt

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__number_iterations

Input File Parameter:: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__multiplier

Definition at line 22 of file CreateIterationNumberBasedTimeStepping.cpp.

 {
     config.checkConfigParameter("type", "IterationNumberBasedTimeStepping");
  
     auto const t_initial = config.getConfigParameter<double>("t_initial");
     auto const t_end = config.getConfigParameter<double>("t_end");
     auto const initial_dt = config.getConfigParameter<double>("initial_dt");
     auto const minimum_dt = config.getConfigParameter<double>("minimum_dt");
     auto const maximum_dt = config.getConfigParameter<double>("maximum_dt");
  
     auto number_iterations =
         config.getConfigParameter<std::vector<int>>("number_iterations");
     auto multiplier =
         config.getConfigParameter<std::vector<double>>("multiplier");
  
     return std::make_unique<IterationNumberBasedTimeStepping>(
         t_initial, t_end, minimum_dt, maximum_dt, initial_dt,
         std::move(number_iterations), std::move(multiplier));
 }

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

Referenced by createTimeStepper().

◆ createNewtonRaphsonSolverParameters()

NewtonRaphsonSolverParameters NumLib::createNewtonRaphsonSolverParameters ( BaseLib::ConfigTree const & config )

Input File Parameter:: nonlinear_solver__maximum_iterations

Input File Parameter:: nonlinear_solver__error_tolerance

Input File Parameter:: nonlinear_solver__residuum_tolerance

Input File Parameter:: nonlinear_solver__increment_tolerance

Definition at line 17 of file CreateNewtonRaphsonSolverParameters.cpp.

 {
     DBUG("Create local nonlinear solver parameters.");
     auto const maximum_iterations =
         config.getConfigParameter<int>("maximum_iterations");
  
     DBUG("\tmaximum_iterations: {:d}.", maximum_iterations);
  
     auto const error_tolerance =
         config.getConfigParameterOptional<double>("error_tolerance");
     if (error_tolerance)
     {
         WARN(
             "The 'error_tolerance' tag for the Newton-Raphson solver is "
             "deprecated.\n"
             "Use new tags 'residuum_tolerance' and 'increment_tolerance'.\n"
             "For now we use residuum_tolerance {} and increment_tolerance 0.",
             *error_tolerance);
         return {maximum_iterations, *error_tolerance, 0};
     }
  
     auto const residuum_tolerance =
         config.getConfigParameter<double>("residuum_tolerance");
  
     DBUG("\tresiduum_tolerance: {:g}.", residuum_tolerance);
  
     auto const increment_tolerance =
         config.getConfigParameter<double>("increment_tolerance");
  
     DBUG("\tincrement_tolerance: {:g}.", increment_tolerance);
  
     return {maximum_iterations, residuum_tolerance, increment_tolerance};
 }

References DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), and WARN().

Referenced by MaterialLib::Fracture::createCoulomb(), MaterialLib::Solids::Creep::createCreepBGRa(), MaterialLib::Solids::Ehlers::createEhlers(), MaterialLib::Solids::Lubby2::createLubby2(), and ProcessLib::RichardsMechanics::createRichardsMechanicsProcess().

◆ createTimeDiscretization()

std::unique_ptr< TimeDiscretization > NumLib::createTimeDiscretization ( BaseLib::ConfigTree const & config )

Input File Parameter:: prj__time_loop__processes__process__time_discretization__type

Input File Parameter:: prj__time_loop__processes__process__time_discretization__BackwardEuler

Definition at line 19 of file TimeDiscretizationBuilder.cpp.

 {
     auto const type = config.getConfigParameter<std::string>("type");
  
     if (type == "BackwardEuler")
     {
         return std::make_unique<BackwardEuler>();
     }
     OGS_FATAL("Unrecognized time discretization type `{:s}'", type);
 }

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

Referenced by ProcessLib::createPerProcessData().

◆ createTimeStepper()

std::unique_ptr< TimeStepAlgorithm > NumLib::createTimeStepper ( BaseLib::ConfigTree const & config )

Input File Parameter:: prj__time_loop__processes__process__time_stepping__type

Input File Parameter:: prj__time_loop__processes__process__time_stepping__SingleStep

Definition at line 26 of file CreateTimeStepper.cpp.

 {
     auto const type = config.peekConfigParameter<std::string>("type");
  
     if (type == "SingleStep")
     {
         config.ignoreConfigParameter("type");
         return std::make_unique<NumLib::FixedTimeStepping>(0.0, 1.0, 1.0);
     }
     if (type == "FixedTimeStepping")
     {
         return NumLib::createFixedTimeStepping(config);
     }
     if (type == "EvolutionaryPIDcontroller")
     {
         return NumLib::createEvolutionaryPIDcontroller(config);
     }
     if (type == "IterationNumberBasedTimeStepping")
     {
         return NumLib::createIterationNumberBasedTimeStepping(config);
     }
     OGS_FATAL(
         "Unknown time stepping type: '{:s}'. The available types are: "
         "\n\tSingleStep,"
         "\n\tFixedTimeStepping,"
         "\n\tEvolutionaryPIDcontroller,",
         "\n\tIterationNumberBasedTimeStepping\n",
         type.data());
 }

References createEvolutionaryPIDcontroller(), createFixedTimeStepping(), createIterationNumberBasedTimeStepping(), BaseLib::ConfigTree::ignoreConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::createPerProcessData().

◆ getIndices()

std::vector< GlobalIndexType > NumLib::getIndices	(	std::size_t const	mesh_item_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table
	)

Returns nodal indices for the item identified by mesh_item_id from the given dof_table.

Definition at line 124 of file DOFTableUtil.cpp.

 {
     assert(dof_table.size() > mesh_item_id);
     std::vector<GlobalIndexType> indices;
  
     // Local matrices and vectors will always be ordered by component
     // no matter what the order of the global matrix is.
     for (int c = 0; c < dof_table.getNumberOfGlobalComponents(); ++c)
     {
         auto const& idcs = dof_table(mesh_item_id, c).rows;
         indices.reserve(indices.size() + idcs.size());
         indices.insert(indices.end(), idcs.begin(), idcs.end());
     }
  
     return indices;
 }

References MaterialPropertyLib::c, NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), and NumLib::LocalToGlobalIndexMap::size().

◆ getNodalValue()

double NumLib::getNodalValue	(	GlobalVector const &	x,
		MeshLib::Mesh const &	mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	node_id,
		std::size_t const	global_component_id
	)

Returns the value for the given node_id and global_component_id from the vector x.

Definition at line 110 of file DOFTableUtil.cpp.

 {
     MeshLib::Location const l{mesh.getID(), MeshLib::MeshItemType::Node,
                               node_id};
  
     auto const index = dof_table.getGlobalIndex(l, global_component_id);
     assert(index != NumLib::MeshComponentMap::nop);
  
     return x.get(index);
 }

References MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), MeshLib::Node, and NumLib::MeshComponentMap::nop.

Referenced by ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), and ProcessLib::TES::TESProcess::computeVapourPartialPressure().

◆ getNonGhostNodalValue()

double NumLib::getNonGhostNodalValue	(	GlobalVector const &	x,
		MeshLib::Mesh const &	mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	node_id,
		std::size_t const	global_component_id
	)

Returns the value for the given node_id and global_component_id from the vector x in case the node is not a ghost node. Else 0.0 is returned.

Definition at line 91 of file DOFTableUtil.cpp.

 {
     MeshLib::Location const l{mesh.getID(), MeshLib::MeshItemType::Node,
                               node_id};
  
     auto const index = dof_table.getGlobalIndex(l, global_component_id);
     assert(index != NumLib::MeshComponentMap::nop);
  
     if (index < 0)
     {  // ghost node value
         return 0.0;
     }
  
     return x.get(index);
 }

References MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), MeshLib::Node, and NumLib::MeshComponentMap::nop.

Referenced by NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm().

◆ getRowColumnIndices()

LocalToGlobalIndexMap::RowColumnIndices NumLib::getRowColumnIndices	(	std::size_t const	id,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< GlobalIndexType > &	indices
	)

Returns row/column indices for the item identified by id from the given dof_table.

Definition at line 143 of file DOFTableUtil.cpp.

 {
     assert(dof_table.size() > id);
     indices.clear();
  
     // Local matrices and vectors will always be ordered by component,
     // no matter what the order of the global matrix is.
     for (int c = 0; c < dof_table.getNumberOfGlobalComponents(); ++c)
     {
         auto const& idcs = dof_table(id, c).rows;
         indices.reserve(indices.size() + idcs.size());
         indices.insert(indices.end(), idcs.begin(), idcs.end());
     }
  
     return NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices, indices);
 }

References MaterialPropertyLib::c, NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), and NumLib::LocalToGlobalIndexMap::size().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::LiquidFlow::LiquidFlowProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux(), and ProcessLib::TES::TESProcess::postIterationConcreteProcess().

◆ initShapeMatrices()

template<typename ShapeFunction , typename ShapeMatricesType , int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename IntegrationMethod >

std::vector<typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator<typename ShapeMatricesType::ShapeMatrices> > NumLib::initShapeMatrices	(	MeshLib::Element const &	e,
		bool const	is_axially_symmetric,
		IntegrationMethod const &	integration_method
	)

Definition at line 53 of file InitShapeMatrices.h.

 {
     int const n_integration_points = integration_method.getNumberOfPoints();
  
     std::vector<typename IntegrationMethod::WeightedPoint> points;
     points.reserve(n_integration_points);
     for (int ip = 0; ip < n_integration_points; ++ip)
     {
         points.push_back(integration_method.getWeightedPoint(ip));
     }
  
     return computeShapeMatrices<ShapeFunction, ShapeMatricesType, GlobalDim,
                                 SelectedShapeMatrixType>(
         e, is_axially_symmetric, points);
 }

References computeShapeMatrices().

◆ interpolateCoordinates()

template<typename ShapeFunction , typename ShapeMatricesType >

std::array<double, 3> NumLib::interpolateCoordinates	(	MeshLib::Element const &	e,
		typename ShapeMatricesType::ShapeMatrices::ShapeType const &	N
	)

Definition at line 82 of file InitShapeMatrices.h.

 {
     auto const fe =
         createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
  
     return fe.interpolateCoordinates(N);
 }

References N.

◆ interpolateToHigherOrderNodes()

template<typename LowerOrderShapeFunction , typename HigherOrderMeshElementType , int GlobalDim, typename EigenMatrixType >

void NumLib::interpolateToHigherOrderNodes	(	MeshLib::Element const &	element,
		bool const	is_axially_symmetric,
		Eigen::MatrixBase< EigenMatrixType > const &	node_values,
		MeshLib::PropertyVector< double > &	interpolated_values_global_vector
	)

Interpolates scalar node_values given in lower order element nodes (e.g. the base nodes) to higher order element's nodes (e.g. quadratic nodes) and writes the result into the global property vector.

The base nodes' values are copied. For each higher order node the shape matrices are evaluated for the lower order element (the base nodes), and used for the the scalar quantity interpolation.

Definition at line 106 of file Interpolation.h.

 {
     assert(dynamic_cast<HigherOrderMeshElementType const*>(&element));
     assert(node_values.cols() == 1);  // Scalar quantity only.
  
     using SF = LowerOrderShapeFunction;
     using ShapeMatricesType = ShapeMatrixPolicyType<SF, GlobalDim>;
  
     int const number_base_nodes = element.getNumberOfBaseNodes();
     int const number_all_nodes = element.getNumberOfNodes();
  
     // Copy the values for linear nodes.
     for (int n = 0; n < number_base_nodes; ++n)
     {
         std::size_t const global_index = getNodeIndex(element, n);
         interpolated_values_global_vector[global_index] = node_values[n];
     }
  
     //
     // Interpolate values for higher order nodes.
     //
  
     int const number_higher_order_nodes = number_all_nodes - number_base_nodes;
     std::vector<MathLib::Point3d> higher_order_nodes;
     higher_order_nodes.reserve(number_higher_order_nodes);
     for (int n = 0; n < number_higher_order_nodes; ++n)
     {
         higher_order_nodes.emplace_back(
             NaturalCoordinates<HigherOrderMeshElementType>::coordinates
                 [number_base_nodes + n]);
     }
  
     // Shape matrices evaluated at higher order nodes' coordinates.
     auto const shape_matrices =
         computeShapeMatrices<SF, ShapeMatricesType, GlobalDim,
                              ShapeMatrixType::N>(element, is_axially_symmetric,
                                                  higher_order_nodes);
  
     for (int n = 0; n < number_higher_order_nodes; ++n)
     {
         std::size_t const global_index =
             getNodeIndex(element, number_base_nodes + n);
         interpolated_values_global_vector[global_index] =
             shape_matrices[n].N * node_values;
     }
 }

References computeShapeMatrices(), MeshLib::getNodeIndex(), MeshLib::Element::getNumberOfBaseNodes(), MeshLib::Element::getNumberOfNodes(), and N.

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::StokesFlow::LocalAssemblerData< ShapeFunctionLiquidVelocity, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::computeSecondaryVariableConcrete(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::postTimestepConcreteWithBlockVectors().

◆ interpolateXCoordinate()

template<typename ShapeFunction , typename ShapeMatricesType >

double NumLib::interpolateXCoordinate	(	MeshLib::Element const &	e,
		typename ShapeMatricesType::ShapeMatrices::ShapeType const &	N
	)

Definition at line 71 of file InitShapeMatrices.h.

 {
     auto const fe =
         createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
  
     return fe.interpolateZerothCoordinate(N);
 }

References N.

◆ makeExtrapolatable()

template<typename LocalAssemblerCollection , typename IntegrationPointValuesMethod >

ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection> NumLib::makeExtrapolatable	(	LocalAssemblerCollection const &	local_assemblers,
		IntegrationPointValuesMethod	integration_point_values_method
	)

Creates an ExtrapolatableLocalAssemblerCollection, which can be used to provide information to an Extrapolator.

Definition at line 149 of file ExtrapolatableElementCollection.h.

 {
     return ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>{
         local_assemblers, integration_point_values_method};
 }

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::extrapolateIntegrationPointValuesToNodes(), and ProcessLib::makeExtrapolator().

◆ norm()

double NumLib::norm	(	GlobalVector const &	x,
		unsigned const	global_component,
		MathLib::VecNormType	norm_type,
		LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh
	)

Computes the specified norm of the given global component of the given vector x.

Remarks: x is typically the solution vector of a monolithically coupled process with several primary variables.

Definition at line 163 of file DOFTableUtil.cpp.

 {
     switch (norm_type)
     {
         case MathLib::VecNormType::NORM1:
             return norm1(x, global_component, dof_table, mesh);
         case MathLib::VecNormType::NORM2:
             return norm2(x, global_component, dof_table, mesh);
         case MathLib::VecNormType::INFINITY_N:
             return normInfinity(x, global_component, dof_table, mesh);
         default:
             OGS_FATAL("An invalid norm type has been passed.");
     }
 }

References MathLib::INFINITY_N, MathLib::NORM1, NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm1(), MathLib::NORM2, NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm2(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::normInfinity(), and OGS_FATAL.

Referenced by NumLib::ConvergenceCriterionPerComponentDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkResidual(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm1(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm2(), and NumLib::anonymous_namespace{DOFTableUtil.cpp}::normInfinity().

◆ operator<<() [1/2]

template<class T_N , class T_DNDR , class T_J , class T_DNDX >

std::ostream& NumLib::operator<<	(	std::ostream &	os,
		const ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &	shape
	)

Definition at line 129 of file ShapeMatrices-impl.h.

 {
     shape.write(os);
     return os;
 }

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::write().

◆ operator<<() [2/2]

std::ostream& NumLib::operator<<	(	std::ostream &	os,
		LocalToGlobalIndexMap const &	map
	)

Definition at line 453 of file LocalToGlobalIndexMap.cpp.

 {
     std::size_t const max_lines = 10;
     std::size_t lines_printed = 0;
  
     os << "Rows of the local to global index map; " << map._rows.size()
        << " rows\n";
     for (std::size_t e = 0; e < map.size(); ++e)
     {
         os << "== e " << e << " ==\n";
         for (int c = 0; c < map.getNumberOfGlobalComponents(); ++c)
         {
             auto const& line = map._rows(e, c);
  
             os << "c" << c << " { ";
             std::copy(line.cbegin(), line.cend(),
                       std::ostream_iterator<std::size_t>(os, " "));
             os << " }\n";
         }
  
         if (lines_printed++ > max_lines)
         {
             os << "...\n";
             break;
         }
     }
  
     os << "Mesh component map:\n" << map._mesh_component_map;
     return os;
 }

◆ possiblyClampDtToNextFixedTime()

double NumLib::possiblyClampDtToNextFixedTime	(	double const	t,
		double const	dt,
		std::vector< double > const &	fixed_output_times
	)

If any of the fixed times will be reached with given time increment, it will be reduced, otherwise the input will be returned.

Precondition: The input vector of fixed times must be sorted.

Parameters

t	Current time.
dt	Suggested time increment.
fixed_output_times	Sorted list of times which are to be reached.

Definition at line 17 of file TimeStepAlgorithm.cpp.

 {
     auto const specific_time = std::upper_bound(
         std::cbegin(fixed_output_times), std::cend(fixed_output_times), t);
  
     if (specific_time == std::cend(fixed_output_times))
     {
         return dt;
     }
  
     double const t_to_specific_time = *specific_time - t;
     if ((t_to_specific_time > std::numeric_limits<double>::epsilon()) &&
         (t + dt - *specific_time > 0.0))
     {
         return t_to_specific_time;
     }
  
     return dt;
 }

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

◆ shapeFunctionInterpolate()

template<typename NodalValues , typename ShapeMatrix , typename... ScalarTypes>

void NumLib::shapeFunctionInterpolate	(	const NodalValues &	nodal_values,
		const ShapeMatrix &	shape_matrix_N,
		double &	interpolated_value,
		ScalarTypes &...	interpolated_values
	)

Interpolates variables given at element nodes according to the given shape matrix.

This function simply does the usual finite-element interpolation, i.e. multiplication of nodal values with the shape function.

Parameters

nodal_values	vector of nodal values, ordered by component
shape_matrix_N	shape matrix of the point to which will be interpolated
interpolated_value	interpolated value of the first d.o.f. (output parameter)
interpolated_values	interpolated value of further d.o.f. (output parameter)

Template Parameters

NodalValues	type of the container where nodal values are stored
ShapeMatrix	type of the shape matrix \(N\).
ScalarValues	all of the types in this pack must currently be `double`.

Note: nodal_values have to be ordered by component and it is assumed that all passed d.o.f. are single-component and are interpolated using the same shape function.

Definition at line 79 of file Interpolation.h.

 {
     auto const num_nodal_dof = sizeof...(interpolated_values) + 1;
     auto const num_nodes = shape_matrix_N.size();
  
     assert(num_nodes * num_nodal_dof ==
            static_cast<std::size_t>(nodal_values.size()));
     (void)num_nodal_dof;
     (void)num_nodes;  // no warnings when not in debug build
  
     detail::shapeFunctionInterpolate<0>(nodal_values, shape_matrix_N,
                                         interpolated_value,
                                         interpolated_values...);
 }

◆ transformVariableFromGlobalVector()

template<typename Functor >

void NumLib::transformVariableFromGlobalVector	(	GlobalVector const &	input_vector,
		int const	variable_id,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		MeshLib::PropertyVector< double > &	output_vector,
		Functor	mapFunction
	)

Copies part of a global vector for the given variable into output_vector while applying a function to each value.

Attention: The output_vector is accessed through node id and component, therefore multiple meshes are not supported.

Definition at line 59 of file DOFTableUtil.h.

 {
     MathLib::LinAlg::setLocalAccessibleVector(input_vector);
  
     std::fill(begin(output_vector), end(output_vector),
               std::numeric_limits<double>::quiet_NaN());
  
     int const n_components =
         local_to_global_index_map.getNumberOfVariableComponents(variable_id);
     for (int component = 0; component < n_components; ++component)
     {
         auto const& mesh_subset =
             local_to_global_index_map.getMeshSubset(variable_id, component);
         auto const mesh_id = mesh_subset.getMeshID();
         for (auto const& node : mesh_subset.getNodes())
         {
             auto const node_id = node->getID();
             MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                       node_id);
             output_vector.getComponent(node_id, component) = mapFunction(
                 input_vector[local_to_global_index_map.getGlobalIndex(
                     l, variable_id, component)]);
         }
     }
 }

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::MeshSubset::getMeshID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), MeshLib::Node, and MathLib::LinAlg::setLocalAccessibleVector().

Detailed Description

Namespaces

Classes

Enumerations

Functions

Enumeration Type Documentation

◆ ComponentOrder

◆ ShapeMatrixType

Function Documentation

◆ checkRelativeTolerance()

◆ cleanupGlobalMatrixProviders()

◆ computeShapeMatrices()

◆ computeSparsityPattern()

◆ createConvergenceCriterion()

◆ createConvergenceCriterionDeltaX()

◆ createConvergenceCriterionPerComponentDeltaX()

◆ createConvergenceCriterionPerComponentResidual()

◆ createConvergenceCriterionResidual()

◆ createEvolutionaryPIDcontroller()

◆ createFixedTimeStepping()

◆ createIsoparametricFiniteElement()

◆ createIterationNumberBasedTimeStepping()

◆ createNewtonRaphsonSolverParameters()

◆ createTimeDiscretization()

◆ createTimeStepper()

◆ getIndices()

◆ getNodalValue()

◆ getNonGhostNodalValue()

◆ getRowColumnIndices()

◆ initShapeMatrices()

◆ interpolateCoordinates()

◆ interpolateToHigherOrderNodes()

◆ interpolateXCoordinate()

◆ makeExtrapolatable()

◆ norm()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ possiblyClampDtToNextFixedTime()

◆ shapeFunctionInterpolate()

◆ transformVariableFromGlobalVector()