ElasticMaterials Struct Reference

Manage setting parameters and constitutive equations for nonlinear/linear elastic materials. More...

#include "users_modules/basic_finite_elements/nonlinear_elastic_materials/src/ElasticMaterials.hpp"

Collaboration diagram for ElasticMaterials:

Classes
struct	BlockOptionData

Public Member Functions
	ElasticMaterials (MoFEM::Interface &m_field, std::string def_material="KIRCHHOFF")
virtual	~ElasticMaterials ()
virtual MoFEMErrorCode	iNit ()
virtual MoFEMErrorCode	readConfigFile ()
	read Elastic materials declaration for blocks and meshsets
MoFEMErrorCode	setBlocksOrder ()

Public Attributes
MoFEM::Interface &	mField
std::string	defMaterial
std::string	configFile
bool	iNitialized
	true if class is initialized
std::map< std::string, boost::shared_ptr< NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< adouble > > >	aDoubleMaterialModel
std::map< std::string, boost::shared_ptr< NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< double > > >	doubleMaterialModel
	Hash map of materials for evaluation with double.
std::map< int, BlockOptionData >	blockData
	Material parameters on blocks.
PetscBool	isConfigFileSet
	True if config file is set from command line.
po::variables_map	vM

Detailed Description

Manage setting parameters and constitutive equations for nonlinear/linear elastic materials.

Examples

Remodeling.cpp, and nonlinear_dynamics.cpp.

Definition at line 24 of file ElasticMaterials.hpp.

Constructor & Destructor Documentation

ElasticMaterials()

ElasticMaterials::ElasticMaterials ( MoFEM::Interface & m_field, std::string def_material = "KIRCHHOFF" )

inline

Definition at line 33 of file ElasticMaterials.hpp.

      : mField(m_field), defMaterial(def_material),
        configFile("elastic_material.in"), iNitialized(false) {}

~ElasticMaterials()

virtual ElasticMaterials::~ElasticMaterials ( )

inlinevirtual

Definition at line 38 of file ElasticMaterials.hpp.

{}

Member Function Documentation

iNit()

virtual MoFEMErrorCode ElasticMaterials::iNit ( )

inlinevirtual

Initialize model parameters

Returns

[description]

Definition at line 78 of file ElasticMaterials.hpp.

                                {
    MoFEMFunctionBeginHot;
    // add new material below
    string mat_name;
    aDoubleMaterialModel[MAT_KIRCHHOFF] =
        boost::make_shared<NonlinearElasticElement::
                               FunctionsToCalculatePiolaKirchhoffI<adouble>>();
    doubleMaterialModel[MAT_KIRCHHOFF] = boost::make_shared<
        NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI<double>>();
    aDoubleMaterialModel[MAT_HOOKE] = boost::make_shared<Hooke<adouble>>();
    doubleMaterialModel[MAT_HOOKE] = boost::make_shared<Hooke<double>>();
    aDoubleMaterialModel[MAT_NEOHOOKEAN] =
        boost::make_shared<NeoHookean<adouble>>();
    doubleMaterialModel[MAT_NEOHOOKEAN] =
        boost::make_shared<NeoHookean<double>>();
    std::ostringstream avilable_materials;
    avilable_materials << "set elastic material < ";
    std::map<std::string,
             boost::shared_ptr<
                 NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI<
                     double>>>::iterator mit;
    mit = doubleMaterialModel.begin();
    for (; mit != doubleMaterialModel.end(); mit++) {
      avilable_materials << mit->first << " ";
    }
    avilable_materials << ">";
 
    PetscOptionsBegin(mField.get_comm(), "", "Elastic Materials Configuration",
                      "none");
    char default_material[255];
    PetscBool def_mat_set;
    CHKERR PetscOptionsString(
        "-default_material", avilable_materials.str().c_str(), "",
        defMaterial.c_str(), default_material, 255, &def_mat_set);
    if (def_mat_set) {
      defMaterial = default_material;
      if (aDoubleMaterialModel.find(defMaterial) ==
          aDoubleMaterialModel.end()) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "material <%s> not implemented", default_material);
      }
    }
    char config_file[255];
    CHKERR PetscOptionsString("-elastic_material_configuration",
                              "elastic materials configure file name", "",
                              configFile.c_str(), config_file, 255,
                              &isConfigFileSet);
    if (isConfigFileSet) {
      configFile = config_file;
    }
    PetscOptionsEnd();
    MoFEMFunctionReturnHot(0);
  }

