ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int DisplacementDim>
class ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >

Definition at line 113 of file HMPhaseFieldFEM.h.

#include <HMPhaseFieldFEM.h>

Inheritance diagram for ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

Collaboration diagram for ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >:

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	DeformationVector
using	DeformationMatrix
using	PhaseFieldVector
using	PhaseFieldMatrix
using	PressureVector
using	PressureMatrix
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	IpData
using	Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>

Public Member Functions
	HMPhaseFieldLocalAssembler (HMPhaseFieldLocalAssembler const &)=delete
	HMPhaseFieldLocalAssembler (HMPhaseFieldLocalAssembler &&)=delete
	HMPhaseFieldLocalAssembler (MeshLib::Element const &e, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, HMPhaseFieldProcessData< DisplacementDim > &process_data)
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	postNonLinearSolverConcrete (Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, double const t, double const dt, int const process_id) override
void	approximateFractureWidth (std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double const dt) 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
double	heaviside (double const v)
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
std::vector< double > const &	getIntPtWidth (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
Public Member Functions inherited from ProcessLib::HMPhaseField::HMPhaseFieldLocalAssemblerInterface
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	assemble (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
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.
virtual std::optional< VectorSegment >	getVectorDeformationSegment () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Static Public Attributes
static int const	KelvinVectorSize
static constexpr auto &	N_u_op

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
void	assembleWithJacobianHydroEquations (const double t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
void	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
HMPhaseFieldProcessData< 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	phasefield_index = 0
static constexpr int	phasefield_size = ShapeFunction::NPOINTS
static constexpr int	pressure_index = phasefield_index + phasefield_size
static constexpr int	pressure_size = ShapeFunction::NPOINTS
static constexpr int	displacement_index = pressure_index + pressure_size
static constexpr int	displacement_size

Member Typedef Documentation

BMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 130 of file HMPhaseFieldFEM.h.

DeformationMatrix

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::DeformationMatrix

Initial value:

 
        typename ShapeMatricesType::template MatrixType<displacement_size,
                                                        displacement_size>

Definition at line 138 of file HMPhaseFieldFEM.h.

DeformationVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::DeformationVector

Initial value:

 
        typename ShapeMatricesType::template VectorType<displacement_size>

Definition at line 136 of file HMPhaseFieldFEM.h.

GlobalDimVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

Definition at line 134 of file HMPhaseFieldFEM.h.

Invariants

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>

Definition at line 163 of file HMPhaseFieldFEM.h.

IpData

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::IpData

Initial value:

 
        IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 154 of file HMPhaseFieldFEM.h.

NodalForceVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 132 of file HMPhaseFieldFEM.h.

NodalMatrixType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 152 of file HMPhaseFieldFEM.h.

NodalVectorType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 153 of file HMPhaseFieldFEM.h.

PhaseFieldMatrix

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldMatrix

Initial value:

 
        typename ShapeMatricesType::template MatrixType<phasefield_size,
                                                        phasefield_size>

Definition at line 143 of file HMPhaseFieldFEM.h.

PhaseFieldVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldVector

Initial value:

 
        typename ShapeMatricesType::template VectorType<phasefield_size>

Definition at line 141 of file HMPhaseFieldFEM.h.

PressureMatrix

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PressureMatrix

Initial value:

 
        typename ShapeMatricesType::template MatrixType<pressure_size,
                                                        pressure_size>

Definition at line 148 of file HMPhaseFieldFEM.h.

PressureVector

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PressureVector

Initial value:

 
        typename ShapeMatricesType::template VectorType<pressure_size>

Definition at line 146 of file HMPhaseFieldFEM.h.

ShapeMatrices

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 128 of file HMPhaseFieldFEM.h.

ShapeMatricesType

template<typename ShapeFunction , int DisplacementDim>

using ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ShapeMatricesType

Initial value:

 
        ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 125 of file HMPhaseFieldFEM.h.

Constructor & Destructor Documentation

HMPhaseFieldLocalAssembler() [1/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler ( HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > const & )

delete

HMPhaseFieldLocalAssembler() [2/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler ( HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim > && )

delete

HMPhaseFieldLocalAssembler() [3/3]

template<typename ShapeFunction , int DisplacementDim>

ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler ( MeshLib::Element const & e, std::size_t const , NumLib::GenericIntegrationMethod const & integration_method, bool const is_axially_symmetric, HMPhaseFieldProcessData< DisplacementDim > & process_data )

inline

Definition at line 168 of file HMPhaseFieldFEM.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.C_tensile.setZero(kelvin_vector_size, kelvin_vector_size);
            ip_data.C_compressive.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.width_ip = 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::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data, MeshLib::Element::getID(), NumLib::GenericIntegrationMethod::getNumberOfPoints(), MathLib::WeightedPoint::getWeight(), NumLib::GenericIntegrationMethod::getWeightedPoint(), NumLib::initShapeMatrices(), MathLib::KelvinVector::kelvin_vector_dimensions(), ProcessLib::HMPhaseField::SecondaryData< ShapeMatrixType >::N, MaterialLib::Solids::selectSolidConstitutiveRelation(), and ParameterLib::SpatialPosition::setElementID().

Member Function Documentation

approximateFractureWidth()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::approximateFractureWidth ( std::size_t mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, std::vector< GlobalVector * > const & x, double const t, double const dt )

overridevirtual

Implements ProcessLib::HMPhaseField::HMPhaseFieldLocalAssemblerInterface.

Definition at line 455 of file HMPhaseFieldFEM-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() ==
           phasefield_size + displacement_size + pressure_size);
 
    auto const d = Eigen::Map<PhaseFieldVector const>(
        &local_coupled_xs[phasefield_index], phasefield_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    double const ele_d = std::clamp(d.sum() / d.size(), 0.0, 1.0);
    (*_process_data.ele_d)[_element.getID()] = ele_d;
 
    if ((*_process_data.ele_d)[_element.getID()] <
        _process_data.irreversible_threshold)
    {
        double const width_init = _process_data.width_init(t, x_position)[0];
        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 he = ls / _process_data.diffused_range_parameter;
 
        int const n_integration_points =
            _integration_method.getNumberOfPoints();
        double width = 0.0;
        for (int ip = 0; ip < n_integration_points; ip++)
        {
            auto eps_tensor =
                MathLib::KelvinVector::kelvinVectorToTensor(_ip_data[ip].eps);
            Eigen::EigenSolver<decltype(eps_tensor)> eigen_solver(eps_tensor);
            Eigen::MatrixXf::Index maxIndex;
            double const max_principal_strain =
                eigen_solver.eigenvalues().real().maxCoeff(&maxIndex);
            auto const max_eigen_vector =
                eigen_solver.eigenvectors().real().col(maxIndex);
 
            // Fracture aperture estimation
            auto& width_ip = _ip_data[ip].width_ip;
            width_ip = max_principal_strain * he;
            width_ip = width_ip < width_init ? width_init : width_ip;
            width += width_ip;
 
            // Fracture direction estimation
            auto& normal_ip = _ip_data[ip].normal_ip;
            if (std::abs(max_principal_strain) > k)
            {
                for (int i = 0; i < DisplacementDim; i++)
                {
                    normal_ip[i] = max_eigen_vector[i];
                }
            }
 
            // Fracture enhanced porosity
            auto& fracture_enhanced_porosity =
                _ip_data[ip].fracture_enhanced_porosity;
            fracture_enhanced_porosity = width_ip / he;
        }
 
        // Update aperture for the fractured element
        (*_process_data.width)[_element.getID()] = width / n_integration_points;
    }
}

References ProcessLib::getCoupledLocalSolutions(), MathLib::KelvinVector::kelvinVectorToTensor(), and ParameterLib::SpatialPosition::setElementID().

assembleWithJacobianForDeformationEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< 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 61 of file HMPhaseFieldFEM-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 const p = local_x.template segment<pressure_size>(pressure_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 const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& solid = medium->phase("Solid");
    auto const& fluid = fluidPhase(*medium);
    MPL::VariableArray vars;
 
    double const k = _process_data.residual_stiffness(t, x_position)[0];
    double const ls = _process_data.crack_length_scale(t, x_position)[0];
 
    auto const& identity2 = Invariants::identity2;
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
        double const d_ip = N.dot(d);
        double const p_ip = N.dot(p);
 
        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 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 const& sigma = _ip_data[ip].sigma;
        auto const& D = _ip_data[ip].D;
 
        auto& biot_coefficient = _ip_data[ip].biot_coefficient;
        auto& biot_modulus_inv = _ip_data[ip].biot_modulus_inv;
        auto const& fracture_enhanced_porosity =
            _ip_data[ip].fracture_enhanced_porosity;
 
        // Update the effective bulk modulus
        auto const& P_sph = Invariants::spherical_projection;
        auto const D_sph = P_sph * D * identity2;
        double const bulk_modulus_eff = Invariants::trace(D_sph) / 9.;
 
        auto const& solid_material =
            MaterialLib::Solids::selectSolidConstitutiveRelation(
                _process_data.solid_materials, _process_data.material_ids,
                _element.getID());
        auto const bulk_modulus = solid_material.getBulkModulus(t, x_position);
        auto const alpha_0 =
            solid.property(MPL::PropertyType::biot_coefficient)
                .template value<double>(vars, x_position, t, dt);
        auto const porosity_0 =
            medium->property(MPL::PropertyType::porosity)
                .template value<double>(vars, x_position, t, dt);
        double const bulk_modulus_degradation = bulk_modulus_eff / bulk_modulus;
 
        // Update Biot's coefficient
        biot_coefficient = 1. - bulk_modulus_degradation * (1. - alpha_0);
 
        // The reference porosity
        auto const porosity_reference = porosity_0 + fracture_enhanced_porosity;
 
        // Update Biot's modulus
        biot_modulus_inv = bulk_modulus_degradation * (alpha_0 - porosity_0) *
                           (1. - alpha_0) / bulk_modulus;
 
        auto const rho_sr =
            solid.property(MPL::PropertyType::density)
                .template value<double>(vars, x_position, t, dt);
        auto const rho_fr =
            fluid.property(MPL::PropertyType::density)
                .template value<double>(vars, x_position, t, dt);
 
        auto const rho =
            rho_sr * (1. - porosity_reference) + porosity_reference * rho_fr;
        auto const& b = _process_data.specific_body_force;
 
        local_rhs.noalias() -=
            (B.transpose() * (sigma - biot_coefficient * p_ip * identity2) -
             N_u_op(N).transpose() * rho * b) *
            w;
        local_Jac.noalias() += B.transpose() * D * B * w;
    }
}

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

assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< 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 31 of file HMPhaseFieldFEM-impl.h.

{
    // For the equations with phase field.
    if (process_id == _process_data._phasefield_process_id)
    {
        assembleWithJacobianPhaseFieldEquations(t, dt, local_x, local_b_data,
                                                local_Jac_data);
        return;
    }
 
    // For the equations for hydro
    if (process_id == _process_data._hydro_process_id)
    {
        assembleWithJacobianHydroEquations(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);
}

assembleWithJacobianHydroEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianHydroEquations ( const double t, double const dt, Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, std::vector< double > & local_b_data, std::vector< double > & local_Jac_data )

private

Definition at line 174 of file HMPhaseFieldFEM-impl.h.

{
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
 
    auto const p = local_x.template segment<pressure_size>(pressure_index);
    auto const p_prev =
        local_x_prev.template segment<pressure_size>(pressure_index);
 
    auto local_Jac = MathLib::createZeroedMatrix<PressureMatrix>(
        local_Jac_data, pressure_size, pressure_size);
 
    auto local_rhs = MathLib::createZeroedVector<PressureVector>(local_b_data,
                                                                 pressure_size);
 
    typename ShapeMatricesType::NodalMatrixType mass =
        ShapeMatricesType::NodalMatrixType::Zero(pressure_size, pressure_size);
 
    typename ShapeMatricesType::NodalMatrixType laplace =
        ShapeMatricesType::NodalMatrixType::Zero(pressure_size, pressure_size);
 
    typename ShapeMatricesType::NodalMatrixType stablizing =
        ShapeMatricesType::NodalMatrixType::Zero(pressure_size, pressure_size);
 
    ParameterLib::SpatialPosition x_position;
    x_position.setElementID(_element.getID());
 
    auto const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& fluid = fluidPhase(*medium);
    MPL::VariableArray vars;
 
    auto const& P_sph = Invariants::spherical_projection;
    auto const& P_dev = Invariants::deviatoric_projection;
    auto const& identity2 = Invariants::identity2;
    auto const& ones2 = Invariants::ones2;
 
    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 width = (*_process_data.width)[_element.getID()];
    double const fracture_threshold = _process_data.fracture_threshold;
    double const fracture_permeability_parameter =
        _process_data.fracture_permeability_parameter;
    double const fixed_stress_stabilization_parameter =
        _process_data.fixed_stress_stabilization_parameter;
    double const spatial_stabilization_parameter =
        _process_data.spatial_stabilization_parameter;
    auto const he =
        ls / _process_data.diffused_range_parameter;  // element size
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
        double const d_ip = N.dot(d);
 
        auto const rho_fr =
            fluid.property(MPL::PropertyType::density)
                .template value<double>(vars, x_position, t, dt);
        double const cf = _process_data.fluid_compressibility;
        auto const Km = medium->property(MPL::PropertyType::permeability)
                            .template value<double>(vars, x_position, t, dt);
        auto const K = MPL::formEigenTensor<DisplacementDim>(Km);
        auto const mu = fluid.property(MPL::PropertyType::viscosity)
                            .template value<double>(vars, x_position, t, dt);
 
        auto const vol_strain = Invariants::trace(_ip_data[ip].eps);
        auto const vol_strain_prev = Invariants::trace(_ip_data[ip].eps_prev);
        auto const& biot_coefficient = _ip_data[ip].biot_coefficient;
        auto const& biot_modulus_inv = _ip_data[ip].biot_modulus_inv;
        auto const& fracture_enhanced_porosity =
            _ip_data[ip].fracture_enhanced_porosity;
 
        // The reference porosity
        auto const porosity_0 =
            medium->property(MPL::PropertyType::porosity)
                .template value<double>(vars, x_position, t, dt);
        auto const porosity_reference = porosity_0 + fracture_enhanced_porosity;
 
        double const dv_dt = (vol_strain - vol_strain_prev) / dt;
 
        // The degraded shear modulus
        auto const& D = _ip_data[ip].D;
        auto const D_sph = P_sph * D * identity2;
        auto const D_dev = P_dev * D * (ones2 - identity2) / std::sqrt(2.);
        auto const degraded_shear_modulus =
            Invariants::FrobeniusNorm(D_dev) / 2.;
        auto const degraded_bulk_modulus = Invariants::trace(D_sph) / 9.;
 
        double const residual_bulk_modulus = [&]
        {
            if ((*_process_data.ele_d)[_element.getID()] <
                _process_data.fracture_threshold)
            {
                // The residual bulk modulus in the fractured element
                double const degradation_threshold =
                    _process_data.degradation_derivative->degradation(
                        fracture_threshold, k, ls);
                auto const& D_threshold =
                    degradation_threshold * _ip_data[ip].C_tensile +
                    _ip_data[ip].C_compressive;
                auto const D_sph_threshold = P_sph * D_threshold * identity2;
 
                return Invariants::trace(D_sph_threshold) / 9.;
            }
            return degraded_bulk_modulus;
        }();
 
        double const modulus_rm = fixed_stress_stabilization_parameter *
                                  biot_coefficient * biot_coefficient /
                                  residual_bulk_modulus;
 
        double const stablization_spatial =
            spatial_stabilization_parameter * 0.25 * he * he /
            (degraded_bulk_modulus + 4. / 3. * degraded_shear_modulus);
        stablizing.noalias() +=
            dNdx.transpose() * stablization_spatial * dNdx * w;
 
        mass.noalias() +=
            (biot_modulus_inv + cf * porosity_reference + modulus_rm) *
            N.transpose() * N * w;
 
        auto const K_over_mu = K / mu;
        laplace.noalias() += dNdx.transpose() * K_over_mu * dNdx * w;
        auto const& b = _process_data.specific_body_force;
 
        // bodyforce-driven Darcy flow
        local_rhs.noalias() += dNdx.transpose() * rho_fr * K_over_mu * b * w;
 
        local_rhs.noalias() -= (biot_coefficient * dv_dt -
                                modulus_rm * _ip_data[ip].coupling_pressure) *
                               N.transpose() * w;
 
        if ((*_process_data.ele_d)[_element.getID()] <
            _process_data.irreversible_threshold)
        {
            // Fracture-enhanced permeability
            auto const& normal_ip = _ip_data[ip].normal_ip;
            auto const Kf =
                std::pow(1. - d_ip, fracture_permeability_parameter) * width *
                width * width / he / 12.0 *
                (Eigen::Matrix<double, DisplacementDim,
                               DisplacementDim>::Identity() -
                 normal_ip * normal_ip.transpose());
            laplace.noalias() += dNdx.transpose() * Kf / mu * dNdx * w;
        }
    }
    local_Jac.noalias() = laplace + mass / dt + stablizing / dt;
 
    local_rhs.noalias() -=
        laplace * p + mass * (p - p_prev) / dt + stablizing * (p - p_prev) / dt;
}

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

assembleWithJacobianPhaseFieldEquations()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< 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 333 of file HMPhaseFieldFEM-impl.h.

{
    auto const d = local_x.template segment<phasefield_size>(phasefield_index);
    auto const p = local_x.template segment<pressure_size>(pressure_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 const& solid_material =
        MaterialLib::Solids::selectSolidConstitutiveRelation(
            _process_data.solid_materials, _process_data.material_ids,
            _element.getID());
 
    auto const bulk_modulus = solid_material.getBulkModulus(t, x_position);
    auto const& medium = _process_data.media_map.getMedium(_element.getID());
    auto const& solid = medium->phase("Solid");
    MPL::VariableArray vars;
 
    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];
 
    auto const& identity2 = Invariants::identity2;
 
    int const n_integration_points = _integration_method.getNumberOfPoints();
    for (int ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        double const d_ip = N.dot(d);
        double const p_ip = N.dot(p);
        double const degradation =
            _process_data.degradation_derivative->degradation(d_ip, k, ls);
        double const degradation_df1 =
            _process_data.degradation_derivative->degradationDf1(d_ip, k, ls);
        double const degradation_df2 =
            _process_data.degradation_derivative->degradationDf2(d_ip, k, ls);
 
        _ip_data[ip].updateConstitutiveRelation(
            t, x_position, dt, u, degradation,
            _process_data.energy_split_model);
 
        auto& biot_coefficient = _ip_data[ip].biot_coefficient;
        auto& biot_modulus_inv = _ip_data[ip].biot_modulus_inv;
 
        auto const alpha_0 =
            solid.property(MPL::PropertyType::biot_coefficient)
                .template value<double>(vars, x_position, t, dt);
        auto const porosity_0 =
            medium->property(MPL::PropertyType::porosity)
                .template value<double>(vars, x_position, t, dt);
 
        auto const& D = _ip_data[ip].D;
        auto const& P_sph = Invariants::spherical_projection;
        auto const D_sph = P_sph * D * identity2;
        double const bulk_modulus_eff = Invariants::trace(D_sph) / 9.;
        double const bulk_modulus_degradation = bulk_modulus_eff / bulk_modulus;
 
        // Update Biot's coefficient
        biot_coefficient = 1. - bulk_modulus_degradation * (1. - alpha_0);
 
        // Update Biot's modulus
        biot_modulus_inv = bulk_modulus_degradation * (alpha_0 - porosity_0) *
                           (1. - alpha_0) / bulk_modulus;
 
        auto const& strain_energy_tensile = _ip_data[ip].strain_energy_tensile;
        auto const& C_tensile = _ip_data[ip].C_tensile;
        auto const C_tensile_sph = P_sph * C_tensile * identity2;
        double const bulk_modulus_plus = Invariants::trace(C_tensile_sph) / 9.;
 
        auto const driven_energy =
            N.transpose() *
            (strain_energy_tensile + p_ip * p_ip / 2. * bulk_modulus_plus /
                                         bulk_modulus * (alpha_0 - porosity_0) *
                                         (1. - alpha_0) / bulk_modulus) *
            w;
 
        local_Jac.noalias() += driven_energy * N * degradation_df2;
 
        local_rhs.noalias() -= driven_energy * degradation_df1;
 
        calculateCrackLocalJacobianAndResidual<
            decltype(dNdx), decltype(N), decltype(w), decltype(d),
            decltype(local_Jac), decltype(local_rhs)>(
            dNdx, N, w, d, local_Jac, local_rhs, gc, ls,
            _process_data.phasefield_model);
    }
}

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

computeEnergy()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< 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::HMPhaseField::HMPhaseFieldLocalAssemblerInterface.

Definition at line 532 of file HMPhaseFieldFEM-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() ==
           phasefield_size + displacement_size + pressure_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);
    auto const p = Eigen::Map<PressureVector const>(
        &local_coupled_xs[pressure_index], pressure_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++)
    {
        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 p_ip = N.dot(p);
 
        element_elastic_energy += _ip_data[ip].elastic_energy * w;
 
        switch (_process_data.phasefield_model)
        {
            case MaterialLib::Solids::Phasefield::PhaseFieldModel::AT1:
            {
                element_surface_energy +=
                    gc * 0.375 *
                    ((1 - d_ip) / ls + (dNdx * d).dot((dNdx * d)) * ls) * w;
 
                break;
            }
            case MaterialLib::Solids::Phasefield::PhaseFieldModel::AT2:
            {
                element_surface_energy += 0.5 * gc *
                                          ((1 - d_ip) * (1 - d_ip) / ls +
                                           (dNdx * d).dot((dNdx * d)) * ls) *
                                          w;
                break;
            }
            case MaterialLib::Solids::Phasefield::PhaseFieldModel::COHESIVE:
            {
                element_surface_energy +=
                    gc / std::numbers::pi *
                    ((1 - d_ip * d_ip) / ls + (dNdx * d).dot((dNdx * d)) * ls) *
                    w;
                break;
            }
        }
 
        element_pressure_work += p_ip * (N_u_op(N) * 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 MaterialLib::Solids::Phasefield::AT1, MaterialLib::Solids::Phasefield::AT2, MaterialLib::Solids::Phasefield::COHESIVE, ProcessLib::getCoupledLocalSolutions(), and ParameterLib::SpatialPosition::setElementID().

getIntPtEpsilon()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverrideprivatevirtual

Implements ProcessLib::HMPhaseField::HMPhaseFieldLocalAssemblerInterface.

Definition at line 322 of file HMPhaseFieldFEM.h.

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

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

getIntPtSigma()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverrideprivatevirtual

Implements ProcessLib::HMPhaseField::HMPhaseFieldLocalAssemblerInterface.

Definition at line 312 of file HMPhaseFieldFEM.h.

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

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

getIntPtWidth()

template<typename ShapeFunction , int DisplacementDim>

std::vector< double > const & ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtWidth ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > & cache ) const

overridevirtual

Implements ProcessLib::HMPhaseField::HMPhaseFieldLocalAssemblerInterface.

Definition at line 630 of file HMPhaseFieldFEM-impl.h.

{
    return ProcessLib::getIntegrationPointScalarData(_ip_data,
                                                     &IpData::width_ip, cache);
}

References ProcessLib::getIntegrationPointScalarData().

getShapeMatrix()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 296 of file HMPhaseFieldFEM.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::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data, and ProcessLib::HMPhaseField::SecondaryData< ShapeMatrixType >::N.

heaviside()

template<typename ShapeFunction , int DisplacementDim>

double ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::heaviside ( double const v )

inline

Definition at line 294 of file HMPhaseFieldFEM.h.

{ return (v < 0) ? 0.0 : 1.0; }

initializeConcrete()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete ( )

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 238 of file HMPhaseFieldFEM.h.

    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            _ip_data[ip].pushBackState();
 
            // Specify the direction of preexisting fracture if it exists. The
            // default value is zero.
            auto& normal_ip = _ip_data[ip].normal_ip;
            auto const fracture_normal =
                _process_data.specific_fracture_direction;
            normal_ip = fracture_normal;
        }
        // Specify the aperture of preexisting fractures if they exist. The
        // default value is zero.
        ParameterLib::SpatialPosition x_position;
        x_position.setElementID(_element.getID());
        auto const width_init = _process_data.width_init(0, x_position)[0];
        (*_process_data.width)[_element.getID()] = width_init;
    }

References ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data, ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data, MeshLib::Element::getID(), NumLib::GenericIntegrationMethod::getNumberOfPoints(), and ParameterLib::SpatialPosition::setElementID().

postNonLinearSolverConcrete()

template<typename ShapeFunction , int DisplacementDim>

void ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::postNonLinearSolverConcrete ( Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, double const t, double const dt, int const process_id )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 436 of file HMPhaseFieldFEM-impl.h.

{
    int const n_integration_points = _integration_method.getNumberOfPoints();
    auto const p = local_x.template segment<pressure_size>(pressure_index);
    auto const p_prev =
        local_x_prev.template segment<pressure_size>(pressure_index);
 
    for (int ip = 0; ip < n_integration_points; ip++)
    {
        auto const& N = _ip_data[ip].N;
        _ip_data[ip].coupling_pressure = N.dot(p - p_prev) / dt;
    }
}

postTimestepConcrete()

template<typename ShapeFunction , int DisplacementDim>

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

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 262 of file HMPhaseFieldFEM.h.

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

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

Member Data Documentation

_element

template<typename ShapeFunction , int DisplacementDim>

MeshLib::Element const& ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_element

private

Definition at line 350 of file HMPhaseFieldFEM.h.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), and ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete().

