neml2::LAROMANCE6DInterpolation Class Reference

#include <LAROMANCE6DInterpolation.h>

Inheritance diagram for neml2::LAROMANCE6DInterpolation:

Public Types
enum class	TransformEnum {   COMPRESS , DECOMPRESS , LOG10BOUNDED , EXP10BOUNDED ,   MINMAX }

Public Member Functions
	LAROMANCE6DInterpolation (const OptionSet &options)
void	request_AD () override

Static Public Member Functions
static OptionSet	expected_options ()

Protected Member Functions
void	set_value (bool, bool, bool) override

Private Member Functions
std::pair< Scalar, Scalar >	findLeftIndexAndFraction (const Scalar &grid, const Scalar &interp_points) const
	find index of input point
Scalar	interpolate_and_transform () const
	compute interpolated value and transform results
Scalar	transform_data (const Scalar &data, const std::vector< double > &param, TransformEnum transform_type) const
	transform data
std::string	json_to_string (const std::string &key) const
	read in json axes transform name
std::vector< double >	json_to_vector (const std::string &key) const
	read in json axes transform constants
Scalar	json_6Dvector_to_torch (const std::string &key) const
	read 6D grid date from json and store in Torch tensor
Scalar	json_vector_to_torch (const std::string &key) const
	read 1D vector of grid points from json and store in Torch tensor
Scalar	compute_interpolation (const std::vector< std::pair< Scalar, Scalar > > index_and_fraction, const Scalar grid_values) const
	compute interpolated value
TransformEnum	get_transform_enum (const std::string &name) const
Scalar	transform_compress (const Scalar &data, const std::vector< double > &params) const
	LAROMANCE transforms for input axes and output axis.
Scalar	transform_decompress (const Scalar &data, const std::vector< double > &params) const
Scalar	transform_log10_bounded (const Scalar &data, const std::vector< double > &params) const
Scalar	transform_exp10_bounded (const Scalar &data, const std::vector< double > &params) const
Scalar	transform_min_max (const Scalar &data, const std::vector< double > &params) const

Private Attributes
Scalar	_stress_grid
	grid for interpolation
Scalar	_temperature_grid
Scalar	_plastic_strain_grid
Scalar	_cell_grid
Scalar	_wall_grid
Scalar	_env_grid
Scalar	_grid_values
	grid values being interpolated
const Variable< Scalar > &	_vm_stress
	Model input for interpolation.
const Variable< Scalar > &	_temperature
	Temperature.
const Variable< Scalar > &	_ep_strain
	The creep strain.
const Variable< Scalar > &	_cell_dd
	cell dislocation density
const Variable< Scalar > &	_wall_dd
	wall dislocation density
const Variable< Scalar > &	_env_fac
	environmental factor
Variable< Scalar > &	_output_rate
	Model output.
nlohmann::json	_json
	JSON object containing interpolation grid and values.
TransformEnum	_stress_transform_enum
	input transform enums
TransformEnum	_temperature_transform_enum
TransformEnum	_plastic_strain_transform_enum
TransformEnum	_cell_transform_enum
TransformEnum	_wall_transform_enum
TransformEnum	_env_transform_enum
std::vector< double >	_stress_transform_values
	input transform values
std::vector< double >	_temperature_transform_values
std::vector< double >	_plastic_strain_transform_values
std::vector< double >	_cell_transform_values
std::vector< double >	_wall_transform_values
std::vector< double >	_env_transform_values
std::string	_output_rate_name
	output transform rate name
std::vector< double >	_output_transform_values
	output transform values
TransformEnum	_output_transform_enum
	output transform enum

Detailed Description

Definition at line 19 of file LAROMANCE6DInterpolation.h.

Member Enumeration Documentation

TransformEnum

enum class neml2::LAROMANCE6DInterpolation::TransformEnum

strong

Enumerator
COMPRESS
DECOMPRESS
LOG10BOUNDED
EXP10BOUNDED
MINMAX

Definition at line 28 of file LAROMANCE6DInterpolation.h.

  {
    COMPRESS,
    DECOMPRESS,
    LOG10BOUNDED,
    EXP10BOUNDED,
    MINMAX
  };

Constructor & Destructor Documentation

LAROMANCE6DInterpolation()

neml2::LAROMANCE6DInterpolation::LAROMANCE6DInterpolation

(

const OptionSet &

options

)