readConfigFile()

virtual MoFEMErrorCode ElasticMaterials::readConfigFile ( )

inlinevirtual

read Elastic materials declaration for blocks and meshsets

File parameters:

[block_1]
displacemet_order = 1/2 .. N
material = KIRCHHOFF/HOOKE/NEOHOOKEAN
young_modulus = 1
poisson_ratio = 0.25
density = 1
a_x = 0
a_y = 0
a_z = 10

To read material configuration file you need to use option:

-elastic_material_configuration name_of_config_file

Definition at line 153 of file ElasticMaterials.hpp.

                                          {
    MoFEMFunctionBegin;
 
    ifstream file(configFile.c_str());
    if (isConfigFileSet) {
      if (!file.good()) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "file < %s > not found",
                configFile.c_str());
      }
    } else {
      if (!file.good()) {
        MoFEMFunctionReturnHot(0);
      }
    }
 
    po::options_description config_file_options;
    for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
 
      std::ostringstream str_order;
      str_order << "block_" << it->getMeshsetId() << ".displacemet_order";
      config_file_options.add_options()(
          str_order.str().c_str(),
          po::value<int>(&blockData[it->getMeshsetId()].oRder)
              ->default_value(-1));
 
      std::ostringstream str_material;
      str_material << "block_" << it->getMeshsetId() << ".material";
      config_file_options.add_options()(
          str_material.str().c_str(),
          po::value<std::string>(&blockData[it->getMeshsetId()].mAterial)
              ->default_value(defMaterial));
 
      std::ostringstream str_ym;
      str_ym << "block_" << it->getMeshsetId() << ".young_modulus";
      config_file_options.add_options()(
          str_ym.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].yOung)
              ->default_value(-1));
 
      std::ostringstream str_pr;
      str_pr << "block_" << it->getMeshsetId() << ".poisson_ratio";
      config_file_options.add_options()(
          str_pr.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].pOisson)
              ->default_value(-2));
 
      std::ostringstream str_density;
      str_density << "block_" << it->getMeshsetId() << ".density";
      config_file_options.add_options()(
          str_density.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].dEnsity)
              ->default_value(-1));
 
      std::ostringstream str_dashG;
      str_dashG << "block_" << it->getMeshsetId() << ".dashG";
      config_file_options.add_options()(
          str_dashG.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].dashG)
              ->default_value(-1));
 
      std::ostringstream str_dashPoisson;
      str_dashPoisson << "block_" << it->getMeshsetId() << ".dashPoisson";
      config_file_options.add_options()(
          str_dashPoisson.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].dashPoisson)
              ->default_value(-2));
 
      std::ostringstream str_ax;
      str_ax << "block_" << it->getMeshsetId() << ".a_x";
      config_file_options.add_options()(
          str_ax.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].aX)
              ->default_value(0));
 
      std::ostringstream str_ay;
      str_ay << "block_" << it->getMeshsetId() << ".a_y";
      config_file_options.add_options()(
          str_ay.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].aY)
              ->default_value(0));
 
      std::ostringstream str_az;
      str_az << "block_" << it->getMeshsetId() << ".a_z";
      config_file_options.add_options()(
          str_az.str().c_str(),
          po::value<double>(&blockData[it->getMeshsetId()].aZ)
              ->default_value(0));
    }
    po::parsed_options parsed =
        parse_config_file(file, config_file_options, true);
    store(parsed, vM);
    po::notify(vM);
    std::vector<std::string> additional_parameters;
    additional_parameters =
        collect_unrecognized(parsed.options, po::include_positional);
    for (std::vector<std::string>::iterator vit = additional_parameters.begin();
         vit != additional_parameters.end(); vit++) {
      CHKERR PetscPrintf(PETSC_COMM_WORLD,
                         "** WARNING Unrecognized option %s\n", vit->c_str());
    }
 
    MoFEMFunctionReturn(0);
  }

setBlocksOrder()

MoFEMErrorCode ElasticMaterials::setBlocksOrder ( )

