ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int DisplacementDim>
class ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >

Definition at line 170 of file PhaseFieldFEM.h.

#include <PhaseFieldFEM.h>

Inheritance diagram for ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

Collaboration diagram for ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

Public Types
using	ShapeMatricesType
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>
using	NodalForceVectorType = typename BMatricesType::NodalForceVectorType
using	DeformationVector
using	PhaseFieldVector
using	PhaseFieldMatrix
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	IpData

Public Member Functions
	PhaseFieldLocalAssembler (PhaseFieldLocalAssembler const &)=delete
	PhaseFieldLocalAssembler (PhaseFieldLocalAssembler &&)=delete
	PhaseFieldLocalAssembler (MeshLib::Element const &e, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, PhaseFieldProcessData< DisplacementDim > &process_data)
std::size_t	setIPDataInitialConditions (std::string_view const name, double const *values, int const integration_order) override
	Returns number of read integration points.
void	assemble (double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
void	assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override
void	initializeConcrete () override
void	postTimestepConcrete (Eigen::VectorXd const &, Eigen::VectorXd const &, double const, double const, int const) override
void	computeCrackIntegral (std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double &crack_volume) override
void	computeEnergy (std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double &elastic_energy, double &surface_energy, double &pressure_work) override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
std::vector< double >	getSigma () const override
std::vector< double >	getEpsilon () const override
Public Member Functions inherited from ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface
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 &	getIntPtSigmaTensile (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
std::vector< double > const &	getIntPtSigmaCompressive (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 &	getIntPtEpsilonTensile (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
void	assembleWithJacobianPhaseFieldEquations (double const t, double const dt, Eigen::VectorXd const &local_x, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
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)

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

Static Private Attributes
static constexpr int	displacement_index = 0
static constexpr int	displacement_size
static constexpr int	phasefield_index
static constexpr int	phasefield_size = ShapeFunction::NPOINTS
static const int	phase_process_id = 1
static const int	mechanics_process_id = 0

Member Typedef Documentation

BMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 186 of file PhaseFieldFEM.h.

DeformationVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::DeformationVector

Initial value:

 
        typename ShapeMatricesType::template VectorType<displacement_size>

Definition at line 190 of file PhaseFieldFEM.h.

IpData

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::IpData

Initial value:

 
        IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 199 of file PhaseFieldFEM.h.

NodalForceVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 188 of file PhaseFieldFEM.h.

NodalMatrixType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 197 of file PhaseFieldFEM.h.

NodalVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 198 of file PhaseFieldFEM.h.

PhaseFieldMatrix

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldMatrix

Initial value:

 
        typename ShapeMatricesType::template MatrixType<phasefield_size,
                                                        phasefield_size>

Definition at line 194 of file PhaseFieldFEM.h.

PhaseFieldVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldVector

Initial value:

 
        typename ShapeMatricesType::template VectorType<phasefield_size>

Definition at line 192 of file PhaseFieldFEM.h.

ShapeMatrices

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 185 of file PhaseFieldFEM.h.

ShapeMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatricesType

Initial value:

 
        ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 181 of file PhaseFieldFEM.h.

Constructor & Destructor Documentation

PhaseFieldLocalAssembler() [1/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler ( PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > const & )

delete

PhaseFieldLocalAssembler() [2/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler ( PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > && )

delete

PhaseFieldLocalAssembler() [3/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler ( MeshLib::Element const & e, std::size_t const , NumLib::GenericIntegrationMethod const & integration_method, bool const is_axially_symmetric, PhaseFieldProcessData< DisplacementDim > & process_data )

inline

Definition at line 205 of file PhaseFieldFEM.h.

        : _process_data(process_data),
          _integration_method(integration_method),
          _element(e),
          _is_axially_symmetric(is_axially_symmetric)
    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        _ip_data.reserve(n_integration_points);
        _secondary_data.N.resize(n_integration_points);
 
        auto& solid_material =
            MaterialLib::Solids::selectSolidConstitutiveRelation(
                _process_data.solid_materials,
                _process_data.material_ids,
                e.getID());
 
        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_tensile.setZero(kelvin_vector_size);
            ip_data.eps.setZero(kelvin_vector_size);
            ip_data.eps_prev.resize(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.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;
        }
    }

References ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data, MeshLib::Element::getID(), NumLib::GenericIntegrationMethod::getNumberOfPoints(), MathLib::WeightedPoint::getWeight(), NumLib::GenericIntegrationMethod::getWeightedPoint(), NumLib::initShapeMatrices(), MathLib::KelvinVector::kelvin_vector_dimensions(), ProcessLib::PhaseField::SecondaryData< ShapeMatrixType >::N, MaterialLib::Solids::selectSolidConstitutiveRelation(), and ParameterLib::SpatialPosition::setElementID().

Member Function Documentation

assemble()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< 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 271 of file PhaseFieldFEM.h.

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

References OGS_FATAL.

assembleWithJacobianForDeformationEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< 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 43 of file PhaseFieldFEM-impl.h.

{
    using DeformationMatrix =
        typename ShapeMatricesType::template MatrixType<displacement_size,
                                                        displacement_size>;
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
    auto const u =
        local_x.template segment<displacement_size>(displacement_index);
 
    auto local_Jac = MathLib::createZeroedMatrix<DeformationMatrix>(
        local_Jac_data, displacement_size, displacement_size);
 
    auto local_rhs = MathLib::createZeroedVector<DeformationVector>(
        local_b_data, displacement_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    auto local_pressure = 0.0;
    if (_process_data.pressurized_crack)
    {
        local_pressure = _process_data.unity_pressure;
    }
 
    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;
        eps.noalias() = B * u;
        double const k = _process_data.residual_stiffness(t, x_position)[0];
        double const ls = _process_data.crack_length_scale(t, x_position)[0];
        double const d_ip = N.dot(d);
        double const degradation =
            _process_data.degradation_derivative->degradation(d_ip, k, ls);
        _ip_data[ip].updateConstitutiveRelation(
            t, x_position, dt, u, degradation,
            _process_data.energy_split_model);
 
        auto& sigma = _ip_data[ip].sigma;
        auto const& D = _ip_data[ip].D;
 
        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_sr = _process_data.solid_density(t, x_position)[0];
        auto const& b = _process_data.specific_body_force;
 
        local_rhs.noalias() -=
            (B.transpose() * sigma - N_u.transpose() * rho_sr * b -
             local_pressure * N_u.transpose() * dNdx * d) *
            w;
        local_Jac.noalias() += B.transpose() * D * B * w;
    }
}

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

assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< 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 23 of file PhaseFieldFEM-impl.h.

{
    // For the equations with phase field.
    if (process_id == phase_process_id)
    {
        assembleWithJacobianPhaseFieldEquations(t, dt, local_x, local_b_data,
                                                local_Jac_data);
        return;
    }
 
    // For the equations with deformation
    assembleWithJacobianForDeformationEquations(t, dt, local_x, local_b_data,
                                                local_Jac_data);
}

assembleWithJacobianPhaseFieldEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianPhaseFieldEquations ( 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 127 of file PhaseFieldFEM-impl.h.

{
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
    auto const u =
        local_x.template segment<displacement_size>(displacement_index);
 
    auto local_Jac = MathLib::createZeroedMatrix<PhaseFieldMatrix>(
        local_Jac_data, phasefield_size, phasefield_size);
    auto local_rhs = MathLib::createZeroedVector<PhaseFieldVector>(
        local_b_data, phasefield_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    auto local_pressure = 0.0;
    if (_process_data.static_pressurized_crack)
    {
        local_pressure = _process_data.unity_pressure;
    }
    else if (_process_data.propagating_pressurized_crack)
    {
        local_pressure = _process_data.pressure;
    }
 
    double const k = _process_data.residual_stiffness(t, x_position)[0];
    double const ls = _process_data.crack_length_scale(t, x_position)[0];
    double const gc = _process_data.crack_resistance(t, x_position)[0];
 
    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;
 
        double const d_ip = N.dot(d);
        double const degradation =
            _process_data.degradation_derivative->degradation(d_ip, k, ls);
        double const degradation_df1 =
            _process_data.degradation_derivative->degradation_df1(d_ip, ls);
        double const degradation_df2 =
            _process_data.degradation_derivative->degradation_df2(d_ip, ls);
        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;
        eps.noalias() = B * u;
        _ip_data[ip].updateConstitutiveRelation(
            t, x_position, dt, u, degradation,
            _process_data.energy_split_model);
 
        auto const& strain_energy_tensile = _ip_data[ip].strain_energy_tensile;
 
        auto& ip_data = _ip_data[ip];
        ip_data.strain_energy_tensile = strain_energy_tensile;
 
        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() +=
            (N.transpose() * N * degradation_df2 * strain_energy_tensile) * w;
 
        local_rhs.noalias() -=
            (N.transpose() * degradation_df1 * strain_energy_tensile -
             local_pressure * dNdx.transpose() * N_u * u) *
            w;
 
        switch (_process_data.phasefield_model)
        {
            case PhaseFieldModel::AT1:
            {
                auto const local_Jac_AT1 =
                    (gc * 0.75 * dNdx.transpose() * dNdx * ls * w).eval();
                local_Jac.noalias() += local_Jac_AT1;
 
                local_rhs.noalias() -=
                    gc * (-0.375 * N.transpose() / ls) * w + local_Jac_AT1 * d;
                break;
            }
            case PhaseFieldModel::AT2:
            {
                auto const local_Jac_AT2 =
                    (gc *
                     (N.transpose() * N / ls + dNdx.transpose() * dNdx * ls) *
                     w)
                        .eval();
                local_Jac.noalias() += local_Jac_AT2;
 
                local_rhs.noalias() -=
                    local_Jac_AT2 * d - gc * (N.transpose() / ls) * w;
                break;
            }
            case PhaseFieldModel::COHESIVE:
            {
                auto const local_Jac_COHESIVE =
                    (2.0 / std::numbers::pi * gc *
                     (-N.transpose() * N / ls + dNdx.transpose() * dNdx * ls) *
                     w)
                        .eval();
 
                local_Jac.noalias() += local_Jac_COHESIVE;
 
                local_rhs.noalias() -= local_Jac_COHESIVE * d;
                break;
            }
        }
    }
}

References ProcessLib::PhaseField::AT1, ProcessLib::PhaseField::AT2, ProcessLib::PhaseField::COHESIVE, ProcessLib::LinearBMatrix::computeBMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), NumLib::interpolateXCoordinate(), ParameterLib::SpatialPosition::setElementID(), and ParameterLib::SpatialPosition::setIntegrationPoint().

computeCrackIntegral()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::computeCrackIntegral ( std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, std::vector< GlobalVector * > const & x, double const t, double & crack_volume )

overridevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 258 of file PhaseFieldFEM-impl.h.

{
    std::vector<std::vector<GlobalIndexType>> indices_of_processes;
    indices_of_processes.reserve(dof_tables.size());
    std::transform(dof_tables.begin(), dof_tables.end(),
                   std::back_inserter(indices_of_processes),
                   [&](auto const dof_table)
                   { return NumLib::getIndices(mesh_item_id, *dof_table); });
 
    auto local_coupled_xs = getCoupledLocalSolutions(x, indices_of_processes);
    assert(local_coupled_xs.size() == displacement_size + phasefield_size);
 
    auto const d = Eigen::Map<PhaseFieldVector const>(
        &local_coupled_xs[phasefield_index], phasefield_size);
    auto const u = Eigen::Map<DeformationVector const>(
        &local_coupled_xs[displacement_index], 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;
 
        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;
        }
 
        crack_volume += (N_u * u).dot(dNdx * d) * w;
    }
}

References ProcessLib::getCoupledLocalSolutions(), ParameterLib::SpatialPosition::setElementID(), and ParameterLib::SpatialPosition::setIntegrationPoint().

computeEnergy()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::computeEnergy ( std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, std::vector< GlobalVector * > const & x, double const t, double & elastic_energy, double & surface_energy, double & pressure_work )

overridevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 309 of file PhaseFieldFEM-impl.h.

{
    std::vector<std::vector<GlobalIndexType>> indices_of_processes;
    indices_of_processes.reserve(dof_tables.size());
    std::transform(dof_tables.begin(), dof_tables.end(),
                   std::back_inserter(indices_of_processes),
                   [&](auto const dof_table)
                   { return NumLib::getIndices(mesh_item_id, *dof_table); });
 
    auto const local_coupled_xs =
        getCoupledLocalSolutions(x, indices_of_processes);
    assert(local_coupled_xs.size() == displacement_size + phasefield_size);
 
    auto const d = Eigen::Map<PhaseFieldVector const>(
        &local_coupled_xs[phasefield_index], phasefield_size);
    auto const u = Eigen::Map<DeformationVector const>(
        &local_coupled_xs[displacement_index], displacement_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    double element_elastic_energy = 0.0;
    double element_surface_energy = 0.0;
    double element_pressure_work = 0.0;
 
    double const gc = _process_data.crack_resistance(t, x_position)[0];
    double const ls = _process_data.crack_length_scale(t, x_position)[0];
    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 pressure_ip = _process_data.pressure;
 
        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;
        }
 
        element_elastic_energy += _ip_data[ip].elastic_energy * w;
 
        double const d_ip = N.dot(d);
        switch (_process_data.phasefield_model)
        {
            case PhaseFieldModel::AT1:
            {
                element_surface_energy +=
                    gc * 0.375 *
                    ((1 - d_ip) / ls + (dNdx * d).dot((dNdx * d)) * ls) * w;
 
                break;
            }
            case PhaseFieldModel::AT2:
            {
                element_surface_energy += 0.5 * gc *
                                          ((1 - d_ip) * (1 - d_ip) / ls +
                                           (dNdx * d).dot((dNdx * d)) * ls) *
                                          w;
                break;
            }
            case PhaseFieldModel::COHESIVE:
            {
                element_surface_energy +=
                    gc / std::numbers::pi *
                    ((1 - d_ip * d_ip) / ls + (dNdx * d).dot((dNdx * d)) * ls) *
                    w;
                break;
            }
        }
 
        if (_process_data.pressurized_crack)
        {
            element_pressure_work += pressure_ip * (N_u * u).dot(dNdx * d) * w;
        }
    }
 
#ifdef USE_PETSC
    int const n_all_nodes = indices_of_processes[1].size();
    int const n_regular_nodes = std::count_if(
        begin(indices_of_processes[1]), end(indices_of_processes[1]),
        [](GlobalIndexType const& index) { return index >= 0; });
    if (n_all_nodes != n_regular_nodes)
    {
        element_elastic_energy *=
            static_cast<double>(n_regular_nodes) / n_all_nodes;
        element_surface_energy *=
            static_cast<double>(n_regular_nodes) / n_all_nodes;
        element_pressure_work *=
            static_cast<double>(n_regular_nodes) / n_all_nodes;
    }
#endif  // USE_PETSC
    elastic_energy += element_elastic_energy;
    surface_energy += element_surface_energy;
    pressure_work += element_pressure_work;
}

References ProcessLib::PhaseField::AT1, ProcessLib::PhaseField::AT2, ProcessLib::PhaseField::COHESIVE, ProcessLib::getCoupledLocalSolutions(), ParameterLib::SpatialPosition::setElementID(), and ParameterLib::SpatialPosition::setIntegrationPoint().

getEpsilon()

template<typename ShapeFunctionDisplacement , int DisplacementDim>

std::vector< double > ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunctionDisplacement, DisplacementDim >::getEpsilon ( ) const

overridevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 464 of file PhaseFieldFEM-impl.h.

{
    auto const kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    std::vector<double> ip_epsilon_values;
    auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
        double, Eigen::Dynamic, kelvin_vector_size, Eigen::RowMajor>>(
        ip_epsilon_values, n_integration_points, kelvin_vector_size);
 
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        auto const& eps = _ip_data[ip].eps;
        cache_mat.row(ip) =
            MathLib::KelvinVector::kelvinVectorToSymmetricTensor(eps);
    }
 
    return ip_epsilon_values;
}

References MathLib::createZeroedMatrix(), MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::kelvinVectorToSymmetricTensor().

getIntPtEpsilon()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverrideprivatevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 394 of file PhaseFieldFEM.h.

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

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

getIntPtEpsilonTensile()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilonTensile ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > & cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 404 of file PhaseFieldFEM.h.

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

References ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::PhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::eps_tensile, and ProcessLib::getIntegrationPointKelvinVectorData().

getIntPtSigma()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverrideprivatevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 364 of file PhaseFieldFEM.h.

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

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

getIntPtSigmaCompressive()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigmaCompressive ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > & cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 384 of file PhaseFieldFEM.h.

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

References ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::getIntegrationPointKelvinVectorData(), and ProcessLib::PhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::sigma_compressive.

getIntPtSigmaTensile()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigmaTensile ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > & cache ) const

inlineoverrideprivatevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 374 of file PhaseFieldFEM.h.

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

References ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::getIntegrationPointKelvinVectorData(), and ProcessLib::PhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::sigma_tensile.

getShapeMatrix()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 347 of file PhaseFieldFEM.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::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data, and ProcessLib::PhaseField::SecondaryData< ShapeMatrixType >::N.

getSigma()

template<typename ShapeFunctionDisplacement , int DisplacementDim>

std::vector< double > ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunctionDisplacement, DisplacementDim >::getSigma ( ) const

overridevirtual

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 456 of file PhaseFieldFEM-impl.h.

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

References ProcessLib::getIntegrationPointKelvinVectorData().

initializeConcrete()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete ( )

inlineoverridevirtual

Set initial stress from parameter.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 289 of file PhaseFieldFEM.h.

    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            auto& ip_data = _ip_data[ip];
 
            ParameterLib::SpatialPosition const x_position{
                std::nullopt, _element.getID(), ip,
                MathLib::Point3d(
                    NumLib::interpolateCoordinates<ShapeFunction,
                                                   ShapeMatricesType>(
                        _element, ip_data.N))};
 
            if (_process_data.initial_stress.value)
            {
                ip_data.sigma =
                    MathLib::KelvinVector::symmetricTensorToKelvinVector<
                        DisplacementDim>((*_process_data.initial_stress.value)(
                        std::numeric_limits<
                            double>::quiet_NaN() /* time independent */,
                        x_position));
            }
 
            ip_data.pushBackState();
        }
    }

References ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data, MeshLib::Element::getID(), NumLib::GenericIntegrationMethod::getNumberOfPoints(), NumLib::interpolateCoordinates(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

postTimestepConcrete()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 320 of file PhaseFieldFEM.h.

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

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

setIPDataInitialConditions()

template<typename ShapeFunctionDisplacement , int DisplacementDim>

std::size_t ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunctionDisplacement, DisplacementDim >::setIPDataInitialConditions ( std::string_view const name, double const * values, int const integration_order )

overridevirtual

Returns number of read integration points.

Implements ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface.

Definition at line 422 of file PhaseFieldFEM-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")
    {
        if (_process_data.initial_stress.value != nullptr)
        {
            OGS_FATAL(
                "Setting initial conditions for stress from integration "
                "point data and from a parameter '{:s}' is not possible "
                "simultaneously.",
                _process_data.initial_stress.value->name);
        }
 
        return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
            values, _ip_data, &IpData::sigma);
    }
 
    return 0;
}

References OGS_FATAL, and ProcessLib::setIntegrationPointKelvinVectorData().

Member Data Documentation

_element

template<typename ShapeFunction , int DisplacementDim>

MeshLib::Element const& ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element

private

Definition at line 427 of file PhaseFieldFEM.h.

Referenced by ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), and ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete().

