NumLib::detail Namespace Reference

Detailed Description

Classes
struct	ByComponent
struct	ByGlobalIndex
struct	ByLocation
struct	ByLocationAndComponent
struct	ComputeDerivativeWrtOneScalar_CD
struct	ComputeDerivativeWrtOneScalar_FD
struct	DefaultPerturbationStrategy
struct	FieldType
struct	IsScalar
struct	IsScalar< Eigen::Matrix< double, N, 1, Eigen::ColMajor, N, 1 > >
struct	Line
struct	LineByLocationAndComponentComparator
struct	LineByLocationComparator
struct	LowerOrderShapeFunctionOrSame
struct	LowerOrderShapeFunctionOrSame< ShapeFunction, std::void_t< typename NumLib::LowerDim< ShapeFunction >::type > >
struct	NumberOfDofs
struct	NumberOfDofs< Vectorial< ShapeFunction, Dim > >
struct	ShapeDataFieldType
struct	ShapeFunctionTraits

Typedefs
using	ComponentGlobalIndexDict
template<typename ElementTraitsLagrange >
using	GetMeshElement = typename ElementTraitsLagrange::Element
template<typename ElementTraitsLagrange >
using	GetShapeFunctionHigherOrder
template<typename ElementTraitsLagrange >
using	GetShapeFunctionLowerOrder
template<typename ShapeFunction >
using	GetShapeMatrixPolicy
template<typename ShapeMatrixPolicy >
using	GetShapeMatrix_N = typename ShapeMatrixPolicy::ShapeMatrices::ShapeType

Functions
template<typename... Ns_t, typename ElementDOFVector , int... Offsets, int... Sizes>
auto	localDOFImpl (ElementDOFVector const &x, boost::mp11::mp_list_c< int, Offsets... >, boost::mp11::mp_list_c< int, Sizes... >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::N >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::DNDR >)
static void	checkJacobianDeterminant (const double detJ, MeshLib::Element const &element)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &ele, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &ele_local_coord, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::DNDR_J >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &ele, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &ele_local_coord, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::N_J >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &ele, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &ele_local_coord, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::DNDX >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >
void	computeMappingMatrices (const MeshLib::Element &ele, const double *natural_pt, const MeshLib::ElementCoordinatesMappingLocal &ele_local_coord, T_SHAPE_MATRICES &shapemat, FieldType< ShapeMatrixType::ALL >)
template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES , ShapeMatrixType T_SHAPE_MATRIX_TYPE>
void	naturalCoordinatesMappingComputeShapeMatrices (const MeshLib::Element &ele, const double *natural_pt, T_SHAPE_MATRICES &shapemat, const unsigned global_dim)
	Used to explicitly instantiate the NaturalCoordinatesMapping class template.
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeHex20)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeHex8)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeLine2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeLine3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapePoint1)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapePrism15)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapePrism6)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapePyra13)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapePyra5)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeQuad4)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeQuad8)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeQuad9)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeTet10)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeTet4)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeTri3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN (ShapeTri6)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePoint1, 0)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine2, 1)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine3, 1)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePoint1, 1)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine2, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine3, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePoint1, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad4, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad8, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad9, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTri3, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTri6, 2)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeHex20, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeHex8, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine2, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeLine3, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePoint1, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePrism15, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePrism6, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePyra13, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapePyra5, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad4, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad8, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeQuad9, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTet10, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTet4, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTri3, 3)
	OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX (ShapeTri6, 3)