inline

Definition at line 257 of file ElasticMaterials.hpp.

                                  {
    MoFEMFunctionBeginHot;
 
    // set app. order
    PetscBool flg = PETSC_TRUE;
    PetscInt disp_order;
    CHKERR PetscOptionsGetInt(PETSC_NULLPTR, PETSC_NULLPTR, "-order", &disp_order,
                              &flg);
    if (flg != PETSC_TRUE) {
      disp_order = 1;
    }
    for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
      if (blockData[it->getMeshsetId()].oRder == -1)
        continue;
      if (blockData[it->getMeshsetId()].oRder == disp_order)
        continue;
      PetscPrintf(mField.get_comm(), "Set block %d oRder to %d\n",
                  it->getMeshsetId(), blockData[it->getMeshsetId()].oRder);
      Range block_ents;
      rval = mField.get_moab().get_entities_by_handle(it->meshset, block_ents,
                                                      true);
      CHKERRG(rval);
      Range ents_to_set_order;
      CHKERR mField.get_moab().get_adjacencies(
          block_ents, 3, false, ents_to_set_order, moab::Interface::UNION);
      ents_to_set_order = ents_to_set_order.subset_by_type(MBTET);
      CHKERR mField.get_moab().get_adjacencies(
          block_ents, 2, false, ents_to_set_order, moab::Interface::UNION);
      CHKERR mField.get_moab().get_adjacencies(
          block_ents, 1, false, ents_to_set_order, moab::Interface::UNION);
      if (mField.check_field("DISPLACEMENT")) {
        CHKERR mField.set_field_order(ents_to_set_order, "DISPLACEMENT",
                                      blockData[it->getMeshsetId()].oRder);
      }
      if (mField.check_field("SPATIAL_POSITION")) {
        CHKERR mField.set_field_order(ents_to_set_order, "SPATIAL_POSITION",
                                      blockData[it->getMeshsetId()].oRder);
      }
      if (mField.check_field("DOT_SPATIAL_POSITION")) {
        CHKERR mField.set_field_order(ents_to_set_order, "DOT_SPATIAL_POSITION",
                                      blockData[it->getMeshsetId()].oRder);
      }
      if (mField.check_field("SPATIAL_VELOCITY")) {
        CHKERR mField.set_field_order(ents_to_set_order, "SPATIAL_VELOCITY",
                                      blockData[it->getMeshsetId()].oRder);
      }
    }
    MoFEMFunctionReturnHot(0);
  }

Member Data Documentation

aDoubleMaterialModel

std::map<std::string, boost::shared_ptr<NonlinearElasticElement:: FunctionsToCalculatePiolaKirchhoffI<adouble> > > ElasticMaterials::aDoubleMaterialModel

Hash map of materials for evaluation with adouble, i.e. ADOL-C

Definition at line 43 of file ElasticMaterials.hpp.

blockData

std::map<int, BlockOptionData> ElasticMaterials::blockData

Material parameters on blocks.

Definition at line 69 of file ElasticMaterials.hpp.

configFile

std::string ElasticMaterials::configFile

Definition at line 29 of file ElasticMaterials.hpp.

defMaterial

std::string ElasticMaterials::defMaterial

default material, if block is set to elastic, this material is used as default

Definition at line 27 of file ElasticMaterials.hpp.

doubleMaterialModel

std::map< std::string, boost::shared_ptr< NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI<double> > > ElasticMaterials::doubleMaterialModel

Hash map of materials for evaluation with double.

Definition at line 50 of file ElasticMaterials.hpp.

iNitialized

bool ElasticMaterials::iNitialized

true if class is initialized

Definition at line 31 of file ElasticMaterials.hpp.

isConfigFileSet

PetscBool ElasticMaterials::isConfigFileSet

True if config file is set from command line.

Definition at line 71 of file ElasticMaterials.hpp.

mField

MoFEM::Interface& ElasticMaterials::mField

Definition at line 26 of file ElasticMaterials.hpp.

vM

po::variables_map ElasticMaterials::vM

Definition at line 72 of file ElasticMaterials.hpp.

---

The documentation for this struct was generated from the following file:

• users_modules/basic_finite_elements/nonlinear_elastic_materials/src/ElasticMaterials.hpp