MaterialLib::Fracture Namespace Reference

Namespaces
	anonymous_namespace{FractureIdentity2.cpp}
	CohesiveZoneModeI
	Coulomb
	Permeability

Classes
struct	FractureIdentity2
class	FractureModelBase
class	LinearElasticIsotropic

Functions
template<int DisplacementDim>
std::unique_ptr< FractureModelBase< DisplacementDim > >	createCoulomb (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
std::unique_ptr< FractureModelBase< DisplacementDim > >	createLinearElasticIsotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, BaseLib::ConfigTree const &config)
double	logPenaltyDerivative (double const aperture0, double const aperture, double const aperture_cutoff)
double	logPenalty (double const aperture0, double const aperture, double const aperture_cutoff)

Function Documentation

createCoulomb()

template<int DisplacementDim>

std::unique_ptr< FractureModelBase< DisplacementDim > > MaterialLib::Fracture::createCoulomb	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		BaseLib::ConfigTree const &	config
	)

Input File Parameter:

material__fracture_model__type

Input File Parameter:

material__fracture_model__Coulomb__normal_stiffness

Input File Parameter:

material__fracture_model__Coulomb__shear_stiffness

Input File Parameter:

material__fracture_model__Coulomb__friction_angle

Input File Parameter:

material__fracture_model__Coulomb__dilatancy_angle

Input File Parameter:

material__fracture_model__Coulomb__cohesion

Input File Parameter:

material__fracture_model__Coulomb__penalty_aperture_cutoff

Input File Parameter:

material__fracture_model__Coulomb__tension_cutoff

Input File Parameter:

material__fracture_model__Coulomb__nonlinear_solver

Definition at line 21 of file CreateCoulomb.cpp.

{
    config.checkConfigParameter("type", "Coulomb");
    DBUG("Create Coulomb material");
 
    auto& Kn = ParameterLib::findParameter<double>(
        config, "normal_stiffness", parameters, 1);
 
    auto& Ks = ParameterLib::findParameter<double>(
        config, "shear_stiffness", parameters, 1);
 
    auto& friction_angle = ParameterLib::findParameter<double>(
        config, "friction_angle", parameters, 1);
 
    auto& dilatancy_angle = ParameterLib::findParameter<double>(
        config, "dilatancy_angle", parameters, 1);
 
    auto& cohesion = ParameterLib::findParameter<double>(
        config, "cohesion", parameters, 1);
 
    auto const penalty_aperture_cutoff =
        config.getConfigParameter<double>("penalty_aperture_cutoff");
 
    auto const tension_cutoff =
        config.getConfigParameter<bool>("tension_cutoff");
 
    typename Coulomb::Coulomb<DisplacementDim>::MaterialProperties mp{
        Kn, Ks, friction_angle, dilatancy_angle, cohesion};
 
    auto const& nonlinear_solver_config =
        config.getConfigSubtree("nonlinear_solver");
    auto const nonlinear_solver_parameters =
        NumLib::createNewtonRaphsonSolverParameters(nonlinear_solver_config);
 
    return std::make_unique<Coulomb::Coulomb<DisplacementDim>>(
        nonlinear_solver_parameters, penalty_aperture_cutoff, tension_cutoff,
        mp);
}

References BaseLib::ConfigTree::checkConfigParameter(), NumLib::createNewtonRaphsonSolverParameters(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::getConfigSubtree().

createLinearElasticIsotropic()

template<int DisplacementDim>

std::unique_ptr< FractureModelBase< DisplacementDim > > MaterialLib::Fracture::createLinearElasticIsotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		BaseLib::ConfigTree const &	config
	)

Input File Parameter:

material__fracture_model__type

Input File Parameter:

material__fracture_model__LinearElasticIsotropic__normal_stiffness

Input File Parameter:

material__fracture_model__LinearElasticIsotropic__shear_stiffness

Input File Parameter:

material__fracture_model__LinearElasticIsotropic__penalty_aperture_cutoff

Input File Parameter:

material__fracture_model__LinearElasticIsotropic__tension_cutoff

Definition at line 21 of file CreateLinearElasticIsotropic.cpp.

{
    config.checkConfigParameter("type", "LinearElasticIsotropic");
    DBUG("Create LinearElasticIsotropic material");
 
    auto const& Kn = ParameterLib::findParameter<double>(
        config, "normal_stiffness", parameters, 1);
 
    auto const& Ks = ParameterLib::findParameter<double>(
        config, "shear_stiffness", parameters, 1);
 
    auto const penalty_aperture_cutoff =
        config.getConfigParameter<double>("penalty_aperture_cutoff");
 
    auto const tension_cutoff =
        config.getConfigParameter<bool>("tension_cutoff");
 
    typename LinearElasticIsotropic<DisplacementDim>::MaterialProperties mp{Kn,
                                                                            Ks};
 
    return std::make_unique<LinearElasticIsotropic<DisplacementDim>>(
        penalty_aperture_cutoff, tension_cutoff, mp);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess().

logPenalty()

double MaterialLib::Fracture::logPenalty ( double const  aperture0, double const  aperture, double const  aperture_cutoff  )

inline

Definition at line 49 of file LogPenalty.h.

{
    if (aperture >= aperture0)
    {
        return 1;
    }
 
    // Logarithmic penalty
    if (aperture > aperture_cutoff)
    {
        double const penalty = std::log(aperture / aperture0);
        return 1 + penalty * penalty;
    }
 
    // Linear penalty below aperture cutoff
    {
        double const penalty = std::log(aperture_cutoff / aperture0);
        return 1 + penalty * penalty +
               2 * penalty / aperture_cutoff * (aperture - aperture_cutoff);
    }
};

Referenced by MaterialLib::Fracture::CohesiveZoneModeI::CohesiveZoneModeI< DisplacementDim >::computeConstitutiveRelation(), and MaterialLib::Fracture::LinearElasticIsotropic< DisplacementDim >::computeConstitutiveRelation().

logPenaltyDerivative()

double MaterialLib::Fracture::logPenaltyDerivative ( double const  aperture0, double const  aperture, double const  aperture_cutoff  )

inline

A penalty function for negative aperture suppression used as a multiplier to the normal fracture stiffness.

The derivative is continuous at aperture = aperture0 and aperture = aperture_cutoff.

Definition at line 23 of file LogPenalty.h.

{
    if (aperture >= aperture0)
    {
        return 1;
    }
 
    // Logarithmic penalty
    if (aperture > aperture_cutoff)
    {
        double const penalty = std::log(aperture / aperture0);
        return 1 + penalty * penalty +
               2 * penalty / aperture * (aperture - aperture0);
    }
 
    // Linear penalty below aperture cutoff
    {
        double const penalty = std::log(aperture_cutoff / aperture0);
        return 1 + penalty * penalty +
               2 * penalty / aperture_cutoff *
                   (2 * aperture - aperture_cutoff - aperture0);
    }
};

Referenced by MaterialLib::Fracture::CohesiveZoneModeI::CohesiveZoneModeI< DisplacementDim >::computeConstitutiveRelation(), MaterialLib::Fracture::LinearElasticIsotropic< DisplacementDim >::computeConstitutiveRelation(), and MaterialLib::Fracture::Coulomb::Coulomb< DisplacementDim >::computeConstitutiveRelation().