template<class T >
void	setMatrixZero (T &mat)
template<class T >
void	setVectorZero (T &vec)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::N >)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::DNDR >)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::DNDR_J >)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::N_J >)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::DNDX >)
template<class T_N , class T_DNDR , class T_J , class T_DNDX >
void	setZero (ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape, ShapeDataFieldType< ShapeMatrixType::ALL >)
template<unsigned DOFOffset, typename NodalValues , typename ShapeMatrix >
void	shapeFunctionInterpolate (const NodalValues &, const ShapeMatrix &)
template<unsigned DOFOffset, typename NodalValues , typename ShapeMatrix , typename... ScalarTypes>
void	shapeFunctionInterpolate (const NodalValues &nodal_values, const ShapeMatrix &shape_matrix_N, double &interpolated_value, ScalarTypes &... interpolated_values)
template<std::size_t IndexInTuple, typename Tuple >
double	getScalarOrVectorComponent (Tuple const &tuple, Eigen::Index component)
template<typename MeshElementType , typename IPData , typename FluxVectorType , typename Derived >
void	assembleAdvectionMatrix (IPData const &ip_data_vector, NumLib::ShapeMatrixCache const &shape_matrix_cache, std::vector< FluxVectorType > const &ip_flux_vector, Eigen::MatrixBase< Derived > &laplacian_matrix)
template<typename IPData , typename FluxVectorType , typename Derived >
void	assembleAdvectionMatrix (IPData const &ip_data_vector, std::vector< FluxVectorType > const &ip_flux_vector, Eigen::MatrixBase< Derived > &laplacian_matrix)
template<typename Derived >
void	applyFullUpwind (Eigen::VectorXd const &quasi_nodal_flux, Eigen::MatrixBase< Derived > &laplacian_matrix)
template<typename IPData , typename FluxVectorType , typename Derived >
void	applyFullUpwind (IPData const &ip_data_vector, std::vector< FluxVectorType > const &ip_flux_vector, Eigen::MatrixBase< Derived > &laplacian_matrix)
template<typename MatrixVectorType >
std::unique_ptr< MatrixVectorType >	newZeroedInstance (MathLib::MatrixSpecifications const &matrix_specification)
void	calculateFluxCorrectedTransport (const double t, const double dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, const MathLib::MatrixSpecifications &matrix_specification, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)
Eigen::MatrixXd	getHydrodynamicDispersion (Eigen::MatrixXd const &pore_diffusion_coefficient, Eigen::VectorXd const &velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal)
Eigen::MatrixXd	getHydrodynamicDispersionWithArtificialDiffusion (IsotropicDiffusionStabilization const &stabilizer, std::size_t const element_id, Eigen::MatrixXd const &pore_diffusion_coefficient, Eigen::VectorXd const &velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal)
bool	solvePicard (GlobalLinearSolver &linear_solver, GlobalMatrix &A, GlobalVector &rhs, GlobalVector &x, MathLib::LinearSolverBehaviour const linear_solver_behaviour)

Typedef Documentation

ComponentGlobalIndexDict

using NumLib::detail::ComponentGlobalIndexDict

Initial value:

 boost::multi_index::multi_index_container<
    Line, boost::multi_index::indexed_by<
              boost::multi_index::ordered_unique<
                  boost::multi_index::tag<ByLocationAndComponent>,
                  boost::multi_index::identity<Line>,
                  LineByLocationAndComponentComparator>,
              boost::multi_index::ordered_non_unique<
                  boost::multi_index::tag<ByLocation>,
                  boost::multi_index::identity<Line>, LineByLocationComparator>,
              boost::multi_index::ordered_non_unique<
                  boost::multi_index::tag<ByComponent>,
                  boost::multi_index::member<Line, int, &Line::comp_id>>,
              boost::multi_index::ordered_non_unique<
                  boost::multi_index::tag<ByGlobalIndex>,
                  boost::multi_index::member<Line, GlobalIndexType,
                                             &Line::global_index>>>>

Definition at line 104 of file ComponentGlobalIndexDict.h.

GetMeshElement

template<typename ElementTraitsLagrange >

using NumLib::detail::GetMeshElement = typename ElementTraitsLagrange::Element

Definition at line 23 of file ShapeMatrixCache.h.

GetShapeFunctionHigherOrder

template<typename ElementTraitsLagrange >

using NumLib::detail::GetShapeFunctionHigherOrder

Initial value:

 
    typename ElementTraitsLagrange::ShapeFunction

Definition at line 26 of file ShapeMatrixCache.h.

GetShapeFunctionLowerOrder

template<typename ElementTraitsLagrange >

using NumLib::detail::GetShapeFunctionLowerOrder

Initial value:

 
    typename ElementTraitsLagrange::LowerOrderShapeFunction

Definition at line 30 of file ShapeMatrixCache.h.

GetShapeMatrix_N

template<typename ShapeMatrixPolicy >

using NumLib::detail::GetShapeMatrix_N = typename ShapeMatrixPolicy::ShapeMatrices::ShapeType

Definition at line 41 of file ShapeMatrixCache.h.

GetShapeMatrixPolicy

template<typename ShapeFunction >

using NumLib::detail::GetShapeMatrixPolicy

Initial value:

 
    
    
    
    ShapeMatrixPolicyType<ShapeFunction, 3 >

Definition at line 34 of file ShapeMatrixCache.h.

Function Documentation

applyFullUpwind() [1/2]

template<typename Derived >

