ProcessLib::SmallDeformationNonlocal Namespace Reference

Classes
struct	IntegrationPointData
struct	IntegrationPointDataNonlocalInterface
struct	NonlocalIP
struct	SecondaryData
class	SmallDeformationNonlocalLocalAssembler
struct	SmallDeformationNonlocalLocalAssemblerInterface
class	SmallDeformationNonlocalProcess
struct	SmallDeformationNonlocalProcessData

Functions
template<int DisplacementDim>
std::unique_ptr< Process >	createSmallDeformationNonlocalProcess (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process >	createSmallDeformationNonlocalProcess< 2 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process >	createSmallDeformationNonlocalProcess< 3 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
double	calculateDamage (double const kappa_d, double const alpha_d, double const beta_d)
template<int DisplacementDim, typename KelvinVectorType >
double	calculateDamageKappaD (double const eps_p_eff_diff, KelvinVectorType const &sigma, double const kappa_d_prev, double const h_d, MaterialLib::Solids::Ehlers::MaterialProperties const &mp)

Function Documentation

calculateDamage()

double ProcessLib::SmallDeformationNonlocal::calculateDamage ( double const kappa_d, double const alpha_d, double const beta_d )

inline

Computes the damage internal material variable explicitly based on the results obtained from the local stress return algorithm.

Definition at line 25 of file Damage.h.

{
    double const damage = (1 - beta_d) * (1 - std::exp(-kappa_d / alpha_d));
 
    if (damage < 0. || damage >= 1.)
    {
        OGS_FATAL("Damage value {:g} outside of [0,1) interval.", damage);
    }
 
    return damage;
}

References OGS_FATAL.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian().

calculateDamageKappaD()

template<int DisplacementDim, typename KelvinVectorType >

double ProcessLib::SmallDeformationNonlocal::calculateDamageKappaD	(	double const	eps_p_eff_diff,
		KelvinVectorType const &	sigma,
		double const	kappa_d_prev,
		double const	h_d,
		MaterialLib::Solids::Ehlers::MaterialProperties const &	mp )

Definition at line 39 of file Damage.h.

{
    // Default case of the rate problem. Updated below if volumetric plastic
    // strain rate is positive (dilatancy).
 
    // non-const for Eigen solver.
    auto sigma_tensor = MathLib::KelvinVector::kelvinVectorToTensor(sigma);
 
    Eigen::EigenSolver<decltype(sigma_tensor)> eigen_solver(sigma_tensor);
    auto const principal_stress = real(eigen_solver.eigenvalues().array());
    double const prod_stress = std::sqrt(principal_stress.square().sum());
 
    // Brittleness decrease with confinement for the nonlinear flow rule.
    // ATTENTION: For linear flow rule -> constant brittleness.
    double const tensile_strength =
        std::sqrt(3.0) * mp.kappa / (1 + std::sqrt(3.0) * mp.beta);
    double const r_s = prod_stress / tensile_strength - 1.;
 
    // Compute normalizing strain.
    double const x_s = [](double const h_d, double const r_s)
    {
        if (r_s < 0)
        {
            return 1.;
        }
        if (r_s <= 1)
        {
            return 1. + h_d * r_s * r_s;
        }
        return 1. - 3 * h_d + 4 * h_d * std::sqrt(r_s);
    }(h_d, r_s);
 
    return kappa_d_prev + eps_p_eff_diff / x_s;
}

References MaterialLib::Solids::Ehlers::MaterialProperties::beta, MaterialLib::Solids::Ehlers::MaterialProperties::kappa, and MathLib::KelvinVector::kelvinVectorToTensor().

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::preAssemble().

createSmallDeformationNonlocalProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )

Input File Parameter

prj__processes__process__type

Process Variables

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__process_variables

Primary process variables as they appear in the global component vector:

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__process_variables__process_variable

Process Parameters

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__solid_density

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__specific_body_force

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__reference_temperature

Input File Parameter

prj__processes__process__SMALL_DEFORMATION_NONLOCAL__internal_length

Definition at line 27 of file CreateSmallDeformationNonlocalProcess.cpp.

{
    config.checkConfigParameter("type", "SMALL_DEFORMATION_NONLOCAL");
    DBUG("Create SmallDeformationNonlocalProcess.");
 
 
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    auto per_process_variables = findProcessVariables(
        variables, pv_config,
        {
         "process_variable"});
 
    DBUG("Associate displacement with process variable '{:s}'.",
         per_process_variables.back().get().getName());
 
    if (per_process_variables.back().get().getNumberOfGlobalComponents() !=
        DisplacementDim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the displacement dimension: got {:d}, expected {:d}",
            per_process_variables.back().get().getName(),
            per_process_variables.back().get().getNumberOfGlobalComponents(),
            DisplacementDim);
    }
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    process_variables.push_back(std::move(per_process_variables));
 
    auto solid_constitutive_relations =
        MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
            parameters, local_coordinate_system, materialIDs(mesh), config);
 
    // Solid density
    auto const& solid_density = ParameterLib::findParameter<double>(
        config,
        "solid_density", parameters, 1, &mesh);
    DBUG("Use '{:s}' as solid density parameter.", solid_density.name);
 
    // Specific body force
    Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.size() != DisplacementDim)
        {
            OGS_FATAL(
                "The size of the specific body force vector does not match the "
                "displacement dimension. Vector size is {:d}, displacement "
                "dimension is {:d}",
                b.size(), DisplacementDim);
        }
 
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    // Reference temperature
    const auto& reference_temperature =
        config.getConfigParameter<double>(
            "reference_temperature", std::numeric_limits<double>::quiet_NaN());
 
    auto const internal_length =
        config.getConfigParameter<double>("internal_length");
 
    SmallDeformationNonlocalProcessData<DisplacementDim> process_data{
        materialIDs(mesh),     std::move(solid_constitutive_relations),
        solid_density,         specific_body_force,
        reference_temperature, internal_length * internal_length};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<SmallDeformationNonlocalProcess<DisplacementDim>>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables));
}

References BaseLib::ConfigTree::checkConfigParameter(), MaterialLib::Solids::createConstitutiveRelations(), ProcessLib::createSecondaryVariables(), DBUG(), ParameterLib::findParameter(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), and OGS_FATAL.

createSmallDeformationNonlocalProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess< 2 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )

Referenced by ProjectData::parseProcesses().

createSmallDeformationNonlocalProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess< 3 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )

Referenced by ProjectData::parseProcesses().