Detailed Description

template<typename ShapeFunction, int DisplacementDim>
class ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >

Definition at line 30 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

#include <SmallDeformationLocalAssemblerMatrixNearFracture.h>

Inheritance diagram for ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >:

[legend]

Collaboration diagram for ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >:

[legend]

Public Types
using	ShapeMatricesType
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>
using	BBarMatrixType = typename BMatricesType::BBarMatrixType
using	BMatrixType = typename BMatricesType::BMatrixType
using	StiffnessMatrixType = typename BMatricesType::StiffnessMatrixType
using	NodalForceVectorType = typename BMatricesType::NodalForceVectorType
using	NodalDisplacementVectorType

Public Member Functions
	SmallDeformationLocalAssemblerMatrixNearFracture (SmallDeformationLocalAssemblerMatrixNearFracture const &)=delete
	SmallDeformationLocalAssemblerMatrixNearFracture (SmallDeformationLocalAssemblerMatrixNearFracture &&)=delete
	SmallDeformationLocalAssemblerMatrixNearFracture (MeshLib::Element const &e, std::size_t const n_variables, std::size_t const local_matrix_size, std::vector< unsigned > const &dofIndex_to_localIndex, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, SmallDeformationProcessData< DisplacementDim > &process_data)
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	assembleWithJacobian (double const t, double const dt, Eigen::VectorXd const &local_u, Eigen::VectorXd &local_b, Eigen::MatrixXd &local_J) override
void	preTimestepConcrete (std::vector< double > const &, double const, double const) override
void	computeSecondaryVariableConcreteWithVector (double const t, Eigen::VectorXd const &local_x) 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 > const &	getIntPtSigma (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::vector< double > const &	getIntPtEpsilon (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::vector< double > const &	getIntPtFractureStress (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
std::vector< double > const &	getIntPtFractureAperture (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
Public Member Functions inherited from ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface
	SmallDeformationLocalAssemblerInterface ()
	SmallDeformationLocalAssemblerInterface (std::size_t n_local_size, std::vector< unsigned > dofIndex_to_localIndex)
void	assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x_, std::vector< double > const &, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override
void	computeSecondaryVariableConcrete (double const t, double const, Eigen::VectorXd const &local_x, Eigen::VectorXd const &) override
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	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)
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 int	getNumberOfVectorElementsForDeformation () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Types
using	IntegrationPointDataType

Private Member Functions
std::optional< BBarMatrixType >	getDilatationalBBarMatrix () const

Private Attributes
SmallDeformationProcessData< DisplacementDim > &	_process_data
std::vector< FractureProperty * >	_fracture_props
std::vector< JunctionProperty * >	_junction_props
std::unordered_map< int, int >	_fracID_to_local
std::vector< IntegrationPointDataType, Eigen::aligned_allocator< IntegrationPointDataType > >	_ip_data
NumLib::GenericIntegrationMethod const &	_integration_method
MeshLib::Element const &	_element
bool const	_is_axially_symmetric
SecondaryData< typename ShapeMatrices::ShapeType >	_secondary_data

Member Typedef Documentation

◆ BBarMatrixType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::BBarMatrixType = typename BMatricesType::BBarMatrixType

Definition at line 40 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ BMatricesType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 39 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ BMatrixType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::BMatrixType = typename BMatricesType::BMatrixType

Definition at line 42 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ IntegrationPointDataType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::IntegrationPointDataType

private

Initial value:

 
        IntegrationPointDataMatrix<ShapeMatricesType, BMatricesType,
                                   DisplacementDim>

Definition at line 142 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ NodalDisplacementVectorType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::NodalDisplacementVectorType

Initial value:

typename BMatricesType::NodalForceVectorType

ProcessLib::BMatrixPolicyType::NodalForceVectorType

VectorType< _number_of_dof > NodalForceVectorType

Rhs residual.

Definition BMatrixPolicy.h:37

Definition at line 45 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ NodalForceVectorType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 44 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ NodalMatrixType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 36 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ NodalVectorType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 37 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ ShapeMatrices

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 38 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ ShapeMatricesType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::ShapeMatricesType

Initial value:

ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

ShapeMatrixPolicyType

EigenFixedShapeMatrixPolicy< ShapeFunction, GlobalDim > ShapeMatrixPolicyType

Definition ShapeMatrixPolicy.h:134

Definition at line 34 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

◆ StiffnessMatrixType

template<typename ShapeFunction, int DisplacementDim>

using ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::StiffnessMatrixType = typename BMatricesType::StiffnessMatrixType

Definition at line 43 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

Constructor & Destructor Documentation

◆ SmallDeformationLocalAssemblerMatrixNearFracture() [1/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture ( SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim > const & )

delete

References SmallDeformationLocalAssemblerMatrixNearFracture().

Referenced by SmallDeformationLocalAssemblerMatrixNearFracture(), and SmallDeformationLocalAssemblerMatrixNearFracture().

◆ SmallDeformationLocalAssemblerMatrixNearFracture() [2/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture ( SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim > && )

delete

References SmallDeformationLocalAssemblerMatrixNearFracture().

◆ SmallDeformationLocalAssemblerMatrixNearFracture() [3/3]

template<typename ShapeFunction, int DisplacementDim>

ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture	(	MeshLib::Element const &	e,
		std::size_t const	n_variables,
		std::size_t const	local_matrix_size,
		std::vector< unsigned > const &	dofIndex_to_localIndex,
		NumLib::GenericIntegrationMethod const &	integration_method,
		bool const	is_axially_symmetric,
		SmallDeformationProcessData< DisplacementDim > &	process_data )

Definition at line 41 of file SmallDeformationLocalAssemblerMatrixNearFracture-impl.h.

    : SmallDeformationLocalAssemblerInterface(
          n_variables * ShapeFunction::NPOINTS * DisplacementDim,
          dofIndex_to_localIndex),
      _process_data(process_data),
      _integration_method(integration_method),
      _element(e),
      _is_axially_symmetric(is_axially_symmetric)
{
    std::vector<ShapeMatrices, Eigen::aligned_allocator<
                                   typename ShapeMatricesType::ShapeMatrices>>
        shape_matrices =
            NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                      DisplacementDim>(e, is_axially_symmetric,
                                                       _integration_method);
 
    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());
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        _ip_data.emplace_back(solid_material);
        auto& ip_data = _ip_data[ip];
        auto const& sm = shape_matrices[ip];
        ip_data.N_u = sm.N;
        ip_data.dNdx_u = sm.dNdx;
        ip_data.integration_weight =
            _integration_method.getWeightedPoint(ip).getWeight() *
            sm.integralMeasure * sm.detJ;
 
        // Initialize current time step values
        static const int kelvin_vector_size =
            MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
        ip_data._sigma.setZero(kelvin_vector_size);
        ip_data._eps.setZero(kelvin_vector_size);
 
        // Previous time step values are not initialized and are set later.
        ip_data._sigma_prev.resize(kelvin_vector_size);
        ip_data._eps_prev.resize(kelvin_vector_size);
 
        ip_data._C.resize(kelvin_vector_size, kelvin_vector_size);
 
        _secondary_data.N[ip] = sm.N;
    }
 
    for (auto fid : process_data.vec_ele_connected_fractureIDs[e.getID()])
    {
        _fracID_to_local.insert({fid, _fracture_props.size()});
        _fracture_props.push_back(&_process_data.fracture_properties[fid]);
    }
 
    _junction_props = process_data.vec_ele_connected_junctionIDs[e.getID()] |
                      ranges::views::transform(
                          [&](auto const jid)
                          { return &_process_data.junction_properties[jid]; }) |
                      ranges::to<std::vector>;
}

References ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface::SmallDeformationLocalAssemblerInterface(), _element, _fracID_to_local, _fracture_props, _integration_method, _ip_data, _is_axially_symmetric, _junction_props, _process_data, _secondary_data, MeshLib::Element::getID(), NumLib::initShapeMatrices(), MathLib::KelvinVector::kelvin_vector_dimensions(), MaterialLib::Solids::selectSolidConstitutiveRelation(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcessData< DisplacementDim >::vec_ele_connected_fractureIDs, and ProcessLib::LIE::SmallDeformation::SmallDeformationProcessData< DisplacementDim >::vec_ele_connected_junctionIDs.

Member Function Documentation

◆ assemble()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< 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 62 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

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

References OGS_FATAL.

◆ assembleWithJacobian()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::assembleWithJacobian	(	double const	t,
		double const	dt,
		Eigen::VectorXd const &	local_u,
		Eigen::VectorXd &	local_b,
		Eigen::MatrixXd &	local_J )

overridevirtual

Reimplemented from ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 116 of file SmallDeformationLocalAssemblerMatrixNearFracture-impl.h.

{
    assert(_element.getDimension() == DisplacementDim);
 
    auto const N_DOF_PER_VAR = ShapeFunction::NPOINTS * DisplacementDim;
    auto const n_fractures = _fracture_props.size();
    auto const n_junctions = _junction_props.size();
    auto const n_enrich_var = n_fractures + n_junctions;
 
    using BlockVectorType =
        typename Eigen::VectorXd::FixedSegmentReturnType<N_DOF_PER_VAR>::Type;
    using BlockMatrixType =
        Eigen::Block<Eigen::MatrixXd, N_DOF_PER_VAR, N_DOF_PER_VAR>;
 
    //--------------------------------------------------------------------------------------
    // prepare sub vectors, matrices for regular displacement (u) and
    // displacement jumps (g)
    //
    // example with two fractures with one intersection:
    //     |b(u)|
    // b = |b(g1)|
    //     |b(g2)|
    //     |b(j1)|
    //
    //     |J(u,u)  J(u,g1)  J(u,g2)  J(u,j1) |
    // J = |J(g1,u) J(g1,g1) J(g1,g2) J(g1,j1)|
    //     |J(g2,u) J(g2,g1) J(g2,g2) J(g2,j1)|
    //     |J(j1,u) J(j1,g1) J(j1,g2) J(j1,j1)|
    //--------------------------------------------------------------------------------------
    auto local_b_u = local_b.segment<N_DOF_PER_VAR>(0);
    std::vector<BlockVectorType> vec_local_b_g;
    for (unsigned i = 0; i < n_enrich_var; i++)
    {
        vec_local_b_g.push_back(
            local_b.segment<N_DOF_PER_VAR>(N_DOF_PER_VAR * (i + 1)));
    }
 
    auto local_J_uu = local_J.block<N_DOF_PER_VAR, N_DOF_PER_VAR>(0, 0);
    std::vector<BlockMatrixType> vec_local_J_ug;
    std::vector<BlockMatrixType> vec_local_J_gu;
    std::vector<std::vector<BlockMatrixType>> vec_local_J_gg(n_enrich_var);
    for (unsigned i = 0; i < n_enrich_var; i++)
    {
        auto sub_ug = local_J.block<N_DOF_PER_VAR, N_DOF_PER_VAR>(
            0, N_DOF_PER_VAR * (i + 1));
        vec_local_J_ug.push_back(sub_ug);
 
        auto sub_gu = local_J.block<N_DOF_PER_VAR, N_DOF_PER_VAR>(
            N_DOF_PER_VAR * (i + 1), 0);
        vec_local_J_gu.push_back(sub_gu);
 
        for (unsigned j = 0; j < n_enrich_var; j++)
        {
            auto sub_gg = local_J.block<N_DOF_PER_VAR, N_DOF_PER_VAR>(
                N_DOF_PER_VAR * (i + 1), N_DOF_PER_VAR * (j + 1));
            vec_local_J_gg[i].push_back(sub_gg);
        }
    }
 
    auto const nodal_u = local_u.segment<N_DOF_PER_VAR>(0);
    std::vector<BlockVectorType> vec_nodal_g;
    for (unsigned i = 0; i < n_enrich_var; i++)
    {
        auto sub = const_cast<Eigen::VectorXd&>(local_u).segment<N_DOF_PER_VAR>(
            N_DOF_PER_VAR * (i + 1));
        vec_nodal_g.push_back(sub);
    }
 
    //------------------------------------------------
    // integration
    //------------------------------------------------
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    MPL::VariableArray variables;
    MPL::VariableArray variables_prev;
 
    auto const B_dil_bar = getDilatationalBBarMatrix();
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto& ip_data = _ip_data[ip];
        auto const& w = _ip_data[ip].integration_weight;
 
        auto const& N = ip_data.N_u;
        auto const& dNdx = ip_data.dNdx_u;
 
        // levelset functions
        Eigen::Vector3d const ip_physical_coords(
            computePhysicalCoordinates(_element, N).data());
        std::vector<double> const levelsets(
            uGlobalEnrichments(_fracture_props, _junction_props,
                               _fracID_to_local, ip_physical_coords));
 
        // u = u^hat + sum_i(enrich^br_i(x) * [u]_i) + sum_i(enrich^junc_i(x) *
        // [u]_i)
        NodalDisplacementVectorType nodal_total_u = nodal_u;
        for (unsigned i = 0; i < n_enrich_var; i++)
        {
            nodal_total_u += levelsets[i] * vec_nodal_g[i];
        }
 
        ParameterLib::SpatialPosition const x_position{
            std::nullopt, this->_element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                this->_element, N))};
 
        auto const x_coord =
            x_position.getCoordinates().value()[0];  // r for axisymmetry
        auto const B = LinearBMatrix::computeBMatrixPossiblyWithBbar<
            DisplacementDim, ShapeFunction::NPOINTS, BBarMatrixType,
            typename BMatricesType::BMatrixType>(dNdx, N, B_dil_bar, x_coord,
                                                 this->_is_axially_symmetric);
 
        // strain, stress
        auto const& eps_prev = ip_data._eps_prev;
        auto const& sigma_prev = ip_data._sigma_prev;
 
        auto& eps = ip_data._eps;
        auto& sigma = ip_data._sigma;
        auto& state = ip_data._material_state_variables;
 
        eps.noalias() = B * nodal_total_u;
 
        variables.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps);
 
        variables_prev.stress
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                sigma_prev);
        variables_prev.mechanical_strain
            .emplace<MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                eps_prev);
        variables_prev.temperature = _process_data.reference_temperature;
 
        auto&& solution = _ip_data[ip]._solid_material.integrateStress(
            variables_prev, variables, t, x_position, dt, *state);
 
        if (!solution)
        {
            OGS_FATAL("Computation of local constitutive relation failed.");
        }
 
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim> C;
        std::tie(sigma, state, C) = std::move(*solution);
 
        // r_u = B^T * Sigma = B^T * C * B * (u+phi*[u])
        // r_[u] = (phi*B)^T * Sigma = (phi*B)^T * C * B * (u+phi*[u])
        local_b_u.noalias() -= B.transpose() * sigma * w;
        for (unsigned i = 0; i < n_enrich_var; i++)
        {
            vec_local_b_g[i].noalias() -=
                levelsets[i] * B.transpose() * sigma * w;
        }
 
        // J_uu += B^T * C * B
        local_J_uu.noalias() += B.transpose() * C * B * w;
 
        for (unsigned i = 0; i < n_enrich_var; i++)
        {
            // J_u[u] += B^T * C * (levelset * B)
            vec_local_J_ug[i].noalias() +=
                B.transpose() * C * (levelsets[i] * B) * w;
 
            // J_[u]u += (levelset * B)^T * C * B
            vec_local_J_gu[i].noalias() +=
                (levelsets[i] * B.transpose()) * C * B * w;
 
            for (unsigned j = 0; j < n_enrich_var; j++)
            {
                // J_[u][u] += (levelset * B)^T * C * (levelset * B)
                vec_local_J_gg[i][j].noalias() +=
                    (levelsets[i] * B.transpose()) * C * (levelsets[j] * B) * w;
            }
        }
    }
}

