Detailed Description

template<typename ShapeFunction, int DisplacementDim>
class ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >

Definition at line 111 of file ThermoMechanicalPhaseFieldFEM.h.

#include <ThermoMechanicalPhaseFieldFEM.h>

Inheritance diagram for ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

[legend]

Collaboration diagram for ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

[legend]

Public Types
using	ShapeMatricesType

using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

using	BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

using	NodalForceVectorType = typename BMatricesType::NodalForceVectorType

using	GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

using	TemperatureVector

using	DeformationVector

using	PhaseFieldVector

using	IpData

Public Member Functions
	ThermoMechanicalPhaseFieldLocalAssembler (ThermoMechanicalPhaseFieldLocalAssembler const &)=delete

	ThermoMechanicalPhaseFieldLocalAssembler (ThermoMechanicalPhaseFieldLocalAssembler &&)=delete

	ThermoMechanicalPhaseFieldLocalAssembler (MeshLib::Element const &e, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, ThermoMechanicalPhaseFieldProcessData< DisplacementDim > &process_data, int const mechanics_related_process_id, int const phase_field_process_id, int const heat_conduction_process_id)

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	initializeConcrete () 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::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssemblerInterface
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	assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_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.

Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Member Functions
std::vector< double > const &	getIntPtSigma (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

std::vector< double > const &	getIntPtEpsilon (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

std::vector< double > const &	getIntPtHeatFlux (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

void	assembleWithJacobianForDeformationEquations (double const t, double const dt, Eigen::VectorXd const &local_x, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)

void	assembleWithJacobianForHeatConductionEquations (double const 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	assembleWithJacobianForPhaseFieldEquations (double const t, Eigen::VectorXd const &local_x, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)

Private Attributes
ThermoMechanicalPhaseFieldProcessData< 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

int const	_mechanics_related_process_id
	ID of the processes that contains mechanical process.

int const	_phase_field_process_id
	ID of phase field process.

int const	_heat_conduction_process_id
	ID of heat conduction process.

Static Private Attributes
static constexpr int	temperature_index = 0

static constexpr int	temperature_size = ShapeFunction::NPOINTS

static constexpr int	displacement_index

static constexpr int	displacement_size

static constexpr int	phasefield_index

static constexpr int	phasefield_size = ShapeFunction::NPOINTS

Member Typedef Documentation

◆ BMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 131 of file ThermoMechanicalPhaseFieldFEM.h.

◆ DeformationVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::DeformationVector

Initial value:

typename ShapeMatricesType::template VectorType<displacement_size>

Definition at line 139 of file ThermoMechanicalPhaseFieldFEM.h.

◆ GlobalDimVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

Definition at line 135 of file ThermoMechanicalPhaseFieldFEM.h.

◆ IpData

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::IpData

Initial value:

IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 143 of file ThermoMechanicalPhaseFieldFEM.h.

◆ NodalForceVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 133 of file ThermoMechanicalPhaseFieldFEM.h.

◆ PhaseFieldVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldVector

Initial value:

typename ShapeMatricesType::template VectorType<phasefield_size>

Definition at line 141 of file ThermoMechanicalPhaseFieldFEM.h.

◆ ShapeMatrices

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 130 of file ThermoMechanicalPhaseFieldFEM.h.

◆ ShapeMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatricesType

Initial value:

ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

EigenFixedShapeMatrixPolicy

Definition ShapeMatrixPolicy.h:73

Definition at line 126 of file ThermoMechanicalPhaseFieldFEM.h.

◆ TemperatureVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::TemperatureVector

Initial value:

typename ShapeMatricesType::template VectorType<temperature_size>

Definition at line 137 of file ThermoMechanicalPhaseFieldFEM.h.

Constructor & Destructor Documentation

◆ ThermoMechanicalPhaseFieldLocalAssembler() [1/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicalPhaseFieldLocalAssembler ( ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > const & )

delete

◆ ThermoMechanicalPhaseFieldLocalAssembler() [2/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicalPhaseFieldLocalAssembler ( ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > && )

delete

◆ ThermoMechanicalPhaseFieldLocalAssembler() [3/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicalPhaseFieldLocalAssembler	(	MeshLib::Element const &	e,
		std::size_t const	,
		NumLib::GenericIntegrationMethod const &	integration_method,
		bool const	is_axially_symmetric,
		ThermoMechanicalPhaseFieldProcessData< DisplacementDim > &	process_data,
		int const	mechanics_related_process_id,
		int const	phase_field_process_id,
		int const	heat_conduction_process_id )

inline

Definition at line 151 of file ThermoMechanicalPhaseFieldFEM.h.

        : _process_data(process_data),
          _integration_method(integration_method),
          _element(e),
          _is_axially_symmetric(is_axially_symmetric),
          _mechanics_related_process_id(mechanics_related_process_id),
          _phase_field_process_id(phase_field_process_id),
          _heat_conduction_process_id(heat_conduction_process_id)
    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        _ip_data.reserve(n_integration_points);
        _secondary_data.N.resize(n_integration_points);
 
        auto& solid_material =
            MaterialLib::Solids::selectSolidConstitutiveRelation(
                _process_data.solid_materials,
                _process_data.material_ids,
                e.getID());
        if (!dynamic_cast<MaterialLib::Solids::LinearElasticIsotropic<
                DisplacementDim> const*>(&solid_material))
        {
            OGS_FATAL(
                "For phasefield process only linear elastic solid material "
                "support is implemented.");
        }
 
        auto const shape_matrices =
            NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                      DisplacementDim>(e, is_axially_symmetric,
                                                       _integration_method);
 
        ParameterLib::SpatialPosition x_position;
        x_position.setElementID(_element.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);
            ip_data.eps.setZero(kelvin_vector_size);
            ip_data.eps_prev.resize(kelvin_vector_size);
            ip_data.eps_m.setZero(kelvin_vector_size);
 
            ip_data.D.setZero(kelvin_vector_size, kelvin_vector_size);
            ip_data.sigma_tensile.setZero(kelvin_vector_size);
            ip_data.sigma_compressive.setZero(kelvin_vector_size);
            ip_data.heatflux.setZero(DisplacementDim);
            ip_data.sigma.setZero(kelvin_vector_size);
            ip_data.strain_energy_tensile = 0.0;
            ip_data.elastic_energy = 0.0;
 
            ip_data.N = shape_matrices[ip].N;
            ip_data.dNdx = shape_matrices[ip].dNdx;
 
            _secondary_data.N[ip] = shape_matrices[ip].N;
        }
    }

Member Function Documentation

◆ assemble()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< 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 225 of file ThermoMechanicalPhaseFieldFEM.h.

    {
        OGS_FATAL(
            "ThermoMechanicalPhaseFieldLocalAssembler: assembly without "
            "Jacobian is not implemented.");
    }

References OGS_FATAL.

◆ assembleWithJacobianForDeformationEquations()

template<typename ShapeFunction , int DisplacementDim>

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

private

Definition at line 49 of file ThermoMechanicalPhaseFieldFEM-impl.h.

{
    assert(local_x.size() ==
           phasefield_size + displacement_size + temperature_size);
 
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
    auto const u =
        local_x.template segment<displacement_size>(displacement_index);
    auto const T =
        local_x.template segment<temperature_size>(temperature_index);
 
    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);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int 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& eps = _ip_data[ip].eps;
 
        auto const& D = _ip_data[ip].D;
        auto const& sigma = _ip_data[ip].sigma;
 
        auto const k = _process_data.residual_stiffness(t, x_position)[0];
        auto rho_sr = _process_data.solid_density(t, x_position)[0];
        auto const alpha = _process_data.linear_thermal_expansion_coefficient(
            t, x_position)[0];
        double const T0 = _process_data.reference_temperature;
        auto const& b = _process_data.specific_body_force;
 
        double const T_ip = N.dot(T);
        double const delta_T = T_ip - T0;
        // calculate real density
        double const rho_s = rho_sr / (1 + 3 * alpha * delta_T);
 
        double const d_ip = N.dot(d);
        double const degradation = d_ip * d_ip * (1 - k) + k;
 
        eps.noalias() = B * u;
        _ip_data[ip].updateConstitutiveRelation(t, x_position, dt, u, alpha,
                                                delta_T, degradation);
 
        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;
        }
 
        local_Jac.noalias() += B.transpose() * D * B * w;
 
        local_rhs.noalias() -=
            (B.transpose() * sigma - N_u.transpose() * rho_s * b) * w;
    }
}

References ProcessLib::LinearBMatrix::computeBMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), NumLib::interpolateXCoordinate(), and ParameterLib::SpatialPosition::setElementID().

◆ assembleWithJacobianForHeatConductionEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForHeatConductionEquations	(	double const	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

Definition at line 137 of file ThermoMechanicalPhaseFieldFEM-impl.h.

{
    assert(local_x.size() ==
           phasefield_size + displacement_size + temperature_size);
 
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
    auto const T =
        local_x.template segment<temperature_size>(temperature_index);
    auto const 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);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int 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& eps_m = _ip_data[ip].eps_m;
        auto& heatflux = _ip_data[ip].heatflux;
 
        auto rho_sr = _process_data.solid_density(t, x_position)[0];
        auto const alpha = _process_data.linear_thermal_expansion_coefficient(
            t, x_position)[0];
        double const c = _process_data.specific_heat_capacity(t, x_position)[0];
        auto const lambda =
            _process_data.thermal_conductivity(t, x_position)[0];
        auto const lambda_res =
            _process_data.residual_thermal_conductivity(t, x_position)[0];
        double const T0 = _process_data.reference_temperature;
 
        double const d_ip = N.dot(d);
        double const T_ip = N.dot(T);
        double const T_dot_ip = (T_ip - N.dot(T_prev)) / dt;
        double const delta_T = T_ip - T0;
        // calculate real density
        double const rho_s = rho_sr / (1 + 3 * alpha * delta_T);
        // calculate effective thermal conductivity
        auto const lambda_eff =
            d_ip * d_ip * lambda + (1 - d_ip) * (1 - d_ip) * lambda_res;
 
        using Invariants = MathLib::KelvinVector::Invariants<
            MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)>;
 
        double const eps_m_trace = Invariants::trace(eps_m);
        if (eps_m_trace >= 0)
        {
            local_Jac.noalias() += (dNdx.transpose() * lambda_eff * dNdx +
                                    N.transpose() * rho_s * c * N / dt) *
                                   w;
 
            local_rhs.noalias() -= (N.transpose() * rho_s * c * T_dot_ip +
                                    dNdx.transpose() * lambda_eff * dNdx * T) *
                                   w;
 
            heatflux.noalias() = -(lambda_eff * dNdx * T) * w;
        }
        else
        {
            local_Jac.noalias() += (dNdx.transpose() * lambda * dNdx +
                                    N.transpose() * rho_s * c * N / dt) *
                                   w;
 
            local_rhs.noalias() -= (N.transpose() * rho_s * c * T_dot_ip +
                                    dNdx.transpose() * lambda * dNdx * T) *
                                   w;
 
            heatflux.noalias() = -(lambda * dNdx * T) * w;
        }
    }
}

References MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MathLib::KelvinVector::kelvin_vector_dimensions(), and ParameterLib::SpatialPosition::setElementID().

◆ assembleWithJacobianForPhaseFieldEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForPhaseFieldEquations	(	double const	t,
		Eigen::VectorXd const &	local_x,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data )

private

Definition at line 226 of file ThermoMechanicalPhaseFieldFEM-impl.h.

{
    assert(local_x.size() ==
           phasefield_size + displacement_size + temperature_size);
 
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
 
    auto local_Jac = MathLib::createZeroedMatrix<
        typename ShapeMatricesType::template MatrixType<phasefield_size,
                                                        phasefield_size>>(
        local_Jac_data, phasefield_size, phasefield_size);
 
    auto local_rhs = MathLib::createZeroedVector<
        typename ShapeMatricesType::template VectorType<phasefield_size>>(
        local_b_data, phasefield_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int 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& strain_energy_tensile = _ip_data[ip].strain_energy_tensile;
 
        auto const gc = _process_data.crack_resistance(t, x_position)[0];
        auto const ls = _process_data.crack_length_scale(t, x_position)[0];
 
        double const d_ip = N.dot(d);
 
        local_Jac.noalias() += (dNdx.transpose() * gc * ls * dNdx +
                                N.transpose() * 2 * strain_energy_tensile * N +
                                N.transpose() * gc / ls * N) *
                               w;
 
        local_rhs.noalias() -=
            (dNdx.transpose() * gc * ls * dNdx * d +
             N.transpose() * d_ip * 2 * strain_energy_tensile -
             N.transpose() * gc / ls * (1 - d_ip)) *
            w;
    }
}

References MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), and ParameterLib::SpatialPosition::setElementID().

◆ assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< 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 21 of file ThermoMechanicalPhaseFieldFEM-impl.h.

{
    if (process_id == _phase_field_process_id)
    {
        assembleWithJacobianForPhaseFieldEquations(t, local_x, local_b_data,
                                                   local_Jac_data);
        return;
    }
 
    if (process_id == _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_b_data,
                                                local_Jac_data);
}

◆ getIntPtEpsilon()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilon	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssemblerInterface.

Definition at line 288 of file ThermoMechanicalPhaseFieldFEM.h.

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

References ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::ThermoMechanicalPhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::eps, and ProcessLib::getIntegrationPointKelvinVectorData().

◆ getIntPtHeatFlux()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtHeatFlux	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssemblerInterface.

Definition at line 298 of file ThermoMechanicalPhaseFieldFEM.h.

    {
        using KelvinVectorType = typename BMatricesType::KelvinVectorType;
 
        auto const n_integration_points = _ip_data.size();
 
        cache.clear();
        auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
            double, DisplacementDim, Eigen::Dynamic, Eigen::RowMajor>>(
            cache, DisplacementDim, n_integration_points);
 
        for (unsigned ip = 0; ip < n_integration_points; ++ip)
        {
            auto const& heatflux = _ip_data[ip].heatflux;
 
            for (typename KelvinVectorType::Index component = 0;
                 component < DisplacementDim;
                 ++component)
            {  // x, y, z components
                cache_mat(component, ip) = heatflux[component];
            }
        }
 
        return cache;
    }

References ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, and MathLib::createZeroedMatrix().

◆ getIntPtSigma()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigma	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssemblerInterface.

Definition at line 278 of file ThermoMechanicalPhaseFieldFEM.h.

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

References ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::getIntegrationPointKelvinVectorData(), and ProcessLib::ThermoMechanicalPhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::sigma.

◆ getShapeMatrix()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 268 of file ThermoMechanicalPhaseFieldFEM.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::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data, and ProcessLib::ThermoMechanicalPhaseField::SecondaryData< ShapeMatrixType >::N.

◆ initializeConcrete()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete ( )

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 243 of file ThermoMechanicalPhaseFieldFEM.h.

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

References ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, and NumLib::GenericIntegrationMethod::getNumberOfPoints().

◆ postTimestepConcrete()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 254 of file ThermoMechanicalPhaseFieldFEM.h.

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