void NumLib::detail::applyFullUpwind	(	Eigen::VectorXd const &	quasi_nodal_flux,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 63 of file AdvectionMatrixAssembler.h.

{
    Eigen::VectorXd const down_mask =
        (quasi_nodal_flux.array() < 0).cast<double>();
    Eigen::VectorXd const down = quasi_nodal_flux.cwiseProduct(down_mask);
 
    double const q_in = -down.sum();
    if (q_in < std::numeric_limits<double>::epsilon())
    {
        return;
    }
 
    Eigen::VectorXd const up_mask =
        (quasi_nodal_flux.array() >= 0).cast<double>();
    Eigen::VectorXd const up = quasi_nodal_flux.cwiseProduct(up_mask);
 
    laplacian_matrix.diagonal().noalias() += up;
    laplacian_matrix.noalias() += down * up.transpose() / q_in;
}

Referenced by applyFullUpwind(), NumLib::assembleAdvectionMatrix(), and NumLib::assembleAdvectionMatrix().

applyFullUpwind() [2/2]

template<typename IPData , typename FluxVectorType , typename Derived >

void NumLib::detail::applyFullUpwind	(	IPData const &	ip_data_vector,
		std::vector< FluxVectorType > const &	ip_flux_vector,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 85 of file AdvectionMatrixAssembler.h.

{
    Eigen::VectorXd quasi_nodal_flux =
        Eigen::VectorXd::Zero(laplacian_matrix.rows());
 
    for (std::size_t ip = 0; ip < ip_flux_vector.size(); ++ip)
    {
        auto const& ip_data = ip_data_vector[ip];
        auto const w = ip_data.integration_weight;
        auto const& dNdx = ip_data.dNdx;
 
        quasi_nodal_flux.noalias() -= ip_flux_vector[ip].transpose() * dNdx * w;
    }
 
    applyFullUpwind(quasi_nodal_flux, laplacian_matrix);
}

References applyFullUpwind().

assembleAdvectionMatrix() [1/2]

template<typename MeshElementType , typename IPData , typename FluxVectorType , typename Derived >

void NumLib::detail::assembleAdvectionMatrix	(	IPData const &	ip_data_vector,
		NumLib::ShapeMatrixCache const &	shape_matrix_cache,
		std::vector< FluxVectorType > const &	ip_flux_vector,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 28 of file AdvectionMatrixAssembler.h.

{
    auto const& Ns = shape_matrix_cache.NsHigherOrder<MeshElementType>();
 
    for (std::size_t ip = 0; ip < ip_flux_vector.size(); ++ip)
    {
        auto const& ip_data = ip_data_vector[ip];
        auto const w = ip_data.integration_weight;
        auto const& dNdx = ip_data.dNdx;
        auto const& N = Ns[ip];
        laplacian_matrix.noalias() +=
            N.transpose() * ip_flux_vector[ip].transpose() * dNdx * w;
    }
}

References NumLib::N, and NumLib::ShapeMatrixCache::NsHigherOrder().

Referenced by NumLib::assembleAdvectionMatrix(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleComponentTransportEquation(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian().

assembleAdvectionMatrix() [2/2]

template<typename IPData , typename FluxVectorType , typename Derived >

void NumLib::detail::assembleAdvectionMatrix	(	IPData const &	ip_data_vector,
		std::vector< FluxVectorType > const &	ip_flux_vector,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 47 of file AdvectionMatrixAssembler.h.

{
    for (std::size_t ip = 0; ip < ip_flux_vector.size(); ++ip)
    {
        auto const& ip_data = ip_data_vector[ip];
        auto const w = ip_data.integration_weight;
        auto const& N = ip_data.N;
        auto const& dNdx = ip_data.dNdx;
        laplacian_matrix.noalias() +=
            N.transpose() * ip_flux_vector[ip].transpose() * dNdx * w;
    }
}

References NumLib::N.

calculateFluxCorrectedTransport()

void NumLib::detail::calculateFluxCorrectedTransport	(	const double	t,
		const double	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id,
		const MathLib::MatrixSpecifications &	matrix_specification,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b )

Definition at line 34 of file FluxCorrectedTransport.h.

{
#ifndef USE_PETSC
    auto D = newZeroedInstance<GlobalMatrix>(matrix_specification);
    auto F = newZeroedInstance<GlobalMatrix>(matrix_specification);
 
    // compute artificial diffusion operator D
    using RawMatrixType = Eigen::SparseMatrix<double, Eigen::RowMajor>;
    auto& K_raw = K.getRawMatrix();
    K_raw *= -1;
    for (int k = 0; k < K_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(K_raw, k); it; ++it)
        {
            if (it.row() != it.col())
            {
                double const kij = it.value();
                double const kji = K.get(it.col(), it.row());
                double const dij = std::max({-kij, 0., -kji});
                D->setValue(it.row(), it.col(), dij);
            }
        }
    }
    auto& D_raw = D->getRawMatrix();
    D_raw -= (D_raw * Eigen::VectorXd::Ones(D_raw.cols())).eval().asDiagonal();
 
    // compute F
    for (int k = 0; k < D_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(D_raw, k); it; ++it)
        {
            double const dij = it.value();
            double const xj = x[process_id]->get(it.col());
            double const xi = x[process_id]->get(it.row());
            double const fij = -dij * (xj - xi);
            F->setValue(it.row(), it.col(), fij);
        }
    }
 
    auto& M_raw = M.getRawMatrix();
    for (int k = 0; k < M_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(M_raw, k); it; ++it)
        {
            double const mij = it.value();
            double const xdotj = (x[process_id]->get(it.col()) -
                                  x_prev[process_id]->get(it.col())) /
                                 dt;
            double const xdoti = (x[process_id]->get(it.row()) -
                                  x_prev[process_id]->get(it.row())) /
                                 dt;
            double const fij = -mij * (xdotj - xdoti);
            F->add(it.row(), it.col(), fij);
        }
    }
 
    auto P_plus = newZeroedInstance<GlobalVector>(matrix_specification);
    auto P_minus = newZeroedInstance<GlobalVector>(matrix_specification);
    auto Q_plus = newZeroedInstance<GlobalVector>(matrix_specification);
    auto Q_minus = newZeroedInstance<GlobalVector>(matrix_specification);
    auto R_plus = newZeroedInstance<GlobalVector>(matrix_specification);
    auto R_minus = newZeroedInstance<GlobalVector>(matrix_specification);
 
    auto& F_raw = F->getRawMatrix();
    for (int k = 0; k < F_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it)
        {
            if (it.row() != it.col())
            {
                double const fij = it.value();
                P_plus->add(it.row(), std::max(0., fij));
                P_minus->add(it.row(), std::min(0., fij));
 
                double const x_prev_i = x_prev[process_id]->get(it.row());
                double const x_prev_j = x_prev[process_id]->get(it.col());
 
                double const Q_plus_i = Q_plus->get(it.row());
                double Q_plus_i_tmp =
                    std::max({Q_plus_i, 0., x_prev_j - x_prev_i});
                Q_plus->set(it.row(), Q_plus_i_tmp);
 
                double const Q_minus_i = Q_minus->get(it.row());
                double Q_minus_i_tmp =
                    std::min({Q_minus_i, 0., x_prev_j - x_prev_i});
                Q_minus->set(it.row(), Q_minus_i_tmp);
            }
        }
    }
 
    Eigen::VectorXd const M_L =
        (M_raw * Eigen::VectorXd::Ones(M_raw.cols())).eval();
    for (auto k = R_plus->getRangeBegin(); k < R_plus->getRangeEnd(); ++k)
    {
        double const mi = M_L(k);
        double const Q_plus_i = Q_plus->get(k);
        double const P_plus_i = P_plus->get(k);
 
        double const tmp =
            P_plus_i == 0. ? 0.0 : std::min(1.0, mi * Q_plus_i / dt / P_plus_i);
 
        R_plus->set(k, tmp);
    }
 
    for (auto k = R_minus->getRangeBegin(); k < R_minus->getRangeEnd(); ++k)
    {
        double const mi = M_L(k);
        double const Q_minus_i = Q_minus->get(k);
        double const P_minus_i = P_minus->get(k);
 
        double const tmp = P_minus_i == 0.
                               ? 0.0
                               : std::min(1.0, mi * Q_minus_i / dt / P_minus_i);
        R_minus->set(k, tmp);
    }
 
    auto alpha = newZeroedInstance<GlobalMatrix>(matrix_specification);
    for (int k = 0; k < F_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it)
        {
            double const fij = it.value();
            if (fij > 0.)
            {
                double const R_plus_i = R_plus->get(it.row());
                double const R_minus_j = R_minus->get(it.col());
                double const alpha_ij = std::min(R_plus_i, R_minus_j);
 
                alpha->setValue(it.row(), it.col(), alpha_ij);
            }
            else
            {
                double const R_minus_i = R_minus->get(it.row());
                double const R_plus_j = R_plus->get(it.col());
                double const alpha_ij = std::min(R_minus_i, R_plus_j);
 
                alpha->setValue(it.row(), it.col(), alpha_ij);
            }
        }
    }
 
    // compute limited antidiffusive fluxes
    for (int k = 0; k < F_raw.outerSize(); ++k)
    {
        for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it)
        {
            if (it.row() != it.col())
            {
                double const fij = it.value();
                double const alpha_ij = alpha->get(it.row(), it.col());
 
                b.add(it.row(), alpha_ij * fij);
            }
        }
    }
 
    // compute low-order operator
    K_raw += D_raw;
    K_raw *= -1;
 
    // overwrite with the lumped mass matrix
    M.setZero();
    for (int k = 0; k < M.getNumberOfRows(); ++k)
    {
        M.setValue(k, k, M_L(k));
    }
#endif  // end of ifndef USE_PETSC
}

