CohesiveZoneModeI.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <Eigen/Core>
#include <utility>
 
#include "FractureModelBase.h"
#include "ParameterLib/Parameter.h"
 
namespace MaterialLib
{
namespace Fracture
{
namespace CohesiveZoneModeI
{
struct MaterialPropertiesParameters
{
    using P = ParameterLib::Parameter<double>;
    using X = ParameterLib::SpatialPosition;
 
    MaterialPropertiesParameters(P const& normal_stiffness_,
                                 P const& shear_stiffness_,
                                 P const& fracture_toughness_,
                                 P const& peak_normal_traction_)
        : normal_stiffness(normal_stiffness_),
          shear_stiffness(shear_stiffness_),
          fracture_toughness(fracture_toughness_),
          peak_normal_traction(peak_normal_traction_)
    {
    }

    double fracture_opening_at_peak_traction(double const t, X const& x) const
    {
        return peak_normal_traction(t, x)[0] / normal_stiffness(t, x)[0];
    }

    double fracture_opening_at_residual_traction(double const t,
                                                 X const& x) const
    {
        if (peak_normal_traction(t, x)[0] == 0.0)
        {
            return 0.0;
        }
 
        return 2 * fracture_toughness(t, x)[0] / peak_normal_traction(t, x)[0];
    }

    P const& normal_stiffness;
    P const& shear_stiffness;

    P const& fracture_toughness;
    P const& peak_normal_traction;
};

struct MaterialProperties final
{
    MaterialProperties(double const t, ParameterLib::SpatialPosition const& x,
                       MaterialPropertiesParameters const& mp)
        : Kn(mp.normal_stiffness(t, x)[0]),
          Ks(mp.shear_stiffness(t, x)[0]),
          Gc(mp.fracture_toughness(t, x)[0]),
          t_np(mp.peak_normal_traction(t, x)[0]),
          w_np(mp.fracture_opening_at_peak_traction(t, x)),
          w_nf(mp.fracture_opening_at_residual_traction(t, x))
    {
    }
 
    double const Kn;
    double const Ks;
    double const Gc;
    double const t_np;
    double const w_np;
    double const w_nf;
};
 
template <int DisplacementDim>
struct StateVariables
    : public FractureModelBase<DisplacementDim>::MaterialStateVariables
{
    void setInitialConditions() { damage = damage_prev; }
 
    void pushBackState() override { damage_prev = damage; }
 
    double damage;  
 
    // Initial values from previous timestep
    double damage_prev;  
};

template <int DisplacementDim>
class CohesiveZoneModeI final : public FractureModelBase<DisplacementDim>
{
public:
    std::unique_ptr<
        typename FractureModelBase<DisplacementDim>::MaterialStateVariables>
    createMaterialStateVariables() override
    {
        return std::make_unique<StateVariables<DisplacementDim>>();
    }
 
public:
public:
    explicit CohesiveZoneModeI(double const penalty_aperture_cutoff,
                               bool const tension_cutoff,
                               MaterialPropertiesParameters material_properties)
        : _penalty_aperture_cutoff(penalty_aperture_cutoff),
          _tension_cutoff(tension_cutoff),
          _mp(std::move(material_properties))
    {
    }

    void computeConstitutiveRelation(
        double const t,
        ParameterLib::SpatialPosition const& x,
        double const aperture0,
        Eigen::Ref<Eigen::VectorXd const>
            sigma0,
        Eigen::Ref<Eigen::VectorXd const>
            w_prev,
        Eigen::Ref<Eigen::VectorXd const>
            w,
        Eigen::Ref<Eigen::VectorXd const>
            sigma_prev,
        Eigen::Ref<Eigen::VectorXd>
            sigma,
        Eigen::Ref<Eigen::MatrixXd>
            C,
        typename FractureModelBase<DisplacementDim>::MaterialStateVariables&
            material_state_variables) override;
 
    MaterialProperties evaluatedMaterialProperties(
        double const t, ParameterLib::SpatialPosition const& x) const
    {
        return MaterialProperties(t, x, _mp);
    }
 
private:
    double const _penalty_aperture_cutoff;

    bool const _tension_cutoff;
 
    MaterialPropertiesParameters _mp;
};
 
}  // namespace CohesiveZoneModeI
}  // namespace Fracture
}  // namespace MaterialLib
 
namespace MaterialLib
{
namespace Fracture
{
namespace CohesiveZoneModeI
{
extern template class CohesiveZoneModeI<2>;
extern template class CohesiveZoneModeI<3>;
}  // namespace CohesiveZoneModeI
}  // namespace Fracture
}  // namespace MaterialLib