ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int DisplacementDim>
class ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >

Local assembler of ThermoMechanics process.

In this assembler, the solid density can be expressed as an exponential function of temperature, if a temperature dependent solid density is assumed. The theory behind this is given below.

During the temperature variation, the solid mass balance is

\[ \rho_s^{n+1} V^{n+1} = \rho_s^n V^n, \]

with \(\rho_s\) the density, \(V\), the volume, and \(n\) the index of the time step. Under pure thermo-mechanics condition, the volume change along with the temperature change is given by

\[ V^{n+1} = V^{n} + \alpha_T dT V^{n} = (1+\alpha_T dT)V^{n}, \]

where \(\alpha_T\) is the volumetric thermal expansivity of the solid. This gives

\[ \rho_s^{n+1} + \alpha_T dT \rho_s^{n+1} = \rho_s^n. \]

Therefore, we obtain the differential expression of the temperature dependent solid density as

\[ \frac{d \rho_s}{d T} = -\alpha_T \rho_s. \]

The solution of the above ODE, i.e the density expression, is given by

\[ \rho_s = {\rho_0} \mathrm{exp} (- \alpha_T (T-T0)), \]

with reference density \(\rho_0\) at a reference temperature of \(T_0\).

An MPL property with the type of Exponential (see MaterialPropertyLib::Exponential) can be used for the temperature dependent solid property.

Definition at line 127 of file ThermoMechanicsFEM.h.

#include <ThermoMechanicsFEM.h>

Inheritance diagram for ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >:

Collaboration diagram for ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >:

Public Types
using	ShapeMatricesType
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType
using	BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>
using	Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>
using	NodalForceVectorType = typename BMatricesType::NodalForceVectorType
using	RhsVector
using	JacobianMatrix
using	IpData

Public Member Functions
	ThermoMechanicsLocalAssembler (ThermoMechanicsLocalAssembler const &)=delete
	ThermoMechanicsLocalAssembler (ThermoMechanicsLocalAssembler &&)=delete
	ThermoMechanicsLocalAssembler (MeshLib::Element const &e, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, ThermoMechanicsProcessData< DisplacementDim > &process_data)
std::size_t	setIPDataInitialConditions (std::string_view const name, double const *values, int const integration_order) override
	Returns number of read integration points.