Referenced by NumLib::computeFluxCorrectedTransport().

checkJacobianDeterminant()

static void NumLib::detail::checkJacobianDeterminant ( const double detJ, MeshLib::Element const & element )

static

Definition at line 92 of file NaturalCoordinatesMapping.cpp.

{
    if (detJ > 0)
    {  // The usual case
        return;
    }
 
    if (detJ < 0)
    {
        ERR("det J = {:g} is negative for element {:d}.",
            detJ,
            element.getID());
#ifndef NDEBUG
        std::cerr << element << "\n";
#endif  // NDEBUG
        OGS_FATAL(
            "Please check whether the node numbering of the element is correct,"
            "or additional elements (like boundary elements) are still present "
            "in the mesh.");
    }
 
    if (detJ == 0)
    {
        ERR("det J is zero for element {:d}.", element.getID());
#ifndef NDEBUG
        std::cerr << element << "\n";
#endif  // NDEBUG
        OGS_FATAL(
            "Please check whether:\n"
            "\t the element nodes may have the same coordinates,\n"
            "\t or the coordinates of all nodes are not given on the x-axis "
            "for a 1D problem or in the xy-plane in the 2D case.\n"
            "The first case can occur, if not all boundary elements"
            "were removed from the bulk mesh.");
    }
}

