Detailed Description

template<typename ShapeFunction, typename IntegrationMethod, int DisplacementDim>
class ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, 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, IntegrationMethod, DisplacementDim >:

[legend]

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

[legend]

Public Types
using	ShapeMatricesType = ShapeMatrixPolicyType< ShapeFunction, DisplacementDim >

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 = typename ShapeMatricesType::template VectorType< ShapeFunction::NPOINTS+ShapeFunction::NPOINTS *DisplacementDim >

using	JacobianMatrix = typename ShapeMatricesType::template MatrixType< ShapeFunction::NPOINTS+ShapeFunction::NPOINTS DisplacementDim, ShapeFunction::NPOINTS+ShapeFunction::NPOINTS DisplacementDim >

using	IpData = IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >

Public Member Functions
	ThermoMechanicsLocalAssembler (ThermoMechanicsLocalAssembler const &)=delete

	ThermoMechanicsLocalAssembler (ThermoMechanicsLocalAssembler &&)=delete

	ThermoMechanicsLocalAssembler (MeshLib::Element const &e, std::size_t const, bool const is_axially_symmetric, unsigned const integration_order, ThermoMechanicsProcessData< DisplacementDim > &process_data)

std::size_t	setIPDataInitialConditions (std::string const &name, double const *values, int const integration_order) override
	Returns number of read integration points. More...

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_xdot, const double dxdot_dx, const double dx_dx, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, 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_xdot, const double dxdot_dx, const double dx_dx, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_rhs_data, std::vector< double > &local_Jac_data) override

void	initializeConcrete () override

void	postTimestepConcrete (Eigen::VectorXd const &, double const, double const) override

Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point. More...

Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual	~LocalAssemblerInterface ()=default

void	setInitialConditions (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, bool const use_monolithic_scheme, 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_xdot, 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_dot, 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, double const t, double const dt)

void	postNonLinearSolver (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, GlobalVector const &xdot, double const t, double const dt, bool const use_monolithic_scheme, int const process_id)

virtual std::vector< double >	interpolateNodalValuesToIntegrationPoints (std::vector< double > const &)

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. More...

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_xdot, 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_xdot, 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

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

IntegrationMethod	_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 , typename IntegrationMethod , int DisplacementDim>

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

Definition at line 138 of file ThermoMechanicsFEM.h.

◆ GlobalDimMatrixType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

Definition at line 137 of file ThermoMechanicsFEM.h.

◆ Invariants

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

Definition at line 142 of file ThermoMechanicsFEM.h.

◆ IpData

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::IpData = IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 150 of file ThermoMechanicsFEM.h.

◆ JacobianMatrix

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::JacobianMatrix = 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 , typename IntegrationMethod , int DisplacementDim>

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

Definition at line 144 of file ThermoMechanicsFEM.h.

◆ RhsVector

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::RhsVector = typename ShapeMatricesType::template VectorType< ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim>

Definition at line 145 of file ThermoMechanicsFEM.h.

◆ ShapeMatrices

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

Definition at line 136 of file ThermoMechanicsFEM.h.

◆ ShapeMatricesType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 131 of file ThermoMechanicsFEM.h.

Constructor & Destructor Documentation