Definition at line 60 of file LAROMANCE6DInterpolation.C.

  : Model(options),
    _vm_stress(declare_input_variable<Scalar>("von_mises_stress")),
    _temperature(declare_input_variable<Scalar>("temperature")),
    _ep_strain(declare_input_variable<Scalar>("equivalent_plastic_strain")),
    _cell_dd(declare_input_variable<Scalar>("cell_dislocation_density")),
    _wall_dd(declare_input_variable<Scalar>("wall_dislocation_density")),
    _env_fac(declare_input_variable<Scalar>("env_factor")),
    _output_rate(declare_output_variable<Scalar>("output_rate"))
{
  std::string filename = options.get<std::string>("model_file_name");
  std::ifstream model_file(filename.c_str());
  model_file >> _json;
 
  // storing grid points for indexing.
  // these should be stored differently so that they are all read in at once.  The order of this can
  // get messed up easily
  _stress_grid = json_vector_to_torch("in_stress");
  _temperature_grid = json_vector_to_torch("in_temperature");
  _plastic_strain_grid = json_vector_to_torch("in_plastic_strain");
  _cell_grid = json_vector_to_torch("in_cell");
  _wall_grid = json_vector_to_torch("in_wall");
  _env_grid = json_vector_to_torch("in_env");
 
  // Read in grid axes transform enums
  _stress_transform_enum = get_transform_enum(json_to_string("in_stress_transform_type"));
  _temperature_transform_enum = get_transform_enum(json_to_string("in_temperature_transform_type"));
  _plastic_strain_transform_enum =
      get_transform_enum(json_to_string("in_plastic_strain_transform_type"));
  _cell_transform_enum = get_transform_enum(json_to_string("in_cell_transform_type"));
  _wall_transform_enum = get_transform_enum(json_to_string("in_wall_transform_type"));
  _env_transform_enum = get_transform_enum(json_to_string("in_env_transform_type"));
 
  // Read in grid axes transform values
  _stress_transform_values = json_to_vector("in_stress_transform_values");
  _temperature_transform_values = json_to_vector("in_temperature_transform_values");
  _plastic_strain_transform_values = json_to_vector("in_plastic_strain_transform_values");
  _cell_transform_values = json_to_vector("in_cell_transform_values");
  _wall_transform_values = json_to_vector("in_wall_transform_values");
  _env_transform_values = json_to_vector("in_env_transform_values");
 
  // Storing values for interpolation
  _output_rate_name = options.get<std::string>("model_file_variable_name");
  _grid_values = json_6Dvector_to_torch(_output_rate_name);
 
  // set up output transforms
  if (_output_rate_name == "out_ep")
  {
    _output_transform_enum = get_transform_enum(json_to_string("out_strain_rate_transform_type"));
    _output_transform_values = json_to_vector("out_strain_rate_transform_values");
  }
  else if (_output_rate_name == "out_cell")
  {
    _output_transform_enum = get_transform_enum(json_to_string("out_cell_rate_transform_type"));
    _output_transform_values = json_to_vector("out_cell_rate_transform_values");
  }
  else if (_output_rate_name == "out_wall")
  {
    _output_transform_enum = get_transform_enum(json_to_string("out_wall_rate_transform_type"));
    _output_transform_values = json_to_vector("out_wall_rate_transform_values");
  }
  else
  {
    throw NEMLException("This ouput variable is not implemented, model_file_variable_name: " +
                        std::string(_output_rate_name));
  }
}

Member Function Documentation

compute_interpolation()

Scalar neml2::LAROMANCE6DInterpolation::compute_interpolation ( const std::vector< std::pair< Scalar, Scalar > >  index_and_fraction, const Scalar  grid_values  ) const

private

compute interpolated value

Definition at line 183 of file LAROMANCE6DInterpolation.C.

{
  Scalar result = Scalar::zeros_like(_temperature());
  for (const auto i : {0, 1})
    for (const auto j : {0, 1})
      for (const auto k : {0, 1})
        for (const auto l : {0, 1})
          for (const auto m : {0, 1})
            for (const auto n : {0, 1})
            {
              auto vertex_value =
                  grid_values.index({(index_and_fraction[0].first +
                                      torch::tensor(i, default_integer_tensor_options())),
                                     (index_and_fraction[1].first +
                                      torch::tensor(j, default_integer_tensor_options())),
                                     (index_and_fraction[2].first +
                                      torch::tensor(k, default_integer_tensor_options())),
                                     (index_and_fraction[3].first +
                                      torch::tensor(l, default_integer_tensor_options())),
                                     (index_and_fraction[4].first +
                                      torch::tensor(m, default_integer_tensor_options())),
                                     (index_and_fraction[5].first +
                                      torch::tensor(n, default_integer_tensor_options()))});
              auto weight = index_and_fraction[0].second.select(-1, i) *
                            index_and_fraction[1].second.select(-1, j) *
                            index_and_fraction[2].second.select(-1, k) *
                            index_and_fraction[3].second.select(-1, l) *
                            index_and_fraction[4].second.select(-1, m) *
                            index_and_fraction[5].second.select(-1, n);
              result += vertex_value * weight;
            }
  return result;
}