References ERR(), MeshLib::Element::getID(), and OGS_FATAL.

Referenced by computeMappingMatrices(), and computeMappingMatrices().

computeMappingMatrices() [1/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & , const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & , T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::DNDR >  )

inline

Definition at line 78 of file NaturalCoordinatesMapping.cpp.

{
    if constexpr (T_SHAPE_FUNC::DIM != 0)
    {
        double* const dNdr = shapemat.dNdr.data();
        T_SHAPE_FUNC::computeGradShapeFunction(natural_pt, dNdr);
    }
}

computeMappingMatrices() [2/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & , const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & , T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::N >  )

inline

Definition at line 67 of file NaturalCoordinatesMapping.cpp.

{
    T_SHAPE_FUNC::computeShapeFunction(natural_pt, shapemat.N);
}

computeMappingMatrices() [3/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & ele, const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & ele_local_coord, T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::ALL >  )

inline

Definition at line 243 of file NaturalCoordinatesMapping.cpp.

{
    computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        FieldType<ShapeMatrixType::N>());
    computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        FieldType<ShapeMatrixType::DNDX>());
}

computeMappingMatrices() [4/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & ele, const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & ele_local_coord, T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::DNDR_J >  )

inline

Definition at line 131 of file NaturalCoordinatesMapping.cpp.

{
    if constexpr (T_SHAPE_FUNC::DIM != 0)
    {
        computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
            ele,
            natural_pt,
            ele_local_coord,
            shapemat,
            FieldType<ShapeMatrixType::DNDR>());
 
        auto const dim = T_SHAPE_FUNC::DIM;
        auto const nnodes = T_SHAPE_FUNC::NPOINTS;
 
        // jacobian: J=[dx/dr dy/dr // dx/ds dy/ds]
        for (auto k = decltype(nnodes){0}; k < nnodes; k++)
        {
            const MathLib::Point3d& mapped_pt =
                ele_local_coord.getMappedCoordinates(k);
            // outer product of dNdr and mapped_pt for a particular node
            for (auto i_r = decltype(dim){0}; i_r < dim; i_r++)
            {
                for (auto j_x = decltype(dim){0}; j_x < dim; j_x++)
                {
                    shapemat.J(i_r, j_x) +=
                        shapemat.dNdr(i_r, k) * mapped_pt[j_x];
                }
            }
        }
 
        shapemat.detJ = shapemat.J.determinant();
        checkJacobianDeterminant(shapemat.detJ, ele);
    }
    else
    {
        shapemat.detJ = 1.0;
    }
}

References checkJacobianDeterminant(), and MeshLib::ElementCoordinatesMappingLocal::getMappedCoordinates().

computeMappingMatrices() [5/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & ele, const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & ele_local_coord, T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::DNDX >  )

inline

