ParameterLib::CoordinateSystem Struct Reference

Detailed Description

A local coordinate system used for tensor transformations.

It offers a simple way for input of anisotropic tensors w.r.t. a coordinate system. The basis vectors form a transformation matrix \(R = (e_0, e_1, e_2)\). For a given anisotropic tensor \(A\) parameter with the corresponding [tag] use_local_coordinate_system the tensor is rotated according to the formula: \(A' = R\cdot A\cdot R^T\).

For computations in transverse isotropic material models, we can create a coordinate system with only one base, where the last base is explicitly given. The other bases are set as implicit and computed from the given base as follows:

• For a 2D coordinate system, the unit vector orthogonal to the given base is used as the first base,
• For a 3D coordinate system, the given base vector, unit_direction, is set as the third base, \({\vec e}_2\). An arbitrary unit vector orthogonal to \({\vec e}_2\) is selected as the second base \(e_1\), and the first base \({\vec e}_0\) is calculated as \({\vec e}_0 = {\vec e}_1 \times {\vec e}_2\).

Definition at line 48 of file CoordinateSystem.h.

#include <CoordinateSystem.h>

Public Member Functions
	CoordinateSystem (Parameter< double > const &unit_direction)
	CoordinateSystem (Parameter< double > const &e0, Parameter< double > const &e1)
	CoordinateSystem (Parameter< double > const &e0, Parameter< double > const &e1, Parameter< double > const &e2)
template<int Dimension>
Eigen::Matrix< double, Dimension, Dimension >	transformation (SpatialPosition const &pos) const
Eigen::Matrix< double, 3, 3 >	transformation_3d (SpatialPosition const &pos) const
template<int Dimension>
Eigen::Matrix< double, Dimension, Dimension >	rotateTensor (std::vector< double > const &values, SpatialPosition const &pos) const
template<int Dimension, typename Derived >
Eigen::Matrix< double, Dimension, Dimension >	rotateTensor (Eigen::MatrixBase< Derived > const &tensor, SpatialPosition const &pos) const
template<int Dimension>
Eigen::Matrix< double, Dimension, Dimension >	rotateDiagonalTensor (std::vector< double > const &values, SpatialPosition const &pos) const
template<>
Eigen::Matrix< double, 2, 2 >	transformation (SpatialPosition const &pos) const
template<>
Eigen::Matrix< double, 3, 3 >	transformation (SpatialPosition const &pos) const

Private Member Functions
Eigen::Matrix< double, 3, 3 >	transformationFromSingleBase_3d (SpatialPosition const &pos) const

Private Attributes
std::array< Parameter< double > const *, 3 >	_base
bool	_has_implicit_base

Constructor & Destructor Documentation

CoordinateSystem() [1/3]

ParameterLib::CoordinateSystem::CoordinateSystem ( Parameter< double > const & unit_direction )

explicit

It is used to create a local coordinate system with only one base, where the last base is explicitly given as unit_direction.

Parameters

unit_direction

The specified unit direction.

Definition at line 67 of file CoordinateSystem.cpp.

    : _base{nullptr, nullptr, &unit_direction}, _has_implicit_base(true)
{
    if (_base[2]->isTimeDependent())
    {
        OGS_FATAL(
            "The unit_normal parameter named {} must not be time dependent.",
            unit_direction.name);
    }
}

References _base, ParameterLib::ParameterBase::name, and OGS_FATAL.

CoordinateSystem() [2/3]

ParameterLib::CoordinateSystem::CoordinateSystem	(	Parameter< double > const &	e0,
		Parameter< double > const &	e1 )

Definition at line 78 of file CoordinateSystem.cpp.

    : _base{&e0, &e1, nullptr}, _has_implicit_base(false)
{
    if (typeid(_base[0]) != typeid(_base[1]))
    {
        OGS_FATAL(
            "The parameter types for the basis must be equal but they are "
            "'{:s}' and '{:s}'.",
            typeid(_base[0]).name(),
            typeid(_base[1]).name());
    }
    if (_base[0]->isTimeDependent() || _base[1]->isTimeDependent())
    {
        OGS_FATAL("The parameters for the basis must not be time dependent.");
    }
    if (_base[0]->getNumberOfGlobalComponents() != 2 ||
        _base[1]->getNumberOfGlobalComponents() != 2)
    {
        OGS_FATAL("The parameters for the 2D basis must have two components.");
    }
}

References _base, and OGS_FATAL.

CoordinateSystem() [3/3]

ParameterLib::CoordinateSystem::CoordinateSystem	(	Parameter< double > const &	e0,
		Parameter< double > const &	e1,
		Parameter< double > const &	e2 )

Definition at line 101 of file CoordinateSystem.cpp.

    : _base{&e0, &e1, &e2}, _has_implicit_base(false)
{
    if ((typeid(_base[0]) != typeid(_base[1])) ||
        (typeid(_base[1]) != typeid(_base[2])) ||
        (typeid(_base[2]) != typeid(_base[0])))
    {
        OGS_FATAL(
            "The parameter types for the basis must be equal but they are "
            "'{:s}', '{:s}', and '{:s}'.",
            typeid(_base[0]).name(),
            typeid(_base[1]).name(),
            typeid(_base[2]).name());
    }
    if (_base[0]->isTimeDependent() || _base[1]->isTimeDependent(),
        _base[2]->isTimeDependent())
    {
        OGS_FATAL("The parameters for the basis must not be time dependent.");
    }
    if (_base[0]->getNumberOfGlobalComponents() != 3 ||
        _base[1]->getNumberOfGlobalComponents() != 3 ||
        _base[2]->getNumberOfGlobalComponents() != 3)
    {
        OGS_FATAL(
            "The parameters for the 3D basis must have three components.");
    }
}

References _base, and OGS_FATAL.

Member Function Documentation

rotateDiagonalTensor()

template<int Dimension>

template Eigen::Matrix< double, 3, 3 > ParameterLib::CoordinateSystem::rotateDiagonalTensor< 3 >	(	std::vector< double > const &	values,
		SpatialPosition const &	pos ) const

Definition at line 301 of file CoordinateSystem.cpp.

{
    assert(values.size() == Dimension ||
           "Input vector has wrong dimension; expected 2 or 3 entries.");
    auto const tensor = Eigen::Map<Eigen::Matrix<double, Dimension, 1> const>(
        values.data(), Dimension, 1);
    auto const R = transformation<Dimension>(pos);
    return R * tensor.asDiagonal() * R.transpose();
}

rotateTensor() [1/2]

template<int Dimension, typename Derived >

Eigen::Matrix< double, Dimension, Dimension > ParameterLib::CoordinateSystem::rotateTensor	(	Eigen::MatrixBase< Derived > const &	tensor,
		SpatialPosition const &	pos ) const

Definition at line 93 of file CoordinateSystem.h.

{
    auto const R = transformation<Dimension>(pos);
    return R * tensor * R.transpose();
}

rotateTensor() [2/2]

template<int Dimension>

template Eigen::Matrix< double, 3, 3 > ParameterLib::CoordinateSystem::rotateTensor< 3 >	(	std::vector< double > const &	values,
		SpatialPosition const &	pos ) const

Definition at line 288 of file CoordinateSystem.cpp.

{
    assert(values.size() == Dimension * Dimension ||
           "Input vector has wrong dimension; expected 4 or 9 entries.");
    auto const tensor =
        Eigen::Map<Eigen::Matrix<double, Dimension, Dimension> const>(
            values.data(), Dimension, Dimension);
    return rotateTensor<Dimension>(tensor, pos);
}

transformation() [1/3]

template<>

Eigen::Matrix< double, 2, 2 > ParameterLib::CoordinateSystem::transformation

(

SpatialPosition const &

pos

)

const

Definition at line 131 of file CoordinateSystem.cpp.

{
    if (_has_implicit_base)
    {
        return getTransformationFromSingleBase2D(*_base[2], pos);
    }
 
    if (_base[2] != nullptr)
    {
        OGS_FATAL(
            "The coordinate system is 3D but a transformation for 2D case is "
            "requested.");
    }
 
    Eigen::Matrix<double, 2, 2> t;
    t.col(0) = Eigen::Map<Eigen::Vector2d>(
        (*_base[0])(0 /* time independent */, pos).data());
    t.col(1) = Eigen::Map<Eigen::Vector2d>(
        (*_base[1])(0 /* time independent */, pos).data());
 
    checkTransformationIsSON(t);
    return t;
}

References ParameterLib::checkNormalization(), ParameterLib::checkTransformationIsSON(), and ParameterLib::ParameterBase::name.

transformation() [2/3]

template<>

Eigen::Matrix< double, 3, 3 > ParameterLib::CoordinateSystem::transformation

(

SpatialPosition const &

pos

)

const

Definition at line 173 of file CoordinateSystem.cpp.

{
    if (_has_implicit_base)
    {
        return getTransformationFromSingleBase3D(*_base[2], pos);
    }
 
    if (_base[2] == nullptr)
    {
        OGS_FATAL(
            "The coordinate system is 2D but a transformation for 3D case is "
            "requested.");
    }
 
    Eigen::Matrix<double, 3, 3> t;
    t.col(0) = Eigen::Map<Eigen::Vector3d>(
        (*_base[0])(0 /* time independent */, pos).data());
    t.col(1) = Eigen::Map<Eigen::Vector3d>(
        (*_base[1])(0 /* time independent */, pos).data());
    t.col(2) = Eigen::Map<Eigen::Vector3d>(
        (*_base[2])(0 /* time independent */, pos).data());
 
    checkTransformationIsSON(t);
    return t;
}

References ParameterLib::checkNormalization(), ParameterLib::checkTransformationIsSON(), ParameterLib::ParameterBase::name, and ParameterLib::tolerance.

transformation() [3/3]

template<int Dimension>

Eigen::Matrix< double, Dimension, Dimension > ParameterLib::CoordinateSystem::transformation

(

SpatialPosition const &

pos

)

const

transformation_3d()

Eigen::Matrix< double, 3, 3 > ParameterLib::CoordinateSystem::transformation_3d

(

SpatialPosition const &

pos

)

const

Definition at line 265 of file CoordinateSystem.cpp.

{
    if (_has_implicit_base)
    {
        return transformationFromSingleBase_3d(pos);
    }
 
    if (_base[2] != nullptr)
    {
        return transformation<3>(pos);
    }
 
    auto e0 = (*_base[0])(0 /* time independent */, pos);
    auto e1 = (*_base[1])(0 /* time independent */, pos);
    Eigen::Matrix<double, 3, 3> t = Eigen::Matrix<double, 3, 3>::Identity();
    t.template topLeftCorner<2, 2>() << e0[0], e1[0], e0[1], e1[1];
 
    checkTransformationIsSON(t);
    return t;
}

References _base, _has_implicit_base, ParameterLib::checkTransformationIsSON(), and transformationFromSingleBase_3d().

Referenced by MaterialPropertyLib::SaturationDependentSwelling::dValue(), and MaterialPropertyLib::SaturationDependentSwelling::value().

transformationFromSingleBase_3d()

Eigen::Matrix< double, 3, 3 > ParameterLib::CoordinateSystem::transformationFromSingleBase_3d ( SpatialPosition const & pos ) const

private

Definition at line 249 of file CoordinateSystem.cpp.

{
    // If base 2, which stores the unit direction vector, has three components:
    if ((*_base[2])(0 /* time independent */, pos).size() == 3)
    {
        return getTransformationFromSingleBase3D(*_base[2], pos);
    }
 
    // If base 2, which stores the unit direction vector, has two components
    Eigen::Matrix<double, 3, 3> t = Eigen::Matrix<double, 3, 3>::Identity();
    t.template topLeftCorner<2, 2>() = transformation<2>(pos);
 
    return t;
}

References _base, and ParameterLib::getTransformationFromSingleBase3D().

Referenced by transformation_3d().

Member Data Documentation

_base

std::array<Parameter<double> const*, 3> ParameterLib::CoordinateSystem::_base

private

Definition at line 85 of file CoordinateSystem.h.

Referenced by CoordinateSystem(), CoordinateSystem(), CoordinateSystem(), transformation_3d(), and transformationFromSingleBase_3d().

_has_implicit_base

bool ParameterLib::CoordinateSystem::_has_implicit_base

private

Definition at line 86 of file CoordinateSystem.h.

Referenced by transformation_3d().

---

The documentation for this struct was generated from the following files:

• ParameterLib/CoordinateSystem.h
• ParameterLib/CoordinateSystem.cpp