◆ ThermoMechanicsLocalAssembler() [1/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

delete

◆ ThermoMechanicsLocalAssembler() [2/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

delete

◆ ThermoMechanicsLocalAssembler() [3/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler	(	MeshLib::Element const &	e,
		std::size_t const	,
		bool const	is_axially_symmetric,
		unsigned const	integration_order,
		ThermoMechanicsProcessData< DisplacementDim > &	process_data
	)

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

     : _process_data(process_data),
       _integration_method(integration_order),
       _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 ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_element, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_process_data, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_secondary_data, MeshLib::Element::getID(), NumLib::initShapeMatrices(), MathLib::KelvinVector::kelvin_vector_dimensions(), ProcessLib::HeatTransportBHE::SecondaryData< ShapeMatrixType >::N, MaterialLib::Solids::selectSolidConstitutiveRelation(), and ParameterLib::SpatialPosition::setElementID().

Member Function Documentation

◆ assemble()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, 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 , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian	(	double const	t,
		double const	dt,
		std::vector< double > const &	local_x,
		std::vector< double > const &	local_xdot,
		const double	dxdot_dx,
		const double	dx_dx,
		std::vector< double > &	local_M_data,
		std::vector< double > &	local_K_data,
		std::vector< double > &	local_rhs_data,
		std::vector< double > &	local_Jac_data
	)

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 121 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_dot = Eigen::Map<typename ShapeMatricesType::template VectorType<
         temperature_size> const>(local_xdot.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++)
     {
         x_position.setIntegrationPoint(ip);
         auto const& w = _ip_data[ip].integration_weight;
         auto const& N = _ip_data[ip].N;
         auto const& dNdx = _ip_data[ip].dNdx;
  
         auto const x_coord =
             NumLib::interpolateXCoordinate<ShapeFunction, ShapeMatricesType>(
                 _element, N);
         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 dT = N.dot(T_dot) * dt;
  
         // Consider also anisotropic thermal expansion.
         auto const solid_linear_thermal_expansivity_vector =
             MPL::formKelvinVectorFromThermalExpansivity<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.eval() * dT;
  
         //
         // 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[static_cast<int>(MPL::Variable::stress)]
             .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                 sigma_prev);
         variables_prev[static_cast<int>(MPL::Variable::mechanical_strain)]
             .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                 eps_m_prev);
         variables_prev[static_cast<int>(MPL::Variable::temperature)]
             .emplace<double>(T_ip);
         variables[static_cast<int>(MPL::Variable::mechanical_strain)]
             .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                 eps_m);
         variables[static_cast<int>(MPL::Variable::temperature)].emplace<double>(
             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.eval());
         KuT.noalias() += B.transpose() * (C * alpha_T_tensor.eval()) * 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_dot;
 }