Definition at line 198 of file NaturalCoordinatesMapping.cpp.

{
    computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        FieldType<ShapeMatrixType::DNDR_J>());
    if constexpr (T_SHAPE_FUNC::DIM != 0)
    {
        checkJacobianDeterminant(shapemat.detJ, ele);
 
        // J^-1, dshape/dx
        shapemat.invJ.noalias() = shapemat.J.inverse();
 
        assert(shapemat.dNdr.rows() == ele.getDimension());
        const unsigned global_dim = ele_local_coord.getGlobalDimension();
        if (global_dim == T_SHAPE_FUNC::DIM)
        {
            shapemat.dNdx
                .template topLeftCorner<T_SHAPE_FUNC::DIM,
                                        T_SHAPE_FUNC::NPOINTS>()
                .noalias() = shapemat.invJ * shapemat.dNdr;
        }
        else
        {
            auto const& matR =
                (ele_local_coord.getRotationMatrixToGlobal().topLeftCorner(
                     global_dim, T_SHAPE_FUNC::DIM))
                    .eval();
 
            auto const invJ_dNdr = shapemat.invJ * shapemat.dNdr;
            auto const dshape_global = matR * invJ_dNdr;
            shapemat.dNdx =
                dshape_global.topLeftCorner(global_dim, T_SHAPE_FUNC::NPOINTS);
        }
    }
}

References checkJacobianDeterminant(), MeshLib::Element::getDimension(), MeshLib::ElementCoordinatesMappingLocal::getGlobalDimension(), and MeshLib::ElementCoordinatesMappingLocal::getRotationMatrixToGlobal().

computeMappingMatrices() [6/6]

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES >

void NumLib::detail::computeMappingMatrices ( const MeshLib::Element & ele, const double * natural_pt, const MeshLib::ElementCoordinatesMappingLocal & ele_local_coord, T_SHAPE_MATRICES & shapemat, FieldType< ShapeMatrixType::N_J >  )

inline

Definition at line 176 of file NaturalCoordinatesMapping.cpp.

{
    computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        FieldType<ShapeMatrixType::N>());
    computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        FieldType<ShapeMatrixType::DNDR_J>());
}

getHydrodynamicDispersion()

Eigen::MatrixXd NumLib::detail::getHydrodynamicDispersion ( Eigen::MatrixXd const & pore_diffusion_coefficient, Eigen::VectorXd const & velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal )

inline

Definition at line 21 of file HydrodynamicDispersion.h.

{
    double const velocity_magnitude = velocity.norm();
    if (velocity_magnitude == 0.0)
    {
        return porosity * pore_diffusion_coefficient;
    }
 
    auto const dim = velocity.size();
    Eigen::MatrixXd const& I(Eigen::MatrixXd::Identity(dim, dim));
    return porosity * pore_diffusion_coefficient +
           solute_dispersivity_transverse * velocity_magnitude * I +
           (solute_dispersivity_longitudinal - solute_dispersivity_transverse) /
               velocity_magnitude * velocity * velocity.transpose();
}

Referenced by NumLib::computeHydrodynamicDispersion().

getHydrodynamicDispersionWithArtificialDiffusion()

Eigen::MatrixXd NumLib::detail::getHydrodynamicDispersionWithArtificialDiffusion ( IsotropicDiffusionStabilization const & stabilizer, std::size_t const element_id, Eigen::MatrixXd const & pore_diffusion_coefficient, Eigen::VectorXd const & velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal )

inline

Definition at line 42 of file HydrodynamicDispersion.h.

{
    double const velocity_magnitude = velocity.norm();
    if (velocity_magnitude == 0.0)
    {
        return porosity * pore_diffusion_coefficient;
    }
 
    double const artificial_diffusion =
        stabilizer.computeArtificialDiffusion(element_id, velocity_magnitude);
 
    auto const dim = velocity.size();
    Eigen::MatrixXd const& I(Eigen::MatrixXd::Identity(dim, dim));
    return porosity * pore_diffusion_coefficient +
           (solute_dispersivity_transverse * velocity_magnitude +
            artificial_diffusion) *
               I +
           (solute_dispersivity_longitudinal - solute_dispersivity_transverse) /
               velocity_magnitude * velocity * velocity.transpose();
}

References NumLib::IsotropicDiffusionStabilization::computeArtificialDiffusion().

Referenced by NumLib::computeHydrodynamicDispersion().

getScalarOrVectorComponent()

template<std::size_t IndexInTuple, typename Tuple >

double NumLib::detail::getScalarOrVectorComponent	(	Tuple const &	tuple,
		Eigen::Index	component )