_integration_method

template<typename ShapeFunction , int DisplacementDim>

NumLib::GenericIntegrationMethod const& ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_integration_method

private

Definition at line 349 of file HMPhaseFieldFEM.h.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), and ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete().

_ip_data

template<typename ShapeFunction , int DisplacementDim>

std::vector<IpData, Eigen::aligned_allocator<IpData> > ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_ip_data

private

Definition at line 347 of file HMPhaseFieldFEM.h.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtEpsilon(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getIntPtSigma(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), and ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete().

_is_axially_symmetric

template<typename ShapeFunction , int DisplacementDim>

bool const ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_is_axially_symmetric

private

Definition at line 352 of file HMPhaseFieldFEM.h.

_process_data

template<typename ShapeFunction , int DisplacementDim>

HMPhaseFieldProcessData<DisplacementDim>& ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_process_data

private

Definition at line 345 of file HMPhaseFieldFEM.h.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), and ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete().

_secondary_data

template<typename ShapeFunction , int DisplacementDim>

SecondaryData<typename ShapeMatrices::ShapeType> ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::_secondary_data

private

Definition at line 351 of file HMPhaseFieldFEM.h.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), and ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::getShapeMatrix().

displacement_index

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::displacement_index = pressure_index + pressure_size

staticconstexprprivate

