nimble::MaterialFactoryBase Class Reference

#include <nimble_material_factory_base.h>

Inheritance diagram for nimble::MaterialFactoryBase:

Public Member Functions
	MaterialFactoryBase ()
virtual	~MaterialFactoryBase ()=default
void	add_valid_double_parameter_name (const char *name)
void	add_valid_string_parameter_name (const char *name)
virtual std::shared_ptr< nimble::Material >	get_material () const
virtual void	parse_and_create (const std::string &mat_params, int num_points)
virtual void	parse_and_create (const std::string &mat_params)
virtual std::map< std::string, double >	parse_material_params_string (const std::string &mat_params)

Protected Member Functions
virtual void	create ()=0
std::shared_ptr< nimble::MaterialParameters >	ParseMaterialParametersString (const std::string &material_parameters, int num_material_points=0) const
std::map< std::string, double >	ParseMaterialParamsStringToMap (const std::string &material_parameters) const

Protected Attributes
std::shared_ptr< nimble::Material >	material = nullptr
std::shared_ptr< const nimble::MaterialParameters >	material_params

Constructor & Destructor Documentation

MaterialFactoryBase()

nimble::MaterialFactoryBase::MaterialFactoryBase

(

)

{
  NeohookeanMaterial::register_supported_material_parameters(*this);
  ElasticMaterial::register_supported_material_parameters(*this);
}

~MaterialFactoryBase()

virtual nimble::MaterialFactoryBase::~MaterialFactoryBase ( )

virtualdefault

Member Function Documentation

add_valid_double_parameter_name()

void nimble::MaterialFactoryBase::add_valid_double_parameter_name ( const char * name )

inline

  {
    find_or_insert_string_in_vector(std::string(name), valid_double_parameter_names);
  }

add_valid_string_parameter_name()

void nimble::MaterialFactoryBase::add_valid_string_parameter_name ( const char * name )

inline

  {
    find_or_insert_string_in_vector(std::string(name), valid_string_parameter_names);
  }

create()

virtual void nimble::MaterialFactoryBase::create ( )

protectedpure virtual

Implemented in nimble::MaterialFactory, and nimble_kokkos::MaterialFactory.

get_material()

virtual std::shared_ptr< nimble::Material > nimble::MaterialFactoryBase::get_material ( ) const

inlinevirtual

  {
    return material;
  }

parse_and_create() [1/2]

virtual void nimble::MaterialFactoryBase::parse_and_create ( const std::string & mat_params )

inlinevirtual

  {
    parse_and_create(mat_params, 0);
  }

parse_and_create() [2/2]

virtual void nimble::MaterialFactoryBase::parse_and_create ( const std::string & mat_params, int num_points )

inlinevirtual

  {
    material_params = ParseMaterialParametersString(mat_params, num_points);
    create();
  }

parse_material_params_string()

virtual std::map< std::string, double > nimble::MaterialFactoryBase::parse_material_params_string ( const std::string & mat_params )

inlinevirtual

  {
    return ParseMaterialParamsStringToMap(mat_params);
  }

ParseMaterialParametersString()

std::shared_ptr< MaterialParameters > nimble::MaterialFactoryBase::ParseMaterialParametersString ( const std::string & material_parameters, int num_material_points = 0 ) const

protected

{
  auto tokens = nimble::tokenize_string(material_parameters);
 
  // The first string is the material name, followed by the material properties
  // (key-value pairs)
 
  NIMBLE_ASSERT(tokens.size() > 1);
 
  const std::string material_name = tokens.front();
  auto              token         = tokens.cbegin() + 1;
  auto              tokens_end    = tokens.cend();
 
  std::map<std::string, std::string> material_string_parameters;
  std::map<std::string, double>      material_double_parameters;
  for (; token != tokens_end; token += 2) {
    auto&& key = *token;
    auto&& val = *(token + 1);
    if (std::find(valid_double_parameter_names.begin(), valid_double_parameter_names.end(), key) !=
        valid_double_parameter_names.end()) {
      double double_val = nimble::string_to_double(val);
      material_double_parameters.insert(std::make_pair(key, double_val));
    } else if (
        std::find(valid_string_parameter_names.begin(), valid_string_parameter_names.end(), key) !=
        valid_string_parameter_names.end()) {
      material_string_parameters.insert(std::make_pair(key, val));
    } else {
      std::string errMsg = "Invalid material parameter encountered: '" + key + "'";
      throw std::invalid_argument(errMsg);
    }
  }
 
  return std::make_shared<MaterialParameters>(
      material_name, material_string_parameters, material_double_parameters, num_material_points);
}

ParseMaterialParamsStringToMap()

std::map< std::string, double > nimble::MaterialFactoryBase::ParseMaterialParamsStringToMap ( const std::string & material_parameters ) const

protected

{
  auto tokens = nimble::tokenize_string(material_parameters);
 
  // The first string is the material name, followed by the material properties (key-value pairs)
  NIMBLE_ASSERT(tokens.size() > 1);
 
  const std::string material_name = tokens.front();
  auto              token         = tokens.cbegin() + 1;
  auto              tokens_end    = tokens.cend();
 
  std::map<std::string, std::string> material_string_parameters;
  std::map<std::string, double>      material_double_parameters;
  for (; token != tokens_end; token += 2) {
    auto&& key = *token;
    auto&& val = *(token + 1);
    if (std::find(valid_double_parameter_names.begin(), valid_double_parameter_names.end(), key) !=
        valid_double_parameter_names.end()) {
      double double_val = nimble::string_to_double(val);
      material_double_parameters.insert(std::make_pair(key, double_val));
    } else if (
        std::find(valid_string_parameter_names.begin(), valid_string_parameter_names.end(), key) !=
        valid_string_parameter_names.end()) {
      material_string_parameters.insert(std::make_pair(key, val));
    } else {
      std::string errMsg = "Invalid material parameter encountered: '" + key + "'";
      throw std::invalid_argument(errMsg);
    }
  }
 
  return material_double_parameters;
}

Member Data Documentation

material

std::shared_ptr<nimble::Material> nimble::MaterialFactoryBase::material = nullptr

protected

material_params

std::shared_ptr<const nimble::MaterialParameters> nimble::MaterialFactoryBase::material_params

protected

---

The documentation for this class was generated from the following files:

• src/nimble_material_factory_base.h
• src/nimble_material_factory_base.cc