Referenced by interpolate_and_transform().

expected_options()

OptionSet neml2::LAROMANCE6DInterpolation::expected_options ( )

static

Definition at line 30 of file LAROMANCE6DInterpolation.C.

{
  auto options = Model::expected_options();
  options.doc() =
      "Multilinear interpolation over six dimensions (von_mises_stress, temperature, "
      "equivalent_plastic_strain, cell_dislocation_density, wall_dislocation_density, env_factor)";
 
  // Model inputs
  options.add_input("equivalent_plastic_strain", "The equivalent plastic strain");
  options.add_input("von_mises_stress", "The von Mises stress");
  options.add_input("cell_dislocation_density", "The cell dislocation density");
  options.add_input("wall_dislocation_density", "The wall dislocation density");
  options.add_input("temperature", "The temperature");
  options.add_input("env_factor", "The environment factor");
 
  // Model Outputs
  options.add_output("output_rate", "The output rate");
 
  // JSON
  options.add<std::string>("model_file_name", "The name of the model file");
  options.add<std::string>("model_file_variable_name",
                           "The name of the variable in the model file");
 
  // jit does not currently work with this
  options.set<bool>("jit", false);
  options.suppress("jit");
 
  return options;
}

findLeftIndexAndFraction()

std::pair< Scalar, Scalar > neml2::LAROMANCE6DInterpolation::findLeftIndexAndFraction ( const Scalar &  grid, const Scalar &  interp_points  ) const

private

find index of input point

Definition at line 164 of file LAROMANCE6DInterpolation.C.

{
  // idx is for the left grid point.
  // searchsorted returns the right idx so -1 makes it the left
  auto left_idx = Scalar(torch::searchsorted(grid, interp_points) - 1, 0);
 
  // this allows us to extrapolate
  left_idx = Scalar(torch::clamp(left_idx, 0, grid.sizes()[0] - 2), 0);
 
  auto left_coord = grid.dynamic_index({left_idx});
  auto right_coord =
      grid.dynamic_index({left_idx + torch::tensor(1, default_integer_tensor_options())});
  auto left_fraction = (right_coord - interp_points) / (right_coord - left_coord);
 
  return {left_idx, neml2::dynamic_stack({left_fraction, 1 - left_fraction}, -1)};
}

Referenced by interpolate_and_transform().

get_transform_enum()

LAROMANCE6DInterpolation::TransformEnum neml2::LAROMANCE6DInterpolation::get_transform_enum ( const std::string &  name ) const

private

Definition at line 147 of file LAROMANCE6DInterpolation.C.

{
  if (name == "COMPRESS")
    return TransformEnum::COMPRESS;
  else if (name == "DECOMPRESS")
    return TransformEnum::DECOMPRESS;
  else if (name == "LOG10BOUNDED")
    return TransformEnum::LOG10BOUNDED;
  else if (name == "EXP10BOUNDED")
    return TransformEnum::EXP10BOUNDED;
  else if (name == "MINMAX")
    return TransformEnum::MINMAX;
 
  throw NEMLException("Unrecognized transform: " + std::string(name));
}

Referenced by LAROMANCE6DInterpolation().

interpolate_and_transform()

Scalar neml2::LAROMANCE6DInterpolation::interpolate_and_transform ( ) const

private

compute interpolated value and transform results

compute interpolated value

Definition at line 220 of file LAROMANCE6DInterpolation.C.

