NEML2Utils Namespace Reference

Classes
struct	Layout
struct	Layout< RankFourTensor >
struct	Layout< RankTwoTensor >
struct	Layout< Real >
struct	Layout< RealVectorValue >
struct	Layout< SymmetricRankFourTensor >
struct	Layout< SymmetricRankTwoTensor >

Enumerations
enum class	MOOSEIOType {   TIME , SCALAR , FUNCTION , VARIABLE ,   MATERIAL }

Functions
std::string	stringify (MOOSEIOType type)
std::shared_ptr< neml2::Model >	getModel (neml2::Factory &factory, const std::string &name, neml2::Dtype dtype=neml2::kFloat64)
	Get the NEML2 Model.
template<typename T >
neml2::Tensor	fromBlob (const std::vector< T > &data)
	Map from std::vector<T> to neml2::Tensor without copying the data.
template<typename T >
void	copyTensorToMOOSEData (const at::Tensor &src, T &dest)
	Directly copy a contiguous chunk of memory of a at::Tensor to a MOOSE data of type T.
bool	shouldCompute (const SubProblem &)
	Determine whether the NEML2 material model should be evaluated.
std::string	docstring (const std::string &desc)
	Augment docstring if NEML2 is not enabled.
void	assertNEML2Enabled ()
	Assert that NEML2 is enabled.

Variables
static std::string	NEML2_help_message
static const std::string	missing_neml2

Enumeration Type Documentation

MOOSEIOType

enum class NEML2Utils::MOOSEIOType

strong

Enumerator
TIME
SCALAR
FUNCTION
VARIABLE
MATERIAL

Definition at line 35 of file NEML2Utils.h.

{
  // unbatched
  TIME,
  SCALAR,
  // batched
  FUNCTION,
  VARIABLE,
  MATERIAL
};

Function Documentation

assertNEML2Enabled()

void NEML2Utils::assertNEML2Enabled

(

)

Assert that NEML2 is enabled.

A MooseError is raised if NEML2 is not enabled.

Definition at line 81 of file NEML2Utils.C.

{
#ifndef NEML2_ENABLED
  mooseError(missing_neml2);
#endif
}

Referenced by NEML2Action::NEML2Action(), NEML2ActionCommon::NEML2ActionCommon(), and NEML2ToMOOSEMaterialProperty< T >::NEML2ToMOOSEMaterialProperty().

copyTensorToMOOSEData()

template<typename T >

void NEML2Utils::copyTensorToMOOSEData	(	const at::Tensor &	src,
		T &	dest
	)

Directly copy a contiguous chunk of memory of a at::Tensor to a MOOSE data of type T.

This assumes the at::Tensor and T have the same layout, for example both row-major with T = RankTwoTensor. If the layouts are different, we may need to reshape/reorder/transpose the at::Tensor before copying.

For this method to work,

1. the address of dest must align with the first element of the data,
2. the number of elements in dest must match the number of elements in src,
3. the src tensor must be of type neml2::kFloat64, and
4. data in dest must be reinterpretable as Real.

Definition at line 137 of file NEML2Utils.h.

{
  if (src.dtype() != neml2::kFloat64)
    mooseError(
        "Cannot copy at::Tensor with dtype ", src.dtype(), " into ", demangle(typeid(T).name()));
  if (src.numel() != Layout<T>::strides[0])
    mooseError("Cannot copy at::Tensor with shape ",
               src.sizes(),
               " into ",
               demangle(typeid(T).name()),
               " with different number of elements.");
  auto dest_tensor = at::from_blob(reinterpret_cast<Real *>(&dest),
                                   Layout<T>::shape,
                                   at::TensorOptions().dtype(neml2::kFloat64));
  dest_tensor.copy_(src.reshape(Layout<T>::shape));
}

docstring()

std::string NEML2Utils::docstring

(

const std::string &

desc

)

Augment docstring if NEML2 is not enabled.

Definition at line 71 of file NEML2Utils.C.

{
#ifndef NEML2_ENABLED
  return missing_neml2 + " (Original description: " + desc + ")";
#else
  return desc;
#endif
}

fromBlob()

template<typename T >

neml2::Tensor NEML2Utils::fromBlob

(

const std::vector< T > &

data

)

Map from std::vector<T> to neml2::Tensor without copying the data.