Definition at line 39 of file NumericalDifferentiation.h.

{
    auto const& value = std::get<IndexInTuple>(tuple);
 
    if constexpr (IsScalar<std::remove_cvref_t<decltype(value)>>::value)
    {
        return value;
    }
    else
    {
        return value[component];
    }
}

localDOFImpl()

template<typename... Ns_t, typename ElementDOFVector , int... Offsets, int... Sizes>

auto NumLib::detail::localDOFImpl	(	ElementDOFVector const &	x,
		boost::mp11::mp_list_c< int, Offsets... >	,
		boost::mp11::mp_list_c< int, Sizes... >	)

Definition at line 42 of file LocalDOF.h.

{
    static_assert(((Sizes > 0) && ...));
    static_assert(((Offsets >= 0) && ...));
 
    return std::tuple<Eigen::Map<typename MatrixPolicyType::VectorType<
        NumberOfDofs<Ns_t>::value> const>...>{{x.data() + Offsets, Sizes}...};
}

Referenced by NumLib::localDOF().

naturalCoordinatesMappingComputeShapeMatrices()

template<class T_SHAPE_FUNC , class T_SHAPE_MATRICES , ShapeMatrixType T_SHAPE_MATRIX_TYPE>

void NumLib::detail::naturalCoordinatesMappingComputeShapeMatrices	(	const MeshLib::Element &	ele,
		const double *	natural_pt,
		T_SHAPE_MATRICES &	shapemat,
		const unsigned	global_dim )

Used to explicitly instantiate the NaturalCoordinatesMapping class template.

Definition at line 267 of file NaturalCoordinatesMapping.cpp.

{
    const MeshLib::ElementCoordinatesMappingLocal ele_local_coord(ele,
                                                                  global_dim);
 
    detail::computeMappingMatrices<T_SHAPE_FUNC, T_SHAPE_MATRICES>(
        ele,
        natural_pt,
        ele_local_coord,
        shapemat,
        detail::FieldType<T_SHAPE_MATRIX_TYPE>());
}

Referenced by NumLib::NaturalCoordinatesMapping< T_SHAPE_FUNC, T_SHAPE_MATRICES >::computeShapeMatrices().

newZeroedInstance()

template<typename MatrixVectorType >

std::unique_ptr< MatrixVectorType > NumLib::detail::newZeroedInstance

(

MathLib::MatrixSpecifications const &

matrix_specification

)

Definition at line 25 of file FluxCorrectedTransport.h.