References _element, _fracID_to_local, _fracture_props, _integration_method, _ip_data, _is_axially_symmetric, _junction_props, _process_data, assembleWithJacobian(), ProcessLib::LinearBMatrix::computeBMatrixPossiblyWithBbar(), ProcessLib::LIE::computePhysicalCoordinates(), ParameterLib::SpatialPosition::getCoordinates(), getDilatationalBBarMatrix(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::mechanical_strain, OGS_FATAL, MaterialPropertyLib::VariableArray::stress, MaterialPropertyLib::VariableArray::temperature, and ProcessLib::LIE::uGlobalEnrichments().

Referenced by assembleWithJacobian().

◆ computeSecondaryVariableConcreteWithVector()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::computeSecondaryVariableConcreteWithVector	(	double const	t,
		Eigen::VectorXd const &	local_x )

overridevirtual

Implements ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 304 of file SmallDeformationLocalAssemblerMatrixNearFracture-impl.h.

{
    // Compute average value per element
    using KV = MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
    KV sigma_avg = KV::Zero();
    auto const e_id = _element.getID();
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        sigma_avg += _ip_data[ip]._sigma;
    }
    sigma_avg /= n_integration_points;
 
    Eigen::Map<KV>(
        &(*_process_data.element_stresses)[e_id * KV::RowsAtCompileTime]) =
        MathLib::KelvinVector::kelvinVectorToSymmetricTensor(sigma_avg);
}