void	assemble (double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
void	assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override
void	assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_rhs_data, std::vector< double > &local_Jac_data) override
void	initializeConcrete () override
void	setInitialConditionsConcrete (Eigen::VectorXd const local_x, double const t, int const process_id) override
void	postTimestepConcrete (Eigen::VectorXd const &, Eigen::VectorXd const &, double const, double const, int const) override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual	~LocalAssemblerInterface ()=default
virtual void	setInitialConditions (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, int const process_id)
virtual void	initialize (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
virtual void	preAssemble (double const, double const, std::vector< double > const &)
virtual void	assembleForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
virtual void	computeSecondaryVariable (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
virtual void	preTimestep (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, double const delta_t)
virtual void	postTimestep (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
void	postNonLinearSolver (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< double > const &) const
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double > > const &) const
	Fits to staggered scheme.
virtual std::optional< VectorSegment >	getVectorDeformationSegment () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Static Public Attributes
static int const	KelvinVectorSize

Private Member Functions
void	assembleWithJacobianForDeformationEquations (const double t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
void	assembleWithJacobianForHeatConductionEquations (const double t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
std::size_t	setSigma (double const *values)
std::vector< double >	getSigma () const override
std::vector< double > const &	getIntPtSigma (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::size_t	setEpsilon (double const *values)
std::vector< double >	getEpsilon () const override
std::vector< double > const &	getIntPtEpsilon (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::vector< double > const &	getIntPtEpsilonMechanical (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::size_t	setEpsilonMechanical (double const *values)
std::vector< double >	getEpsilonMechanical () const override
unsigned	getNumberOfIntegrationPoints () const override
int	getMaterialID () const override
MaterialLib::Solids::MechanicsBase< DisplacementDim >::MaterialStateVariables const &	getMaterialStateVariablesAt (unsigned integration_point) const override

Private Attributes
ThermoMechanicsProcessData< DisplacementDim > &	_process_data
std::vector< IpData, Eigen::aligned_allocator< IpData > >	_ip_data
NumLib::GenericIntegrationMethod const &	_integration_method
MeshLib::Element const &	_element
SecondaryData< typename ShapeMatrices::ShapeType >	_secondary_data
bool const	_is_axially_symmetric

Static Private Attributes
static const int	temperature_index = 0
static const int	temperature_size = ShapeFunction::NPOINTS
static const int	displacement_index = ShapeFunction::NPOINTS
static const int	displacement_size

Member Typedef Documentation

BMatricesType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 138 of file ThermoMechanicsFEM.h.

GlobalDimMatrixType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

Definition at line 137 of file ThermoMechanicsFEM.h.

Invariants

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>

Definition at line 142 of file ThermoMechanicsFEM.h.

IpData

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::IpData

Initial value:

 
        IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 150 of file ThermoMechanicsFEM.h.

JacobianMatrix

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::JacobianMatrix

Initial value:

 typename ShapeMatricesType::template MatrixType<
        ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim,
        ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim>

Definition at line 147 of file ThermoMechanicsFEM.h.

NodalForceVectorType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 144 of file ThermoMechanicsFEM.h.

RhsVector

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::RhsVector

Initial value:

 typename ShapeMatricesType::template VectorType<
        ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim>

Definition at line 145 of file ThermoMechanicsFEM.h.

ShapeMatrices

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 136 of file ThermoMechanicsFEM.h.

ShapeMatricesType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatricesType

Initial value:

 
        ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 131 of file ThermoMechanicsFEM.h.

Constructor & Destructor Documentation

ThermoMechanicsLocalAssembler() [1/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler ( ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim > const & )

delete

References ThermoMechanicsLocalAssembler().

Referenced by ThermoMechanicsLocalAssembler(), and ThermoMechanicsLocalAssembler().

ThermoMechanicsLocalAssembler() [2/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler ( ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim > && )

delete

References ThermoMechanicsLocalAssembler().

ThermoMechanicsLocalAssembler() [3/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler	(	MeshLib::Element const &	e,
		std::size_t const	,
		NumLib::GenericIntegrationMethod const &	integration_method,
		bool const	is_axially_symmetric,
		ThermoMechanicsProcessData< DisplacementDim > &	process_data )

Definition at line 27 of file ThermoMechanicsFEM-impl.h.

    : _process_data(process_data),
      _integration_method(integration_method),
      _element(e),
      _is_axially_symmetric(is_axially_symmetric)
{
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    _ip_data.reserve(n_integration_points);
    _secondary_data.N.resize(n_integration_points);
 
    auto const shape_matrices =
        NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                  DisplacementDim>(e, is_axially_symmetric,
                                                   _integration_method);
 
    auto& solid_material = MaterialLib::Solids::selectSolidConstitutiveRelation(
        _process_data.solid_materials, _process_data.material_ids, e.getID());
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        _ip_data.emplace_back(solid_material);
        auto& ip_data = _ip_data[ip];
        ip_data.integration_weight =
            _integration_method.getWeightedPoint(ip).getWeight() *
            shape_matrices[ip].integralMeasure * shape_matrices[ip].detJ;
 
        static const int kelvin_vector_size =
            MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
        // Initialize current time step values
        ip_data.sigma.setZero(kelvin_vector_size);
        ip_data.eps.setZero(kelvin_vector_size);
 
        // Previous time step values are not initialized and are set later.
        ip_data.sigma_prev.resize(kelvin_vector_size);
        ip_data.eps_prev.resize(kelvin_vector_size);
 
        ip_data.eps_m.setZero(kelvin_vector_size);
        ip_data.eps_m_prev.setZero(kelvin_vector_size);
        ParameterLib::SpatialPosition x_position;
        x_position.setElementID(_element.getID());
        ip_data.N = shape_matrices[ip].N;
        ip_data.dNdx = shape_matrices[ip].dNdx;
 
        _secondary_data.N[ip] = shape_matrices[ip].N;
    }
}

References _element, _integration_method, _ip_data, _is_axially_symmetric, _process_data, _secondary_data, MeshLib::Element::getID(), NumLib::initShapeMatrices(), MathLib::KelvinVector::kelvin_vector_dimensions(), MaterialLib::Solids::selectSolidConstitutiveRelation(), and ParameterLib::SpatialPosition::setElementID().

Member Function Documentation

assemble()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assemble ( double const , double const , std::vector< double > const & , std::vector< double > const & , std::vector< double > & , std::vector< double > & , std::vector< double > &  )

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 170 of file ThermoMechanicsFEM.h.

    {
        OGS_FATAL(
            "ThermoMechanicsLocalAssembler: assembly without jacobian is not "
            "implemented.");
    }

References OGS_FATAL.

assembleWithJacobian()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian ( double const t, double const dt, std::vector< double > const & local_x, std::vector< double > const & local_x_prev, std::vector< double > & local_rhs_data, std::vector< double > & local_Jac_data )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 149 of file ThermoMechanicsFEM-impl.h.

{
    auto const local_matrix_size = local_x.size();
    assert(local_matrix_size == temperature_size + displacement_size);
 
    auto T = Eigen::Map<typename ShapeMatricesType::template VectorType<
        temperature_size> const>(local_x.data() + temperature_index,
                                 temperature_size);
 
    auto u = Eigen::Map<typename ShapeMatricesType::template VectorType<
        displacement_size> const>(local_x.data() + displacement_index,
                                  displacement_size);
    bool const is_u_non_zero = u.norm() > 0.0;
 
    auto T_prev = Eigen::Map<typename ShapeMatricesType::template VectorType<
        temperature_size> const>(local_x_prev.data() + temperature_index,
                                 temperature_size);
 
    auto local_Jac = MathLib::createZeroedMatrix<JacobianMatrix>(
        local_Jac_data, local_matrix_size, local_matrix_size);
 
    auto local_rhs = MathLib::createZeroedVector<RhsVector>(local_rhs_data,
                                                            local_matrix_size);
 
    typename ShapeMatricesType::template MatrixType<displacement_size,
                                                    temperature_size>
        KuT;
    KuT.setZero(displacement_size, temperature_size);
 
    typename ShapeMatricesType::NodalMatrixType KTT;
    KTT.setZero(temperature_size, temperature_size);
 
    typename ShapeMatricesType::NodalMatrixType DTT;
    DTT.setZero(temperature_size, temperature_size);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    MPL::VariableArray variables;
    MPL::VariableArray variables_prev;
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    auto const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& solid_phase = medium->phase("Solid");
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        ParameterLib::SpatialPosition const x_position{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        auto const x_coord = x_position.getCoordinates().value()[0];
        auto const& B =
            LinearBMatrix::computeBMatrix<DisplacementDim,
                                          ShapeFunction::NPOINTS,
                                          typename BMatricesType::BMatrixType>(
                dNdx, N, x_coord, _is_axially_symmetric);
 
        auto& sigma = _ip_data[ip].sigma;
        auto const& sigma_prev = _ip_data[ip].sigma_prev;
 
        auto& eps = _ip_data[ip].eps;
        auto const& eps_prev = _ip_data[ip].eps_prev;
 
        auto& eps_m = _ip_data[ip].eps_m;
        auto const& eps_m_prev = _ip_data[ip].eps_m_prev;
 
        auto& state = _ip_data[ip].material_state_variables;
 
        const double T_ip = N.dot(T);  // T at integration point
        double const T_prev_ip = N.dot(T_prev);
 
        // Consider also anisotropic thermal expansion.
        auto const solid_linear_thermal_expansivity_vector =
            MPL::formKelvinVector<DisplacementDim>(
                solid_phase
                    .property(
                        MaterialPropertyLib::PropertyType::thermal_expansivity)
                    .value(variables, x_position, t, dt));
 
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim> const
            dthermal_strain =
                solid_linear_thermal_expansivity_vector * (T_ip - T_prev_ip);
 
        //
        // displacement equation, displacement part
        //
        // For the restart computation, the displacement may not be
        // reloaded but the initial strains are always available. For such case,
        // the following computation is skipped.
        if (is_u_non_zero)
        {
            eps.noalias() = B * u;
        }
 
        eps_m.noalias() = eps_m_prev + eps - eps_prev - dthermal_strain;
 
        variables_prev.stress
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                sigma_prev);
        variables_prev.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps_m_prev);
        variables_prev.temperature = T_ip;
        variables.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps_m);
        variables.temperature = T_ip;
 
        auto&& solution = _ip_data[ip].solid_material.integrateStress(
            variables_prev, variables, t, x_position, dt, *state);
 
        if (!solution)
        {
            OGS_FATAL("Computation of local constitutive relation failed.");
        }
 
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim> C;
        std::tie(sigma, state, C) = std::move(*solution);
 
        local_Jac
            .template block<displacement_size, displacement_size>(
                displacement_index, displacement_index)
            .noalias() += B.transpose() * C * B * w;
 
        typename ShapeMatricesType::template MatrixType<DisplacementDim,
                                                        displacement_size>
            N_u = ShapeMatricesType::template MatrixType<
                DisplacementDim, displacement_size>::Zero(DisplacementDim,
                                                          displacement_size);
 
        for (int i = 0; i < DisplacementDim; ++i)
        {
            N_u.template block<1, displacement_size / DisplacementDim>(
                   i, i * displacement_size / DisplacementDim)
                .noalias() = N;
        }
 
        auto const rho_s =
            solid_phase.property(MPL::PropertyType::density)
                .template value<double>(variables, x_position, t, dt);
 
        auto const& b = _process_data.specific_body_force;
        local_rhs.template block<displacement_size, 1>(displacement_index, 0)
            .noalias() -=
            (B.transpose() * sigma - N_u.transpose() * rho_s * b) * w;
 
        //
        // displacement equation, temperature part
        // The computation of KuT can be ignored.
        auto const alpha_T_tensor =
            MathLib::KelvinVector::kelvinVectorToSymmetricTensor(
                solid_linear_thermal_expansivity_vector);
        KuT.noalias() += B.transpose() * (C * alpha_T_tensor) * N * w;
 
        if (_ip_data[ip].solid_material.getConstitutiveModel() ==
            MaterialLib::Solids::ConstitutiveModel::CreepBGRa)
        {
            auto const s = Invariants::deviatoric_projection * sigma;
            double const norm_s = Invariants::FrobeniusNorm(s);
            const double creep_coefficient =
                _ip_data[ip].solid_material.getTemperatureRelatedCoefficient(
                    t, dt, x_position, T_ip, norm_s);
            KuT.noalias() += creep_coefficient * B.transpose() * s * N * w;
        }
 
        //
        // temperature equation, temperature part;
        //
        auto const lambda =
            solid_phase
                .property(
                    MaterialPropertyLib::PropertyType::thermal_conductivity)
                .value(variables, x_position, t, dt);
 
        GlobalDimMatrixType const thermal_conductivity =
            MaterialPropertyLib::formEigenTensor<DisplacementDim>(lambda);
 
        KTT.noalias() += dNdx.transpose() * thermal_conductivity * dNdx * w;
 
        auto const c =
            solid_phase
                .property(
                    MaterialPropertyLib::PropertyType::specific_heat_capacity)
                .template value<double>(variables, x_position, t, dt);
        DTT.noalias() += N.transpose() * rho_s * c * N * w;
    }
 
    // temperature equation, temperature part
    local_Jac
        .template block<temperature_size, temperature_size>(temperature_index,
                                                            temperature_index)
        .noalias() += KTT + DTT / dt;
 
    // displacement equation, temperature part
    local_Jac
        .template block<displacement_size, temperature_size>(displacement_index,
                                                             temperature_index)
        .noalias() -= KuT;
 
    local_rhs.template block<temperature_size, 1>(temperature_index, 0)
        .noalias() -= KTT * T + DTT * (T - T_prev) / dt;
}

References _element, _integration_method, _ip_data, _is_axially_symmetric, _process_data, ProcessLib::LinearBMatrix::computeBMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialLib::Solids::CreepBGRa, MaterialPropertyLib::density, MathLib::KelvinVector::Invariants< KelvinVectorSize >::deviatoric_projection, displacement_index, displacement_size, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::formKelvinVector(), MathLib::KelvinVector::Invariants< KelvinVectorSize >::FrobeniusNorm(), ParameterLib::SpatialPosition::getCoordinates(), NumLib::interpolateCoordinates(), MathLib::KelvinVector::kelvinVectorToSymmetricTensor(), MaterialPropertyLib::VariableArray::mechanical_strain, OGS_FATAL, ParameterLib::SpatialPosition::setElementID(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::VariableArray::stress, MaterialPropertyLib::VariableArray::temperature, temperature_index, temperature_size, MaterialPropertyLib::thermal_conductivity, and MaterialPropertyLib::thermal_expansivity.

assembleWithJacobianForDeformationEquations()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations ( const double t, double const dt, Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, std::vector< double > & local_b_data, std::vector< double > & local_Jac_data )

private

Assemble local matrices and vectors arise from the linearized discretized weak form of the residual of the momentum balance equation,

\[ \nabla (\sigma - \mathbf{D} \alpha_T (T-T_0) \mathrm{I}) = f \]

where \( \sigma\) is the effective stress tensor, \(\mathbf{D}\) is the tangential operator, \(T\) is the temperature, \(T_0\) is the initial temperature, \(\alpha_T\) is the linear thermal expansion, \(\mathrm{I}\) is the identity tensor, and \(f\) is the body force.

Parameters

t	Time
dt	Time increment
local_x	Nodal values of \(x\) of all processes of an element.
local_x_prev	Nodal values of \(x_{prev}\) of all processes of an element.
local_b_data	Right hand side vector of an element.
local_Jac_data	Element Jacobian matrix for the Newton-Raphson method.

Definition at line 388 of file ThermoMechanicsFEM-impl.h.

{
    auto const local_T =
        local_x.template segment<temperature_size>(temperature_index);
 
    auto const local_T_prev =
        local_x_prev.template segment<temperature_size>(temperature_index);
 
    auto const local_u =
        local_x.template segment<displacement_size>(displacement_index);
    bool const is_u_non_zero = local_u.norm() > 0.0;
 
    auto local_Jac = MathLib::createZeroedMatrix<
        typename ShapeMatricesType::template MatrixType<displacement_size,
                                                        displacement_size>>(
        local_Jac_data, displacement_size, displacement_size);
 
    auto local_rhs = MathLib::createZeroedVector<
        typename ShapeMatricesType::template VectorType<displacement_size>>(
        local_b_data, displacement_size);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    MPL::VariableArray variables;
    MPL::VariableArray variables_prev;
    auto const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& solid_phase = medium->phase("Solid");
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        ParameterLib::SpatialPosition const x_position{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        auto const x_coord = x_position.getCoordinates().value()[0];
 
        auto const& B =
            LinearBMatrix::computeBMatrix<DisplacementDim,
                                          ShapeFunction::NPOINTS,
                                          typename BMatricesType::BMatrixType>(
                dNdx, N, x_coord, _is_axially_symmetric);
 
        auto& sigma = _ip_data[ip].sigma;
        auto const& sigma_prev = _ip_data[ip].sigma_prev;
 
        auto& eps = _ip_data[ip].eps;
        auto const& eps_prev = _ip_data[ip].eps_prev;
 
        auto& eps_m = _ip_data[ip].eps_m;
        auto const& eps_m_prev = _ip_data[ip].eps_m_prev;
 
        auto& state = _ip_data[ip].material_state_variables;
 
        const double T_ip = N.dot(local_T);  // T at integration point
        variables.temperature = T_ip;
        double const dT_ip = T_ip - N.dot(local_T_prev);
 
        //
        // displacement equation, displacement part
        //
        // For the restart computation, the displacement may not be
        // reloaded but the initial strains are always available. For such case,
        // the following computation is skipped.
        if (is_u_non_zero)
        {
            eps.noalias() = B * local_u;
        }
 
        // Consider also anisotropic thermal expansion.
        auto const solid_linear_thermal_expansivity_vector =
            MPL::formKelvinVector<DisplacementDim>(
                solid_phase
                    .property(
                        MaterialPropertyLib::PropertyType::thermal_expansivity)
                    .value(variables, x_position, t, dt));
 
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim> const
            dthermal_strain = solid_linear_thermal_expansivity_vector * dT_ip;
 
        eps_m.noalias() = eps_m_prev + eps - eps_prev - dthermal_strain;
 
        variables_prev.stress
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                sigma_prev);
        variables_prev.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps_m_prev);
        variables_prev.temperature = T_ip;
        variables.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps_m);
 
        auto&& solution = _ip_data[ip].solid_material.integrateStress(
            variables_prev, variables, t, x_position, dt, *state);
 
        if (!solution)
        {
            OGS_FATAL("Computation of local constitutive relation failed.");
        }
 
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim> C;
        std::tie(sigma, state, C) = std::move(*solution);
 
        local_Jac.noalias() += B.transpose() * C * B * w;
 
        typename ShapeMatricesType::template MatrixType<DisplacementDim,
                                                        displacement_size>
            N_u = ShapeMatricesType::template MatrixType<
                DisplacementDim, displacement_size>::Zero(DisplacementDim,
                                                          displacement_size);
 
        for (int i = 0; i < DisplacementDim; ++i)
        {
            N_u.template block<1, displacement_size / DisplacementDim>(
                   i, i * displacement_size / DisplacementDim)
                .noalias() = N;
        }
 
        auto const rho_s =
            solid_phase.property(MPL::PropertyType::density)
                .template value<double>(variables, x_position, t, dt);
 
        auto const& b = _process_data.specific_body_force;
        local_rhs.noalias() -=
            (B.transpose() * sigma - N_u.transpose() * rho_s * b) * w;
    }
}

References _element, _integration_method, _ip_data, _is_axially_symmetric, _process_data, ProcessLib::LinearBMatrix::computeBMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, displacement_index, displacement_size, MaterialPropertyLib::formKelvinVector(), ParameterLib::SpatialPosition::getCoordinates(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::mechanical_strain, OGS_FATAL, MaterialPropertyLib::VariableArray::stress, MaterialPropertyLib::VariableArray::temperature, temperature_index, and MaterialPropertyLib::thermal_expansivity.

Referenced by assembleWithJacobianForStaggeredScheme().

assembleWithJacobianForHeatConductionEquations()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForHeatConductionEquations ( const double t, double const dt, Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, std::vector< double > & local_b_data, std::vector< double > & local_Jac_data )

private

Assemble local matrices and vectors arise from the linearized discretized weak form of the residual of the energy balance equation,

\[ \rho c_p \cdot{T} - \nabla (\mathbf{K} (\nabla T) = Q_T \]

where \( rho\) is the solid density, \( c_p\) is the specific heat capacity, \( \mathbf{K} \) is the thermal conductivity, and \( Q_T\) is the source/sink term.

Parameters

t	Time
dt	Time increment
local_x	Nodal values of \(x\) of all processes of an element.
local_x_prev	Nodal values of \(x_{prev}\) of all processes of an element.
local_b_data	Right hand side vector of an element.
local_Jac_data	Element Jacobian matrix for the Newton-Raphson method.

Definition at line 528 of file ThermoMechanicsFEM-impl.h.

{
    auto const local_T =
        local_x.template segment<temperature_size>(temperature_index);
 
    auto const local_T_prev =
        local_x_prev.template segment<temperature_size>(temperature_index);
 
    auto local_Jac = MathLib::createZeroedMatrix<
        typename ShapeMatricesType::template MatrixType<temperature_size,
                                                        temperature_size>>(
        local_Jac_data, temperature_size, temperature_size);
 
    auto local_rhs = MathLib::createZeroedVector<
        typename ShapeMatricesType::template VectorType<temperature_size>>(
        local_b_data, temperature_size);
 
    typename ShapeMatricesType::NodalMatrixType mass;
    mass.setZero(temperature_size, temperature_size);
 
    typename ShapeMatricesType::NodalMatrixType laplace;
    laplace.setZero(temperature_size, temperature_size);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    auto const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& solid_phase = medium->phase("Solid");
    MPL::VariableArray variables;
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        ParameterLib::SpatialPosition const x_position{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        const double T_ip = N.dot(local_T);  // T at integration point
        variables.temperature = T_ip;
 
        auto const rho_s =
            solid_phase.property(MPL::PropertyType::density)
                .template value<double>(variables, x_position, t, dt);
        auto const c_p =
            solid_phase.property(MPL::PropertyType::specific_heat_capacity)
                .template value<double>(variables, x_position, t, dt);
 
        mass.noalias() += N.transpose() * rho_s * c_p * N * w;
 
        auto const lambda =
            solid_phase
                .property(
                    MaterialPropertyLib::PropertyType::thermal_conductivity)
                .value(variables, x_position, t, dt);
 
        GlobalDimMatrixType const thermal_conductivity =
            MaterialPropertyLib::formEigenTensor<DisplacementDim>(lambda);
 
        laplace.noalias() += dNdx.transpose() * thermal_conductivity * dNdx * w;
    }
    local_Jac.noalias() += laplace + mass / dt;
 
    local_rhs.noalias() -=
        laplace * local_T + mass * (local_T - local_T_prev) / dt;
}

References _element, _integration_method, _ip_data, _process_data, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), NumLib::interpolateCoordinates(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::VariableArray::temperature, temperature_index, temperature_size, and MaterialPropertyLib::thermal_conductivity.

Referenced by assembleWithJacobianForStaggeredScheme().

assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForStaggeredScheme ( double const t, double const dt, Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, int const process_id, std::vector< double > & local_b_data, std::vector< double > & local_Jac_data )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 366 of file ThermoMechanicsFEM-impl.h.

{
    // For the equations with pressure
    if (process_id == _process_data.heat_conduction_process_id)
    {
        assembleWithJacobianForHeatConductionEquations(
            t, dt, local_x, local_x_prev, local_b_data, local_Jac_data);
        return;
    }
 
    // For the equations with deformation
    assembleWithJacobianForDeformationEquations(t, dt, local_x, local_x_prev,
                                                local_b_data, local_Jac_data);
}

References _process_data, assembleWithJacobianForDeformationEquations(), and assembleWithJacobianForHeatConductionEquations().

getEpsilon()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getEpsilon ( ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 647 of file ThermoMechanicsFEM-impl.h.

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

References getEpsilon(), getIntPtEpsilon(), MathLib::KelvinVector::kelvin_vector_dimensions(), and ProcessLib::transposeInPlace().

Referenced by getEpsilon().

getEpsilonMechanical()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getEpsilonMechanical ( ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 691 of file ThermoMechanicsFEM-impl.h.

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

References getEpsilonMechanical(), getIntPtEpsilonMechanical(), MathLib::KelvinVector::kelvin_vector_dimensions(), and ProcessLib::transposeInPlace().

Referenced by getEpsilonMechanical().

getIntPtEpsilon()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilon ( const double t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, std::vector< double > & cache ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 659 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
        _ip_data, &IpData::eps, cache);
}

References _ip_data, ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::eps, and ProcessLib::getIntegrationPointKelvinVectorData().

Referenced by getEpsilon().

getIntPtEpsilonMechanical()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilonMechanical ( const double t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, std::vector< double > & cache ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 671 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
        _ip_data, &IpData::eps_m, cache);
}

References _ip_data, ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::eps_m, and ProcessLib::getIntegrationPointKelvinVectorData().

Referenced by getEpsilonMechanical().

getIntPtSigma()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigma ( const double t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, std::vector< double > & cache ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 626 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
        _ip_data, &IpData::sigma, cache);
}

References _ip_data, ProcessLib::getIntegrationPointKelvinVectorData(), and ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::sigma.

Referenced by getSigma().

getMaterialID()

template<typename ShapeFunction, int DisplacementDim>

int ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getMaterialID ( ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 710 of file ThermoMechanicsFEM-impl.h.

{
    return _process_data.material_ids == nullptr
               ? 0
               : (*_process_data.material_ids)[_element.getID()];
}

References _element, _process_data, and getMaterialID().

Referenced by getMaterialID().

getMaterialStateVariablesAt()

template<typename ShapeFunction, int DisplacementDim>

MaterialLib::Solids::MechanicsBase< DisplacementDim >::MaterialStateVariables const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getMaterialStateVariablesAt ( unsigned integration_point ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 720 of file ThermoMechanicsFEM-impl.h.

{
    return *_ip_data[integration_point].material_state_variables;
}

References _ip_data.

getNumberOfIntegrationPoints()

template<typename ShapeFunction, int DisplacementDim>

unsigned ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getNumberOfIntegrationPoints ( ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 703 of file ThermoMechanicsFEM-impl.h.

{
    return _integration_method.getNumberOfPoints();
}

References _integration_method, and getNumberOfIntegrationPoints().

Referenced by getNumberOfIntegrationPoints().

getShapeMatrix()

template<typename ShapeFunction, int DisplacementDim>

Eigen::Map< const Eigen::RowVectorXd > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 246 of file ThermoMechanicsFEM.h.

    {
        auto const& N = _secondary_data.N[integration_point];
 
        // assumes N is stored contiguously in memory
        return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
    }

References _secondary_data.

getSigma()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::getSigma ( ) const

overrideprivatevirtual

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 614 of file ThermoMechanicsFEM-impl.h.

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

References getIntPtSigma(), MathLib::KelvinVector::kelvin_vector_dimensions(), and ProcessLib::transposeInPlace().

initializeConcrete()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete ( )

inlineoverridevirtual

Set initial stress from parameter.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 194 of file ThermoMechanicsFEM.h.

    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            auto& ip_data = _ip_data[ip];
 
            ParameterLib::SpatialPosition const x_position{
                std::nullopt, _element.getID(),
                MathLib::Point3d(
                    NumLib::interpolateCoordinates<ShapeFunction,
                                                   ShapeMatricesType>(
                        _element, ip_data.N))};

            if (_process_data.initial_stress != nullptr)
            {
                ip_data.sigma =
                    MathLib::KelvinVector::symmetricTensorToKelvinVector<
                        DisplacementDim>((*_process_data.initial_stress)(
                        std::numeric_limits<
                            double>::quiet_NaN() /* time independent */,
                        x_position));
            }
 
            double const t = 0;  // TODO (naumov) pass t from top
            ip_data.solid_material.initializeInternalStateVariables(
                t, x_position, *ip_data.material_state_variables);
 
            ip_data.pushBackState();
        }
    }

References _element, _integration_method, _ip_data, _process_data, NumLib::interpolateCoordinates(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

postTimestepConcrete()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete ( Eigen::VectorXd const & , Eigen::VectorXd const & , double const , double const , int const  )

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 232 of file ThermoMechanicsFEM.h.

    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            _ip_data[ip].pushBackState();
        }
    }

References _integration_method, and _ip_data.

setEpsilon()

template<typename ShapeFunction, int DisplacementDim>

std::size_t ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::setEpsilon ( double const * values )

private

Definition at line 638 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
        values, _ip_data, &IpData::eps);
}

References _ip_data, ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::eps, and ProcessLib::setIntegrationPointKelvinVectorData().

Referenced by setIPDataInitialConditions().

setEpsilonMechanical()

template<typename ShapeFunction, int DisplacementDim>

std::size_t ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::setEpsilonMechanical ( double const * values )

private

Definition at line 684 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
        values, _ip_data, &IpData::eps_m);
}

References _ip_data, ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::eps_m, setEpsilonMechanical(), and ProcessLib::setIntegrationPointKelvinVectorData().

Referenced by setEpsilonMechanical(), and setIPDataInitialConditions().

setInitialConditionsConcrete()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::setInitialConditionsConcrete ( Eigen::VectorXd const local_x, double const t, int const process_id )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 83 of file ThermoMechanicsFEM-impl.h.

{
    unsigned const n_integration_points =
        this->_integration_method.getNumberOfPoints();
    auto const local_u =
        local_x.template segment<displacement_size>(displacement_index);
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        ParameterLib::SpatialPosition const x_position{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        auto const x_coord = x_position.getCoordinates().value()[0];
 
        auto const& B =
            LinearBMatrix::computeBMatrix<DisplacementDim,
                                          ShapeFunction::NPOINTS,
                                          typename BMatricesType::BMatrixType>(
                dNdx, N, x_coord, _is_axially_symmetric);
 
        _ip_data[ip].eps.noalias() = B * local_u;
    }
}

References _element, _integration_method, _ip_data, _is_axially_symmetric, ProcessLib::LinearBMatrix::computeBMatrix(), displacement_index, ParameterLib::SpatialPosition::getCoordinates(), and NumLib::interpolateCoordinates().

setIPDataInitialConditions()

template<typename ShapeFunction, int DisplacementDim>

std::size_t ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::setIPDataInitialConditions ( std::string_view const name, double const * values, int const integration_order )

overridevirtual

Returns number of read integration points.

Implements ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssemblerInterface< DisplacementDim >.

Definition at line 117 of file ThermoMechanicsFEM-impl.h.

{
    if (integration_order !=
        static_cast<int>(_integration_method.getIntegrationOrder()))
    {
        OGS_FATAL(
            "Setting integration point initial conditions; The integration "
            "order of the local assembler for element {:d} is different from "
            "the integration order in the initial condition.",
            _element.getID());
    }
 
    if (name == "sigma")
    {
        return setSigma(values);
    }
    if (name == "epsilon")
    {
        return setEpsilon(values);
    }
    if (name == "epsilon_m")
    {
        return setEpsilonMechanical(values);
    }
 
    return 0;
}

References _element, _integration_method, OGS_FATAL, setEpsilon(), setEpsilonMechanical(), and setSigma().

setSigma()

template<typename ShapeFunction, int DisplacementDim>

std::size_t ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::setSigma ( double const * values )

private

Definition at line 605 of file ThermoMechanicsFEM-impl.h.

{
    return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
        values, _ip_data, &IpData::sigma);
}