{
  // These transform constants should be given in the json file.
  const auto cell_dd_transformed =
      transform_data(_cell_dd(), _cell_transform_values, _cell_transform_enum);
  const auto wall_dd_transformed =
      transform_data(_wall_dd(), _wall_transform_values, _wall_transform_enum);
  const auto vm_stress_transformed =
      transform_data(_vm_stress(), _stress_transform_values, _stress_transform_enum);
  const auto ep_strain_transformed = transform_data(
      _ep_strain(), _plastic_strain_transform_values, _plastic_strain_transform_enum);
  const auto temperature_transformed =
      transform_data(_temperature(), _temperature_transform_values, _temperature_transform_enum);
  const auto env_fac_transformed =
      transform_data(_env_fac(), _env_transform_values, _env_transform_enum);
 
  std::vector<std::pair<Scalar, Scalar>> left_index_weight;
  left_index_weight.push_back(findLeftIndexAndFraction(_stress_grid, vm_stress_transformed));
  left_index_weight.push_back(findLeftIndexAndFraction(_temperature_grid, temperature_transformed));
  left_index_weight.push_back(
      findLeftIndexAndFraction(_plastic_strain_grid, ep_strain_transformed));
  left_index_weight.push_back(findLeftIndexAndFraction(_cell_grid, cell_dd_transformed));
  left_index_weight.push_back(findLeftIndexAndFraction(_wall_grid, wall_dd_transformed));
  left_index_weight.push_back(findLeftIndexAndFraction(_env_grid, env_fac_transformed));
  Scalar interpolated_result = compute_interpolation(left_index_weight, _grid_values);
  Scalar transformed_result =
      transform_data(interpolated_result, _output_transform_values, _output_transform_enum);
  return transformed_result;
}

Referenced by set_value().

json_6Dvector_to_torch()

Scalar neml2::LAROMANCE6DInterpolation::json_6Dvector_to_torch ( const std::string &  key ) const

private

read 6D grid date from json and store in Torch tensor

Definition at line 376 of file LAROMANCE6DInterpolation.C.

{
  using std::vector;
  if (!_json.contains(key))
    throw NEMLException("The key '" + std::string(key) + "' is missing from the JSON data file.");
 
  vector<vector<vector<vector<vector<vector<double>>>>>> out_data =
      _json[key].get<vector<vector<vector<vector<vector<vector<double>>>>>>>();
 
  const int64_t sz_l0 = out_data.size();
  const int64_t sz_l1 = out_data[0].size();
  const int64_t sz_l2 = out_data[0][0].size();
  const int64_t sz_l3 = out_data[0][0][0].size();
  const int64_t sz_l4 = out_data[0][0][0][0].size();
  const int64_t sz_l5 = out_data[0][0][0][0][0].size();
 
  auto check_level_size =
      [](const int64_t current_vec_size, const int64_t sz_level, const std::string & key)
  {
    if (current_vec_size != sz_level)
      throw NEMLException("Incorrect JSON interpolation grid size for '" + key + "'.");
  };
 
  std::vector<double> linearize_values;
  check_level_size(out_data.size(), sz_l0, key);
  for (auto && level1 : out_data)
  {
    check_level_size(level1.size(), sz_l1, key);
    for (auto && level2 : level1)
    {
      check_level_size(level2.size(), sz_l2, key);
      for (auto && level3 : level2)
      {
        check_level_size(level3.size(), sz_l3, key);
        for (auto && level4 : level3)
        {
          check_level_size(level4.size(), sz_l4, key);
          for (auto && level5 : level4)
          {
            check_level_size(level5.size(), sz_l5, key);
            for (auto && value : level5)
              linearize_values.push_back(value);
          }
        }
      }
    }
  }
 
  return Scalar::create(linearize_values)
      .dynamic_reshape({sz_l0, sz_l1, sz_l2, sz_l3, sz_l4, sz_l5})
      .clone();
}

Referenced by LAROMANCE6DInterpolation().

json_to_string()

std::string neml2::LAROMANCE6DInterpolation::json_to_string ( const std::string &  key ) const

private

read in json axes transform name

Definition at line 346 of file LAROMANCE6DInterpolation.C.

{
  if (!_json.contains(key))
    throw NEMLException("The key '" + std::string(key) + "' is missing from the JSON data file.");
 
  std::string name = _json[key].get<std::string>();
  return name;
}

Referenced by LAROMANCE6DInterpolation().

json_to_vector()

std::vector< double > neml2::LAROMANCE6DInterpolation::json_to_vector ( const std::string &  key ) const

private

read in json axes transform constants

Definition at line 356 of file LAROMANCE6DInterpolation.C.

{
  if (!_json.contains(key))
    throw NEMLException("The key '" + std::string(key) + "' is missing from the JSON data file.");
 
  std::vector<double> data_vec = _json[key].get<std::vector<double>>();
  return data_vec;
}

Referenced by LAROMANCE6DInterpolation().

json_vector_to_torch()