References _element, _integration_method, _ip_data, _process_data, and MathLib::KelvinVector::kelvinVectorToSymmetricTensor().

◆ getDilatationalBBarMatrix()

template<typename ShapeFunction, int DisplacementDim>

std::optional< BBarMatrixType > ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::getDilatationalBBarMatrix ( ) const

inlineprivate

Definition at line 156 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

    {
        if (!(_process_data.use_b_bar))
        {
            return std::nullopt;
        }
 
        return LinearBMatrix::computeDilatationalBbar<
            DisplacementDim, ShapeFunction::NPOINTS, ShapeFunction,
            BBarMatrixType, ShapeMatricesType, IntegrationPointDataType>(
            _ip_data, this->_element, this->_integration_method,
            this->_is_axially_symmetric);
    }

References _ip_data, _process_data, and ProcessLib::LinearBMatrix::computeDilatationalBbar().

Referenced by assembleWithJacobian().

◆ getIntPtEpsilon()

template<typename ShapeFunction, int DisplacementDim>

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

overridevirtual

Implements ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 340 of file SmallDeformationLocalAssemblerMatrixNearFracture-impl.h.

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

References ProcessLib::LIE::SmallDeformation::IntegrationPointDataMatrix< ShapeMatricesType, BMatricesType, DisplacementDim >::_eps, _ip_data, and ProcessLib::getIntegrationPointKelvinVectorData().