References MaterialPropertyLib::c, ProcessLib::LinearBMatrix::computeBMatrix(), MaterialLib::Solids::CreepBGRa, MaterialPropertyLib::density, MathLib::KelvinVector::kelvinVectorToSymmetricTensor(), OGS_FATAL, ParameterLib::SpatialPosition::setElementID(), ParameterLib::SpatialPosition::setIntegrationPoint(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::temperature, MaterialPropertyLib::thermal_conductivity, and MaterialPropertyLib::thermal_expansivity.

◆ assembleWithJacobianForDeformationEquations()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForDeformationEquations	(	const double	t,
		double const	dt,
		Eigen::VectorXd const &	local_x,
		Eigen::VectorXd const &	local_xdot,
		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_xdot	Nodal values of \(\dot{x}\) 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 367 of file ThermoMechanicsFEM-impl.h.

 {
     auto const local_T =
         local_x.template segment<temperature_size>(temperature_index);
  
     auto const local_Tdot =
         local_xdot.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;
     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++)
     {
         x_position.setIntegrationPoint(ip);
         auto const& w = _ip_data[ip].integration_weight;
         auto const& N = _ip_data[ip].N;
         auto const& dNdx = _ip_data[ip].dNdx;
  
         auto const x_coord =
             NumLib::interpolateXCoordinate<ShapeFunction, ShapeMatricesType>(
                 _element, N);
         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
         double const dT_ip = N.dot(local_Tdot) * dt;
         variables[static_cast<int>(MPL::Variable::temperature)].emplace<double>(
             T_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 * local_u;
         }
  
         // Consider also anisotropic thermal expansion.
         auto const solid_linear_thermal_expansivity_vector =
             MPL::formKelvinVectorFromThermalExpansivity<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.eval() * dT_ip;
  
         eps_m.noalias() = eps_m_prev + eps - eps_prev - dthermal_strain;
  
         variables_prev[static_cast<int>(MPL::Variable::stress)]
             .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                 sigma_prev);
         variables_prev[static_cast<int>(MPL::Variable::mechanical_strain)]
             .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                 eps_m_prev);
         variables_prev[static_cast<int>(MPL::Variable::temperature)]
             .emplace<double>(T_ip);
         variables[static_cast<int>(MPL::Variable::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 ProcessLib::LinearBMatrix::computeBMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, OGS_FATAL, ParameterLib::SpatialPosition::setElementID(), ParameterLib::SpatialPosition::setIntegrationPoint(), MaterialPropertyLib::temperature, and MaterialPropertyLib::thermal_expansivity.

◆ assembleWithJacobianForHeatConductionEquations()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForHeatConductionEquations	(	const double	t,
		double const	dt,
		Eigen::VectorXd const &	local_x,
		Eigen::VectorXd const &	local_xdot,
		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_xdot	Nodal values of \(\dot{x}\) 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 510 of file ThermoMechanicsFEM-impl.h.

 {
     auto const local_T =
         local_x.template segment<temperature_size>(temperature_index);
  
     auto const local_dT =
         local_xdot.template segment<temperature_size>(temperature_index) * dt;
  
     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();
  
     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");
     MPL::VariableArray variables;
  
     for (unsigned ip = 0; ip < n_integration_points; ip++)
     {
         x_position.setIntegrationPoint(ip);
         auto const& w = _ip_data[ip].integration_weight;
         auto const& N = _ip_data[ip].N;
         auto const& dNdx = _ip_data[ip].dNdx;
  
         const double T_ip = N.dot(local_T);  // T at integration point
         variables[static_cast<int>(MPL::Variable::temperature)].emplace<double>(
             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_dT / dt;
 }

References MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, ParameterLib::SpatialPosition::setElementID(), ParameterLib::SpatialPosition::setIntegrationPoint(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::temperature, and MaterialPropertyLib::thermal_conductivity.

◆ assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForStaggeredScheme	(	double const	t,
		double const	dt,
		Eigen::VectorXd const &	local_x,
		Eigen::VectorXd const &	local_xdot,
		const double	dxdot_dx,
		const double	dx_dx,
		int const	process_id,
		std::vector< double > &	local_M_data,
		std::vector< double > &	local_K_data,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data
	)

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 342 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_xdot, local_b_data, local_Jac_data);
         return;
     }
  
     // For the equations with deformation
     assembleWithJacobianForDeformationEquations(t, dt, local_x, local_xdot,
                                                 local_b_data, local_Jac_data);
 }

◆ getEpsilon()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getEpsilon

overrideprivatevirtual

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

Definition at line 632 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 MathLib::KelvinVector::kelvin_vector_dimensions().

◆ getEpsilonMechanical()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getEpsilonMechanical

overrideprivatevirtual

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

Definition at line 683 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 MathLib::KelvinVector::kelvin_vector_dimensions().

◆ getIntPtEpsilon()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, 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 645 of file ThermoMechanicsFEM-impl.h.

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

◆ getIntPtEpsilonMechanical()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, 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 659 of file ThermoMechanicsFEM-impl.h.

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

◆ getIntPtSigma()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, 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 608 of file ThermoMechanicsFEM-impl.h.

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

◆ getMaterialStateVariablesAt()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

overrideprivatevirtual

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

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

 {
     return *_ip_data[integration_point].material_state_variables;
 }

◆ getNumberOfIntegrationPoints()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

unsigned ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getNumberOfIntegrationPoints

overrideprivatevirtual

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

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

 {
     return _integration_method.getNumberOfPoints();
 }

◆ getShapeMatrix()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 241 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 ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_secondary_data, and ProcessLib::HeatTransportBHE::SecondaryData< ShapeMatrixType >::N.

◆ getSigma()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector< double > ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getSigma

overrideprivatevirtual

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

Definition at line 595 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 MathLib::KelvinVector::kelvin_vector_dimensions().

◆ initializeConcrete()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

inlineoverridevirtual

Set initial stress from parameter.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 199 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];
  
             if (_process_data.initial_stress != nullptr)
             {
                 ParameterLib::SpatialPosition const x_position{
                     std::nullopt, _element.getID(), ip,
                     MathLib::Point3d(
                         NumLib::interpolateCoordinates<ShapeFunction,
                                                        ShapeMatricesType>(
                             _element, ip_data.N))};
  
                 ip_data.sigma =
                     MathLib::KelvinVector::symmetricTensorToKelvinVector<
                         DisplacementDim>((*_process_data.initial_stress)(
                         std::numeric_limits<
                             double>::quiet_NaN() /* time independent */,
                         x_position));
             }
  
             ip_data.pushBackState();
         }
     }

References ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_element, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_process_data, MeshLib::Element::getID(), NumLib::interpolateCoordinates(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

◆ postTimestepConcrete()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 229 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 ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ setEpsilon()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

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

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

◆ setEpsilonMechanical()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

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

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

◆ setIPDataInitialConditions()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

overridevirtual

Returns number of read integration points.

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

Definition at line 88 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_ip")
     {
         return setSigma(values);
     }
     if (name == "epsilon_ip")
     {
         return setEpsilon(values);
     }
     if (name == "epsilon_m_ip")
     {
         return setEpsilonMechanical(values);
     }
  
     return 0;
 }

References MaterialPropertyLib::name, and OGS_FATAL.

◆ setSigma()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

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

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

Member Data Documentation

◆ _element

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

Definition at line 349 of file ThermoMechanicsFEM.h.

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler(), and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::initializeConcrete().

◆ _integration_method

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

IntegrationMethod ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method

private

Definition at line 348 of file ThermoMechanicsFEM.h.

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::initializeConcrete(), and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::postTimestepConcrete().

◆ _ip_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

Definition at line 346 of file ThermoMechanicsFEM.h.

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::initializeConcrete(), and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::postTimestepConcrete().

◆ _is_axially_symmetric

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

Definition at line 351 of file ThermoMechanicsFEM.h.

◆ _process_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

Definition at line 344 of file ThermoMechanicsFEM.h.

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler(), and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::initializeConcrete().

◆ _secondary_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

private

Definition at line 350 of file ThermoMechanicsFEM.h.

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ThermoMechanicsLocalAssembler(), and ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getShapeMatrix().

◆ displacement_index

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

staticprivate

Definition at line 355 of file ThermoMechanicsFEM.h.

◆ displacement_size

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

staticprivate

Initial value:

=

ShapeFunction::NPOINTS * DisplacementDim

Definition at line 356 of file ThermoMechanicsFEM.h.

◆ KelvinVectorSize

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

static

Initial value:

=

MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)