References _ip_data, ProcessLib::setIntegrationPointKelvinVectorData(), and ProcessLib::ThermoMechanics::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::sigma.

Referenced by setIPDataInitialConditions().

Member Data Documentation

_element

template<typename ShapeFunction, int DisplacementDim>

MeshLib::Element const& ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_element

private

Definition at line 355 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), assembleWithJacobianForHeatConductionEquations(), getMaterialID(), initializeConcrete(), setInitialConditionsConcrete(), and setIPDataInitialConditions().

_integration_method

template<typename ShapeFunction, int DisplacementDim>

NumLib::GenericIntegrationMethod const& ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method

private

Definition at line 354 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), assembleWithJacobianForHeatConductionEquations(), getNumberOfIntegrationPoints(), initializeConcrete(), postTimestepConcrete(), setInitialConditionsConcrete(), and setIPDataInitialConditions().

_ip_data

template<typename ShapeFunction, int DisplacementDim>

std::vector<IpData, Eigen::aligned_allocator<IpData> > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data

private

Definition at line 352 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), assembleWithJacobianForHeatConductionEquations(), getIntPtEpsilon(), getIntPtEpsilonMechanical(), getIntPtSigma(), getMaterialStateVariablesAt(), initializeConcrete(), postTimestepConcrete(), setEpsilon(), setEpsilonMechanical(), setInitialConditionsConcrete(), and setSigma().