◆ getIntPtFractureAperture()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > const & ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::getIntPtFractureAperture	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache ) const

inlineoverridevirtual

Implements ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 126 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

    {
        cache.resize(0);
        return cache;
    }

◆ getIntPtFractureStress()

template<typename ShapeFunction, int DisplacementDim>

std::vector< double > const & ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::getIntPtFractureStress	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache ) const

inlineoverridevirtual

Implements ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 116 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

    {
        cache.resize(0);
        return cache;
    }

◆ getIntPtSigma()

template<typename ShapeFunction, int DisplacementDim>

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

overridevirtual

Implements ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerInterface.

Definition at line 328 of file SmallDeformationLocalAssemblerMatrixNearFracture-impl.h.

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

References _ip_data, ProcessLib::LIE::SmallDeformation::IntegrationPointDataMatrix< ShapeMatricesType, BMatricesType, DisplacementDim >::_sigma, and ProcessLib::getIntegrationPointKelvinVectorData().

◆ getShapeMatrix()

template<typename ShapeFunction, int DisplacementDim>

Eigen::Map< const Eigen::RowVectorXd > ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 95 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

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

References _secondary_data.

◆ preTimestepConcrete()

template<typename ShapeFunction, int DisplacementDim>

void ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::preTimestepConcrete	(	std::vector< double > const &	,
		double const	,
		double const	)

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 79 of file SmallDeformationLocalAssemblerMatrixNearFracture.h.

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