Definition at line 140 of file ThermoMechanicsFEM.h.

◆ temperature_index

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

staticprivate

Definition at line 353 of file ThermoMechanicsFEM.h.

◆ temperature_size

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

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

staticprivate

Definition at line 354 of file ThermoMechanicsFEM.h.

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

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

Detailed Description

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

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Member Typedef Documentation

◆ BMatricesType

◆ GlobalDimMatrixType

◆ Invariants

◆ IpData

◆ JacobianMatrix

◆ NodalForceVectorType

◆ RhsVector

◆ ShapeMatrices

◆ ShapeMatricesType

Constructor & Destructor Documentation

◆ ThermoMechanicsLocalAssembler() [1/3]

◆ ThermoMechanicsLocalAssembler() [2/3]

◆ ThermoMechanicsLocalAssembler() [3/3]

Member Function Documentation

◆ assemble()

◆ assembleWithJacobian()

◆ assembleWithJacobianForDeformationEquations()

◆ assembleWithJacobianForHeatConductionEquations()

◆ assembleWithJacobianForStaggeredScheme()

◆ getEpsilon()

◆ getEpsilonMechanical()

◆ getIntPtEpsilon()

◆ getIntPtEpsilonMechanical()

◆ getIntPtSigma()

◆ getMaterialStateVariablesAt()

◆ getNumberOfIntegrationPoints()

◆ getShapeMatrix()

◆ getSigma()

◆ initializeConcrete()

◆ postTimestepConcrete()

◆ setEpsilon()

◆ setEpsilonMechanical()

◆ setIPDataInitialConditions()

◆ setSigma()

Member Data Documentation

◆ _element

◆ _integration_method

◆ _ip_data

◆ _is_axially_symmetric

◆ _process_data

◆ _secondary_data

◆ displacement_index

◆ displacement_size

◆ KelvinVectorSize

◆ temperature_index

◆ temperature_size

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