_integration_method

template<typename ShapeFunction , int DisplacementDim>

NumLib::GenericIntegrationMethod const& ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method

private

Definition at line 426 of file PhaseFieldFEM.h.

Referenced by ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), and ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete().

_ip_data

template<typename ShapeFunction , int DisplacementDim>

std::vector<IpData, Eigen::aligned_allocator<IpData> > ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data

private

Definition at line 424 of file PhaseFieldFEM.h.

Referenced by ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilon(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilonTensile(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigma(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigmaCompressive(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigmaTensile(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), and ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete().

_is_axially_symmetric

template<typename ShapeFunction , int DisplacementDim>

bool const ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_is_axially_symmetric

private

Definition at line 429 of file PhaseFieldFEM.h.

_process_data

template<typename ShapeFunction , int DisplacementDim>

PhaseFieldProcessData<DisplacementDim>& ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data

private

Definition at line 422 of file PhaseFieldFEM.h.

Referenced by ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), and ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete().

_secondary_data

template<typename ShapeFunction , int DisplacementDim>

SecondaryData<typename ShapeMatrices::ShapeType> ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data

private

Definition at line 428 of file PhaseFieldFEM.h.

Referenced by ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), and ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getShapeMatrix().

displacement_index

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::displacement_index = 0

staticconstexprprivate

Definition at line 173 of file PhaseFieldFEM.h.

displacement_size

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::displacement_size

staticconstexprprivate

Initial value:

=
        ShapeFunction::NPOINTS * DisplacementDim

Definition at line 174 of file PhaseFieldFEM.h.

mechanics_process_id

template<typename ShapeFunction , int DisplacementDim>

const int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::mechanics_process_id = 0

staticprivate

Definition at line 432 of file PhaseFieldFEM.h.

phase_process_id

template<typename ShapeFunction , int DisplacementDim>

const int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::phase_process_id = 1

staticprivate

Definition at line 431 of file PhaseFieldFEM.h.

phasefield_index

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::phasefield_index

staticconstexprprivate

Initial value:

=
        displacement_index + displacement_size

Definition at line 176 of file PhaseFieldFEM.h.

phasefield_size

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::phasefield_size = ShapeFunction::NPOINTS

staticconstexprprivate

Definition at line 178 of file PhaseFieldFEM.h.

---

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

• ProcessLib/PhaseField/PhaseFieldFEM.h
• ProcessLib/PhaseField/PhaseFieldFEM-impl.h