Definition at line 120 of file HMPhaseFieldFEM.h.

displacement_size

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::displacement_size

staticconstexprprivate

Initial value:

=
        ShapeFunction::NPOINTS * DisplacementDim

Definition at line 121 of file HMPhaseFieldFEM.h.

KelvinVectorSize

template<typename ShapeFunction , int DisplacementDim>

int const ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::KelvinVectorSize

static

Initial value:

=
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)

Definition at line 157 of file HMPhaseFieldFEM.h.

N_u_op

template<typename ShapeFunction , int DisplacementDim>

auto& ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::N_u_op

staticconstexpr

Initial value:

= MathLib::eigenBlockMatrixView<
        DisplacementDim, typename ShapeMatricesType::NodalRowVectorType>

Definition at line 160 of file HMPhaseFieldFEM.h.

phasefield_index

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::phasefield_index = 0

staticconstexprprivate

Definition at line 116 of file HMPhaseFieldFEM.h.

phasefield_size

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::phasefield_size = ShapeFunction::NPOINTS

staticconstexprprivate

Definition at line 117 of file HMPhaseFieldFEM.h.

pressure_index

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::pressure_index = phasefield_index + phasefield_size

staticconstexprprivate

Definition at line 118 of file HMPhaseFieldFEM.h.

pressure_size

template<typename ShapeFunction , int DisplacementDim>

int ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::pressure_size = ShapeFunction::NPOINTS

staticconstexprprivate

Definition at line 119 of file HMPhaseFieldFEM.h.

---

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

• ProcessLib/HMPhaseField/HMPhaseFieldFEM.h
• ProcessLib/HMPhaseField/HMPhaseFieldFEM-impl.h