Scalar neml2::LAROMANCE6DInterpolation::json_vector_to_torch ( const std::string &  key ) const

private

read 1D vector of grid points from json and store in Torch tensor

Definition at line 366 of file LAROMANCE6DInterpolation.C.

{
  if (!_json.contains(key))
    throw NEMLException("The key '" + std::string(key) + "' is missing from the JSON data file.");
 
  std::vector<double> in_data = _json[key].get<std::vector<double>>();
  return Scalar::create(in_data).clone();
}

Referenced by LAROMANCE6DInterpolation().

request_AD()

void neml2::LAROMANCE6DInterpolation::request_AD ( )

override

Definition at line 129 of file LAROMANCE6DInterpolation.C.

{
  // only using first derivatives of out_ep, not out_cell and out_wall
  if (_output_rate_name == "out_ep")
  {
    std::vector<const VariableBase *> inputs = {&_vm_stress};
    _output_rate.request_AD(inputs);
  }
}

set_value()

void neml2::LAROMANCE6DInterpolation::set_value ( bool  out, bool  , bool    )

overrideprotected

Definition at line 140 of file LAROMANCE6DInterpolation.C.

{
  if (out)
    _output_rate = interpolate_and_transform();
}

transform_compress()

Scalar neml2::LAROMANCE6DInterpolation::transform_compress ( const Scalar &  data, const std::vector< double > &  params  ) const

private

LAROMANCE transforms for input axes and output axis.

Definition at line 278 of file LAROMANCE6DInterpolation.C.

{
  double factor = param[0];
  double compressor = param[1];
  double original_min = param[2];
  auto d1 = neml2::sign(data) * neml2::pow(neml2::abs(data * factor), compressor);
  auto transformed_data = neml2::log10(1.0 + d1 - original_min);
  return transformed_data;
}

Referenced by transform_data().

transform_data()

Scalar neml2::LAROMANCE6DInterpolation::transform_data ( const Scalar &  data, const std::vector< double > &  param, TransformEnum  transform_type  ) const

private

transform data

Definition at line 251 of file LAROMANCE6DInterpolation.C.

{
  switch (transform_type)
  {
    case TransformEnum::COMPRESS:
      return transform_compress(data, param);
 
    case TransformEnum::DECOMPRESS:
      return transform_decompress(data, param);
 
    case TransformEnum::LOG10BOUNDED:
      return transform_log10_bounded(data, param);
 
    case TransformEnum::EXP10BOUNDED:
      return transform_exp10_bounded(data, param);
 
    case TransformEnum::MINMAX:
      return transform_min_max(data, param);
 
    default:
      return data;
  }
}

Referenced by interpolate_and_transform().

transform_decompress()

Scalar neml2::LAROMANCE6DInterpolation::transform_decompress ( const Scalar &  data, const std::vector< double > &  params  ) const

private

Definition at line 290 of file LAROMANCE6DInterpolation.C.

{
  double factor = param[0];
  double compressor = param[1];
  double original_min = param[2];
  auto d1 = neml2::pow(10.0, data) - 1.0 + original_min;
  auto transformed_data = neml2::sign(d1) * neml2::pow(neml2::abs(d1), 1.0 / compressor) / factor;
  return transformed_data;
}

Referenced by transform_data().

transform_exp10_bounded()

Scalar neml2::LAROMANCE6DInterpolation::transform_exp10_bounded ( const Scalar &  data, const std::vector< double > &  params  ) const

private

Definition at line 318 of file LAROMANCE6DInterpolation.C.

{
  double factor = param[0];
  double lowerbound = param[1];
  double upperbound = param[2];
  double logmin = param[3];
  double logmax = param[4];
  double range = upperbound - lowerbound;
  auto transformed_data =
      (neml2::pow(10.0, ((data - lowerbound) * (logmax - logmin) / range) + logmin) - factor);
  return transformed_data;
}

Referenced by transform_data().

transform_log10_bounded()

Scalar neml2::LAROMANCE6DInterpolation::transform_log10_bounded ( const Scalar &  data, const std::vector< double > &  params  ) const

private

Definition at line 302 of file LAROMANCE6DInterpolation.C.

{
  double factor = param[0];
  double lowerbound = param[1];
  double upperbound = param[2];
  double logmin = param[3];
  double logmax = param[4];
  double range = upperbound - lowerbound;
  auto transformed_data =
      range * (neml2::log10(data + factor) - logmin) / (logmax - logmin) + lowerbound;
  return transformed_data;
}

