CreateEhlers.h

Go to the documentation of this file.

 
#pragma once
 
#include "Ehlers.h"
#include "NumLib/CreateNewtonRaphsonSolverParameters.h"
#include "ParameterLib/Utils.h"
 
namespace MaterialLib
{
namespace Solids
{
namespace Ehlers
{
inline std::unique_ptr<DamagePropertiesParameters> createDamageProperties(
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
    BaseLib::ConfigTree const& config)
{
    auto& alpha_d =
        ParameterLib::findParameter<double>(config, "alpha_d", parameters, 1);
 
    DBUG("Use '{:s}' as alpha_d.", alpha_d.name);
 
    auto& beta_d =
        ParameterLib::findParameter<double>(config, "beta_d", parameters, 1);
 
    DBUG("Use '{:s}' as beta_d.", beta_d.name);
 
    auto& h_d =
        ParameterLib::findParameter<double>(config, "h_d", parameters, 1);
 
    DBUG("Use '{:s}' as h_d.", h_d.name);
 
    return std::make_unique<DamagePropertiesParameters>(
        DamagePropertiesParameters{alpha_d, beta_d, h_d});
}
 
template <int DisplacementDim>
std::unique_ptr<SolidEhlers<DisplacementDim>> createEhlers(
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "Ehlers");
    DBUG("Create Ehlers material");
 
    auto& shear_modulus = ParameterLib::findParameter<double>(
        config, "shear_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as shear modulus parameter.", shear_modulus.name);
 
    auto& bulk_modulus = ParameterLib::findParameter<double>(
        config, "bulk_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as bulk modulus parameter.", bulk_modulus.name);
 
    auto& kappa =
        ParameterLib::findParameter<double>(config, "kappa", parameters, 1);
 
    DBUG("Use '{:s}' as kappa.", kappa.name);
 
    auto& beta =
        ParameterLib::findParameter<double>(config, "beta", parameters, 1);
 
    DBUG("Use '{:s}' as beta.", beta.name);
 
    auto& gamma =
        ParameterLib::findParameter<double>(config, "gamma", parameters, 1);
 
    DBUG("Use '{:s}' as gamma.", gamma.name);
 
    auto& hardening_modulus = ParameterLib::findParameter<double>(
        config, "hardening_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as hardening modulus parameter.", hardening_modulus.name);
 
    auto& alpha =
        ParameterLib::findParameter<double>(config, "alpha", parameters, 1);
 
    DBUG("Use '{:s}' as alpha.", alpha.name);
 
    auto& delta =
        ParameterLib::findParameter<double>(config, "delta", parameters, 1);
 
    DBUG("Use '{:s}' as delta.", delta.name);
 
    auto& eps =
        ParameterLib::findParameter<double>(config, "eps", parameters, 1);
 
    DBUG("Use '{:s}' as eps.", eps.name);
 
    auto& m = ParameterLib::findParameter<double>(config, "m", parameters, 1);
 
    DBUG("Use '{:s}' as m.", m.name);
 
    auto& alphap =
        ParameterLib::findParameter<double>(config, "alphap", parameters, 1);
 
    DBUG("Use '{:s}' as alphap.", alphap.name);
 
    auto& deltap =
        ParameterLib::findParameter<double>(config, "deltap", parameters, 1);
 
    DBUG("Use '{:s}' as deltap.", deltap.name);
 
    auto& epsp =
        ParameterLib::findParameter<double>(config, "epsp", parameters, 1);
 
    DBUG("Use '{:s}' as epsp.", epsp.name);
 
    auto& paremeter_mp =
        ParameterLib::findParameter<double>(config, "mp", parameters, 1);
 
    DBUG("Use '{:s}' as mp.", paremeter_mp.name);
 
    auto& betap =
        ParameterLib::findParameter<double>(config, "betap", parameters, 1);
 
    DBUG("Use '{:s}' as betap.", betap.name);
 
    auto& gammap =
        ParameterLib::findParameter<double>(config, "gammap", parameters, 1);
 
    DBUG("Use '{:s}' as gammap.", gammap.name);
 
    auto tangent_type =
        makeTangentType(config.getConfigParameter<std::string>("tangent_type"));
 
    MaterialPropertiesParameters mp{
        shear_modulus, bulk_modulus, alpha,  beta,
        gamma,         delta,        eps,    m,
        alphap,        betap,        gammap, deltap,
        epsp,          paremeter_mp, kappa,  hardening_modulus};
 
    // Damage properties.
    std::unique_ptr<DamagePropertiesParameters> ehlers_damage_properties;
 
    auto const& ehlers_damage_config =
        config.getConfigSubtreeOptional("damage_properties");
    if (ehlers_damage_config)
    {
        ehlers_damage_properties =
            createDamageProperties(parameters, *ehlers_damage_config);
    }
 
    auto const& nonlinear_solver_config =
        config.getConfigSubtree("nonlinear_solver");
    auto const nonlinear_solver_parameters =
        NumLib::createNewtonRaphsonSolverParameters(nonlinear_solver_config);
 
    return std::make_unique<SolidEhlers<DisplacementDim>>(
        nonlinear_solver_parameters,
        mp,
        std::move(ehlers_damage_properties),
        tangent_type);
}
 
}  // namespace Ehlers
}  // namespace Solids
}  // namespace MaterialLib