_is_axially_symmetric

template<typename ShapeFunction, int DisplacementDim>

bool const ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_is_axially_symmetric

private

Definition at line 357 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), and setInitialConditionsConcrete().

_process_data

template<typename ShapeFunction, int DisplacementDim>

ThermoMechanicsProcessData<DisplacementDim>& ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_process_data

private

Definition at line 350 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), assembleWithJacobianForHeatConductionEquations(), assembleWithJacobianForStaggeredScheme(), getMaterialID(), and initializeConcrete().

_secondary_data

template<typename ShapeFunction, int DisplacementDim>

SecondaryData<typename ShapeMatrices::ShapeType> ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data

private

Definition at line 356 of file ThermoMechanicsFEM.h.

Referenced by ThermoMechanicsLocalAssembler(), and getShapeMatrix().

displacement_index

template<typename ShapeFunction, int DisplacementDim>

const int ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::displacement_index = ShapeFunction::NPOINTS

staticprivate

Definition at line 361 of file ThermoMechanicsFEM.h.

Referenced by assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), and setInitialConditionsConcrete().

displacement_size

template<typename ShapeFunction, int DisplacementDim>

const int ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::displacement_size

staticprivate

Initial value:

=
        ShapeFunction::NPOINTS * DisplacementDim

Definition at line 362 of file ThermoMechanicsFEM.h.

Referenced by assembleWithJacobian(), and assembleWithJacobianForDeformationEquations().

KelvinVectorSize

template<typename ShapeFunction, int DisplacementDim>

int const ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::KelvinVectorSize

static

Initial value:

=
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)

Definition at line 140 of file ThermoMechanicsFEM.h.

temperature_index

template<typename ShapeFunction, int DisplacementDim>

const int ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::temperature_index = 0

staticprivate

Definition at line 359 of file ThermoMechanicsFEM.h.

Referenced by assembleWithJacobian(), assembleWithJacobianForDeformationEquations(), and assembleWithJacobianForHeatConductionEquations().

temperature_size

template<typename ShapeFunction, int DisplacementDim>

const int ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::temperature_size = ShapeFunction::NPOINTS

staticprivate

Definition at line 360 of file ThermoMechanicsFEM.h.

Referenced by assembleWithJacobian(), and assembleWithJacobianForHeatConductionEquations().

---

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

• ProcessLib/ThermoMechanics/ThermoMechanicsFEM.h
• ProcessLib/ThermoMechanics/ThermoMechanicsFEM-impl.h