{
    auto result = MathLib::MatrixVectorTraits<MatrixVectorType>::newInstance(
        matrix_specification);
    result->setZero();
    return result;
}

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [1/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeHex20

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [2/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeHex8

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [3/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeLine2

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [4/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeLine3

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [5/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapePoint1

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [6/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapePrism15

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [7/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapePrism6

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [8/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapePyra13

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [9/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapePyra5

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [10/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeQuad4

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [11/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeQuad8

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [12/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeQuad9

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [13/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeTet10

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [14/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeTet4

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [15/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeTri3

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN() [16/16]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_DYN

(

ShapeTri6

)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [1/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeHex20	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [2/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeHex8	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [3/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine2	,
		1	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [4/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine2	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [5/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine2	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [6/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine3	,
		1	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [7/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine3	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [8/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeLine3	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [9/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePoint1	,
		0	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [10/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePoint1	,
		1	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [11/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePoint1	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [12/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePoint1	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [13/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePrism15	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [14/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePrism6	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [15/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePyra13	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [16/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapePyra5	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [17/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad4	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [18/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad4	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [19/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad8	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [20/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad8	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [21/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad9	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [22/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeQuad9	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [23/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTet10	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [24/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTet4	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [25/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTri3	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [26/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTri3	,
		3	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [27/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTri6	,
		2	)

OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX() [28/28]

NumLib::detail::OGS_INSTANTIATE_NATURAL_COORDINATES_MAPPING_FIX	(	ShapeTri6	,
		3	)

setMatrixZero()

template<class T >

void NumLib::detail::setMatrixZero

(

T &

mat

)

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

{
    // mat.setZero();
    const std::size_t n = mat.rows() * mat.cols();
    auto* v = mat.data();
    for (std::size_t i = 0; i < n; i++)
    {
        v[i] = .0;
    }
}

Referenced by setZero(), setZero(), and setZero().

setVectorZero()

template<class T >

void NumLib::detail::setVectorZero

(

T &

vec

)

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

{
    // vec.setZero();
    const std::size_t n = vec.size();
    auto* v = vec.data();
    for (std::size_t i = 0; i < n; i++)
    {
        v[i] = .0;
    }
}

Referenced by setZero().

setZero() [1/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::ALL >  )

inline

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

{
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::N>());
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDX>());
}

References setZero().

setZero() [2/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::DNDR >  )

inline

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

{
    setMatrixZero(shape.dNdr);
}

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::dNdr, and setMatrixZero().

setZero() [3/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::DNDR_J >  )

inline

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

{
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR>());
    setMatrixZero(shape.J);
    shape.detJ = .0;
    shape.integralMeasure = 0.0;
}

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::detJ, NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::integralMeasure, NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::J, setMatrixZero(), and setZero().

setZero() [4/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::DNDX >  )

inline

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

{
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR_J>());
    setMatrixZero(shape.invJ);
    setMatrixZero(shape.dNdx);
}

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::dNdx, NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::invJ, setMatrixZero(), and setZero().

setZero() [5/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::N >  )

inline

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

{
    setVectorZero(shape.N);
}

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::N, and setVectorZero().

Referenced by NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::setZero(), setZero(), setZero(), setZero(), and setZero().

setZero() [6/6]

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

void NumLib::detail::setZero ( ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > & shape, ShapeDataFieldType< ShapeMatrixType::N_J >  )

inline

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

{
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::N>());
    setZero(shape, ShapeDataFieldType<ShapeMatrixType::DNDR_J>());
}

References setZero().

shapeFunctionInterpolate() [1/2]

template<unsigned DOFOffset, typename NodalValues , typename ShapeMatrix >

void NumLib::detail::shapeFunctionInterpolate	(	const NodalValues &	,
		const ShapeMatrix &	)

See also

NumLib::shapeFunctionInterpolate()

Definition at line 27 of file Interpolation.h.

{
}

Referenced by ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::StokesFlow::LocalAssemblerData< ShapeFunctionLiquidVelocity, ShapeFunctionPressure, GlobalDim >::assemble(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::assemble(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::VariableDependentNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleHeatTransportEquation(), ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHeatTransportEquation(), ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHydraulicEquation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleReactionEquationConcrete(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::calculateIntPtDarcyVelocity(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::TES::TESLocalAssembler< ShapeFunction_, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocityLocal(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtSaturation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::initializeChemicalSystemConcrete(), ProcessLib::TES::TESLocalAssemblerInner< Traits >::preEachAssembleIntegrationPoint(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::setChemicalSystemConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::setInitialConditionsConcrete(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::setInitialConditionsConcrete().

shapeFunctionInterpolate() [2/2]

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

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

See also

NumLib::shapeFunctionInterpolate()

Definition at line 35 of file Interpolation.h.

{
    auto const num_nodes = shape_matrix_N.size();
    double iv = 0.0;
 
    for (auto n = decltype(num_nodes){0}; n < num_nodes; ++n)
    {
        iv += nodal_values[DOFOffset * num_nodes + n] * shape_matrix_N[n];
    }
 
    interpolated_value = iv;
 
    shapeFunctionInterpolate<DOFOffset + 1>(nodal_values, shape_matrix_N,
                                            interpolated_values...);
}

solvePicard()

bool NumLib::detail::solvePicard	(	GlobalLinearSolver &	linear_solver,
		GlobalMatrix &	A,
		GlobalVector &	rhs,
		GlobalVector &	x,
		MathLib::LinearSolverBehaviour const	linear_solver_behaviour )

Definition at line 57 of file NonlinearSolver.cpp.

{
    if (linear_solver_behaviour ==
            MathLib::LinearSolverBehaviour::RECOMPUTE_AND_STORE ||
        linear_solver_behaviour == MathLib::LinearSolverBehaviour::REUSE)
    {
        WARN(
            "The performance optimization to skip the linear solver compute() "
            "step is not implemented for PETSc or LIS linear solvers.");
    }
 
    BaseLib::RunTime time_linear_solver;
    time_linear_solver.start();
 
    bool const iteration_succeeded = linear_solver.solve(A, rhs, x);
 
    INFO("[time] Linear solver took {:g} s.", time_linear_solver.elapsed());
 
    if (iteration_succeeded)
    {
        return true;
    }
 
    ERR("Picard: The linear solver failed in the solve() step.");
    return false;
}

References BaseLib::RunTime::elapsed(), ERR(), INFO(), MathLib::RECOMPUTE_AND_STORE, MathLib::REUSE, MathLib::EigenLisLinearSolver::solve(), BaseLib::RunTime::start(), and WARN().

Referenced by NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::solve().