MaterialLib::Solids::Lubby2 Namespace Reference

Namespaces
	detail

Classes
struct	Lubby2MaterialProperties
class	Lubby2

Functions
template<int DisplacementDim>
std::unique_ptr< Lubby2< DisplacementDim > >	createLubby2 (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
Eigen::Matrix< double, Lubby2< DisplacementDim >::JacobianResidualSize, Lubby2< DisplacementDim >::KelvinVectorSize >	calculatedGdEBurgers ()
template<int DisplacementDim, typename LinearSolver >
MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >	tangentStiffnessA (double const GM0, double const KM0, LinearSolver const &linear_solver)

Function Documentation

calculatedGdEBurgers()

template<int DisplacementDim>

Eigen::Matrix<double, Lubby2<DisplacementDim>::JacobianResidualSize, Lubby2<DisplacementDim>::KelvinVectorSize> MaterialLib::Solids::Lubby2::calculatedGdEBurgers

(

)

Calculates the 18x6 derivative of the residuals with respect to total strain.

Definition at line 27 of file Lubby2.cpp.

{
    Eigen::Matrix<double, Lubby2<DisplacementDim>::JacobianResidualSize,
                  Lubby2<DisplacementDim>::KelvinVectorSize>
        dGdE =
            Eigen::Matrix<double, Lubby2<DisplacementDim>::JacobianResidualSize,
                          Lubby2<DisplacementDim>::KelvinVectorSize>::Zero();
    dGdE.template topLeftCorner<Lubby2<DisplacementDim>::KelvinVectorSize,
                                Lubby2<DisplacementDim>::KelvinVectorSize>()
        .diagonal()
        .setConstant(-2.);
    return dGdE;
}

createLubby2()

template<int DisplacementDim>

std::unique_ptr<Lubby2<DisplacementDim> > MaterialLib::Solids::Lubby2::createLubby2	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		BaseLib::ConfigTree const &	config
	)

Input File Parameter:

material__solid__constitutive_relation__type

Input File Parameter:

material__solid__constitutive_relation__Lubby2__kelvin_shear_modulus

Input File Parameter:

material__solid__constitutive_relation__Lubby2__kelvin_viscosity

Input File Parameter:

material__solid__constitutive_relation__Lubby2__maxwell_shear_modulus

Input File Parameter:

material__solid__constitutive_relation__Lubby2__maxwell_bulk_modulus

Input File Parameter:

material__solid__constitutive_relation__Lubby2__maxwell_viscosity

Input File Parameter:

material__solid__constitutive_relation__Lubby2__dependency_parameter_mk

Input File Parameter:

material__solid__constitutive_relation__Lubby2__dependency_parameter_mvk

Input File Parameter:

material__solid__constitutive_relation__Lubby2__dependency_parameter_mvm

Input File Parameter:

material__solid__constitutive_relation__Lubby2__nonlinear_solver

Definition at line 24 of file CreateLubby2.h.

{
    config.checkConfigParameter("type", "Lubby2");
    DBUG("Create Lubby2 material");
 
    // Kelvin shear modulus.
    auto& kelvin_shear_modulus = ParameterLib::findParameter<double>(
        config, "kelvin_shear_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as kelvin shear modulus parameter.",
         kelvin_shear_modulus.name);
 
    // Kelvin viscosity.
    auto& kelvin_viscosity = ParameterLib::findParameter<double>(
        config, "kelvin_viscosity", parameters, 1);
 
    DBUG("Use '{:s}' as kelvin viscosity parameter.", kelvin_viscosity.name);
 
    // Maxwell shear modulus.
    auto& maxwell_shear_modulus = ParameterLib::findParameter<double>(
        config, "maxwell_shear_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as maxwell shear modulus parameter.",
         maxwell_shear_modulus.name);
 
    // Maxwell bulk modulus.
    auto& maxwell_bulk_modulus = ParameterLib::findParameter<double>(
        config, "maxwell_bulk_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as maxwell bulk modulus parameter.",
         maxwell_bulk_modulus.name);
 
    // Maxwell viscosity.
    auto& maxwell_viscosity = ParameterLib::findParameter<double>(
        config, "maxwell_viscosity", parameters, 1);
 
    DBUG("Use '{:s}' as maxwell viscosity parameter.", maxwell_viscosity.name);
 
    // Dependency parameter for mK.
    auto& dependency_parameter_mK = ParameterLib::findParameter<double>(
        config, "dependency_parameter_mk", parameters, 1);
 
    DBUG("Use '{:s}' as dependency parameter mK.",
         dependency_parameter_mK.name);
 
    // Dependency parameter for mvK.
    auto& dependency_parameter_mvK = ParameterLib::findParameter<double>(
        config, "dependency_parameter_mvk", parameters, 1);
 
    DBUG("Use '{:s}' as dependency parameter mvK.",
         dependency_parameter_mvK.name);
 
    // Dependency parameter for mvM.
    auto& dependency_parameter_mvM = ParameterLib::findParameter<double>(
        config, "dependency_parameter_mvm", parameters, 1);
 
    DBUG("Use '{:s}' as dependency parameter mvM.",
         dependency_parameter_mvM.name);
 
    Lubby2MaterialProperties mp{
        kelvin_shear_modulus,     maxwell_shear_modulus,
        maxwell_bulk_modulus,     kelvin_viscosity,
        maxwell_viscosity,        dependency_parameter_mK,
        dependency_parameter_mvK, dependency_parameter_mvM};
 
    auto const& nonlinear_solver_config =
        config.getConfigSubtree("nonlinear_solver");
    auto const nonlinear_solver_parameters =
        NumLib::createNewtonRaphsonSolverParameters(nonlinear_solver_config);
 
    return std::unique_ptr<Lubby2<DisplacementDim>>{
        new Lubby2<DisplacementDim>{nonlinear_solver_parameters, mp}};
}

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

tangentStiffnessA()

template<int DisplacementDim, typename LinearSolver >

MathLib::KelvinVector::KelvinMatrixType<DisplacementDim> MaterialLib::Solids::Lubby2::tangentStiffnessA	(	double const	GM0,
		double const	KM0,
		LinearSolver const &	linear_solver
	)

Definition at line 42 of file Lubby2.cpp.

{
    // Calculate dGdE for time step
    auto const dGdE = calculatedGdEBurgers<DisplacementDim>();
 
    // Consistent tangent from local Newton iteration of material
    // functionals.
    // Only the upper left block is relevant for the global tangent.
    static int const KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using KelvinMatrix =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;
 
    KelvinMatrix const dzdE =
        linear_solver.solve(-dGdE)
            .template topLeftCorner<KelvinVectorSize, KelvinVectorSize>();
 
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    auto const& P_sph = Invariants::spherical_projection;
    auto const& P_dev = Invariants::deviatoric_projection;
 
    KelvinMatrix C = GM0 * dzdE * P_dev + 3. * KM0 * P_sph;
    return C;
};

References MathLib::KelvinVector::kelvin_vector_dimensions().