Referenced by transform_data().

transform_min_max()

Scalar neml2::LAROMANCE6DInterpolation::transform_min_max ( const Scalar &  data, const std::vector< double > &  params  ) const

private

Definition at line 333 of file LAROMANCE6DInterpolation.C.

{
  double data_min = param[0];
  double data_max = param[1];
  double scaled_min = param[2];
  double scaled_max = param[3];
  auto transformed_data =
      ((data - data_min) / (data_max - data_min)) * (scaled_max - scaled_min) + scaled_min;
  return transformed_data;
}

Referenced by transform_data().

Member Data Documentation

_cell_dd

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_cell_dd

private

cell dislocation density

Definition at line 61 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform().

_cell_grid

Scalar neml2::LAROMANCE6DInterpolation::_cell_grid

private

Definition at line 45 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_cell_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_cell_transform_enum

private

Definition at line 111 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_cell_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_cell_transform_values

private

Definition at line 119 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_env_fac

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_env_fac

private

environmental factor

Definition at line 65 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform().

_env_grid

Scalar neml2::LAROMANCE6DInterpolation::_env_grid

private

Definition at line 47 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_env_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_env_transform_enum

private

Definition at line 113 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_env_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_env_transform_values

private

Definition at line 121 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_ep_strain

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_ep_strain

private

The creep strain.

Definition at line 59 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform().

_grid_values

Scalar neml2::LAROMANCE6DInterpolation::_grid_values

private

grid values being interpolated

Definition at line 50 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_json

nlohmann::json neml2::LAROMANCE6DInterpolation::_json

private

JSON object containing interpolation grid and values.

Definition at line 75 of file LAROMANCE6DInterpolation.h.

Referenced by json_6Dvector_to_torch(), json_to_string(), json_to_vector(), json_vector_to_torch(), and LAROMANCE6DInterpolation().

_output_rate

Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_output_rate

private

Model output.

output rate

Definition at line 71 of file LAROMANCE6DInterpolation.h.

Referenced by request_AD(), and set_value().

_output_rate_name

std::string neml2::LAROMANCE6DInterpolation::_output_rate_name

private

output transform rate name

Definition at line 124 of file LAROMANCE6DInterpolation.h.

Referenced by LAROMANCE6DInterpolation(), and request_AD().

_output_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_output_transform_enum

private

output transform enum

Definition at line 128 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_output_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_output_transform_values

private

output transform values

Definition at line 126 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_plastic_strain_grid

Scalar neml2::LAROMANCE6DInterpolation::_plastic_strain_grid

private

Definition at line 44 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_plastic_strain_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_plastic_strain_transform_enum

private

Definition at line 110 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_plastic_strain_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_plastic_strain_transform_values

private

Definition at line 118 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_stress_grid

Scalar neml2::LAROMANCE6DInterpolation::_stress_grid

private

grid for interpolation

Definition at line 42 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_stress_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_stress_transform_enum

private

input transform enums

Definition at line 108 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_stress_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_stress_transform_values

private

input transform values

Definition at line 116 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_temperature

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_temperature

private

Temperature.

Definition at line 57 of file LAROMANCE6DInterpolation.h.

Referenced by compute_interpolation(), and interpolate_and_transform().

_temperature_grid

Scalar neml2::LAROMANCE6DInterpolation::_temperature_grid

private

Definition at line 43 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_temperature_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_temperature_transform_enum

private

Definition at line 109 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_temperature_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_temperature_transform_values

private

Definition at line 117 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_vm_stress

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_vm_stress

private

Model input for interpolation.

The von Mises stress

Definition at line 55 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and request_AD().

_wall_dd

const Variable<Scalar>& neml2::LAROMANCE6DInterpolation::_wall_dd

private

wall dislocation density

Definition at line 63 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform().

_wall_grid

Scalar neml2::LAROMANCE6DInterpolation::_wall_grid

private

Definition at line 46 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_wall_transform_enum

TransformEnum neml2::LAROMANCE6DInterpolation::_wall_transform_enum

private

Definition at line 112 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

_wall_transform_values

std::vector<double> neml2::LAROMANCE6DInterpolation::_wall_transform_values

private

Definition at line 120 of file LAROMANCE6DInterpolation.h.

Referenced by interpolate_and_transform(), and LAROMANCE6DInterpolation().

---

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

• solid_mechanics/include/neml2/LAROMANCE6DInterpolation.h
• solid_mechanics/src/neml2/LAROMANCE6DInterpolation.C