This method is used in gatherers which gather data from MOOSE as input variables to the NEML2 material model. So in theory, we only need to provide Layout specializations for MOOSE types that can potentially be used as NEML2 input variables.

For this method to work, the underlying data in data must be reinterpretable as Real (neml2::kFloat64). The data class T must also be aligned and follow the striding implied by Layout<T>::shape. The data class T must also have no padding or overhead.

Definition at line 112 of file NEML2Utils.h.

{
  // The const_cast is fine because torch works with non-const ptr so that it can optionally handle
  // deallocation. But we are not going to let torch do that.
  const auto torch_tensor = at::from_blob(const_cast<T *>(data.data()),
                                          neml2::utils::add_shapes(data.size(), Layout<T>::shape),
                                          at::TensorOptions().dtype(neml2::kFloat64));
  return neml2::Tensor(torch_tensor, 1);
}

Referenced by MOOSEQuantityToNEML2< T, state >::gatheredData().

getModel()

std::shared_ptr< neml2::Model > NEML2Utils::getModel	(	neml2::Factory &	factory,
		const std::string &	name,
		neml2::Dtype	dtype = neml2::kFloat64
	)

Get the NEML2 Model.

This is mostly the same as the plain neml2::get_model() method, but it also guards the default dtype and sends the model to the target device.

Returns

neml2::Model&

Definition at line 38 of file NEML2Utils.C.

{
  const auto prev_dtype = neml2::get_default_dtype();
  neml2::set_default_dtype(dtype);
  auto model = factory.get_model(name);
  model->to(dtype);
  neml2::set_default_dtype(prev_dtype);
  return model;
}

Referenced by NEML2Action::NEML2Action().

shouldCompute()

bool NEML2Utils::shouldCompute

(

const SubProblem &

problem

)

Determine whether the NEML2 material model should be evaluated.

Definition at line 53 of file NEML2Utils.C.

{
  // NEML2 computes residual and Jacobian together at EXEC_LINEAR
  // There is no work to be done at EXEC_NONLINEAR **UNLESS** we are computing the Jacobian for
  // automatic scaling.
  if (problem.computingScalingJacobian())
    return true;
 
  if (problem.currentlyComputingResidualAndJacobian())
    return true;
 
  if (problem.currentlyComputingJacobian())
    return false;
 
  return true;
}

Referenced by NEML2BatchIndexGenerator::execute(), NEML2BatchIndexGenerator::initialize(), NEML2ModelExecutor::meshChanged(), and NEML2BatchIndexGenerator::threadJoin().

stringify()

std::string NEML2Utils::stringify

(

MOOSEIOType

type

)

Definition at line 18 of file NEML2Utils.C.

{
  switch (type)
  {
    case NEML2Utils::MOOSEIOType::TIME:
      return "TIME";
    case NEML2Utils::MOOSEIOType::SCALAR:
      return "SCALAR";
    case NEML2Utils::MOOSEIOType::FUNCTION:
      return "FUNCTION";
    case NEML2Utils::MOOSEIOType::VARIABLE:
      return "VARIABLE";
    case NEML2Utils::MOOSEIOType::MATERIAL:
      return "MATERIAL";
    default:
      mooseError("Unknown MOOSE IO type.");
  }
}

Referenced by NEML2Action::printSummary().

Variable Documentation

missing_neml2

const std::string NEML2Utils::missing_neml2

static

Initial value:

= "The `NEML2` library is required but not enabled. Refer "
                                         "to the documentation for guidance on how to enable it."

Definition at line 49 of file NEML2Utils.C.

Referenced by assertNEML2Enabled(), and docstring().

NEML2_help_message

std::string NEML2Utils::NEML2_help_message

static

Initial value:

= R""""(
==============================================================================
To debug NEML2 related issues:
1. Build and run MOOSE in dbg mode.
2. Re-run the simulation using the dbg executable, and often times
   NEML2 will provide a more helpful error message.
3. If the error message is not helpful, or if there is still no error message,
   run the simulation through a debugger: See
   https://mooseframework.inl.gov/application_development/debugging.html
4. If the issue is due to a NEML2 bug, feel free to report it at
   https://github.com/applied-material-modeling/neml2/issues
==============================================================================
)""""

Definition at line 154 of file NEML2Utils.h.

Referenced by NEML2ModelExecutor::extractOutputs(), and NEML2ModelExecutor::fillInputs().