neml2 Namespace Reference

Namespaces
namespace	crystallography
namespace	indexing
namespace	jit
namespace	linalg
namespace	utils

Classes
class	AnisotropicElasticity
class	ArrheniusParameter
	A scalar-valued parameter following an Arrhenius type relation. More...
class	AssociativeIsotropicPlasticHardening
class	AssociativeJ2FlowDirection
	The plastic flow direction assuming an associative J2 flow. More...
class	AssociativeKinematicPlasticHardening
class	AssociativePlasticFlow
class	AvramiErofeevNucleation
	Define the chemical reaction model. More...
class	BackwardEulerTimeIntegration
class	BufferStore
	Interface for object which can store buffers. More...
class	ChabochePlasticHardening
class	ChemicalReactionMechanism
	Define the chemical reaction model. More...
class	ComposedModel
class	ConstantParameter
	A parameter that is actually just a constant. More...
class	CopyVariable
	Copy the value of a variable into another variable. More...
class	CrystalMean
class	CubicElasticityConverter
	Converter for linearized elastic constants assuming cubic symmetry. More...
class	CubicElasticityTensor
	Define an cubic symmetry elasticity tensor in various ways. More...
class	Data
class	DependencyDefinition
class	DependencyResolver
	The DependencyResolver identifies and resolves the dependencies among a set of objects derived from DependencyDefinition. More...
class	Derivative
struct	Diagnosing
class	Diagnosis
	Exception type reserved for diagnostics, so as to not conceptually clash with other exceptions. More...
class	DiagnosticsInterface
	Interface for object making diagnostics about common setup errors. More...
struct	DiagnosticState
class	DiffusionLimitedReaction
class	Driver
	The Driver drives the execution of a NEML2 Model. More...
class	Eigenstrain
class	Elasticity
class	ElasticityConverter
	Base class for converters responsible for converting between different parameterizations of the linear elasticity tensor in different symmetry groups. More...
class	ElasticityInterface
	Interface for objects defining elasticity tensors in terms of other parameters. More...
class	ElasticStrainRate
	Calculate the elastic strain rate from crystal model kinematics. More...
class	EmptyPrimitiveTensor
	Create an empty PrimitiveTensor of type T from the input file. More...
class	EmptyTensor
	Create an empty Tensor from the input file. More...
class	EnumSelection
	Selection of an enum value from a list of candidates. More...
class	EnumSelectionBase
class	Factory
class	FactoryException
class	FillMillerIndex
	Create a single-batched "list" of Miller indices. More...
class	FillR2
	Create a filled R2 from the input file. More...
class	FillRot
	Create a filled R2 from the input file. More...
class	FillSR2
	Create a filled SR2 from the input file. More...
class	FillWR2
	Create a filled WR2 from the input file. More...
class	FischerBurmeister
	Define the Fischer Burmeister Complementary Conditions. More...
class	FixedSizeWorkGenerator
	Interface for work generators that generate a fixed number of batches, i.e., the total amount of work is known at construction time. More...
class	FixOrientation
	Swap orientation plane when the singularity at $2\pi$ is met with the modified Rodrigues vector. More...
class	FlowRule
class	ForwardEulerTimeIntegration
class	FredrickArmstrongPlasticHardening
class	FromTorchScript
	Read the tensors provided by a torch script file. More...
class	FullPrimitiveTensor
	Create a full PrimitiveTensor of type T from the input file. More...
class	FullTensor
	Create a full Tensor from the input file. More...
class	GeneralElasticity
class	GTNYieldFunction
class	GursonCavitation
class	HermiteSmoothStep
class	HITParser
	A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
class	IdentityTensor
	Create an identity Tensor from the input file. More...
class	ImplicitUpdate
class	IncrementToRate
class	InputParameter
	A parameter that is defined by an input variable. More...
class	Interpolation
	The base class for interpolated variable. More...
class	IsotropicElasticityConverter
	Converter for linearized elastic constants assuming isotropic symmetry. More...
class	IsotropicElasticityTensor
	Define an isotropoic elasticity tensor in various ways. More...
class	IsotropicHardening
class	IsotropicHardeningStaticRecovery
class	IsotropicMandelStress
class	KinematicHardening
class	KinematicHardeningStaticRecovery
class	KocksMeckingActivationEnergy
class	KocksMeckingFlowSwitch
class	KocksMeckingFlowViscosity
	A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
class	KocksMeckingIntercept
	A scalar-valued parameter defined by (C-B) / A. More...
class	KocksMeckingRateSensitivity
	A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
class	KocksMeckingYieldStress
	A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
class	LabeledAxis
	A labeled axis used to associate layout of a tensor with human-interpretable names. More...
class	LabeledAxisAccessor
	The accessor containing all the information needed to access an item in a LabeledAxis. More...
class	LDISolidMechanicsDriver
	Large deformation incremental solid mechanics driver. More...
class	LinearCombination
class	LinearInterpolation
	Linearly interpolate the parameter along a single axis. More...
class	LinearIsotropicElasticity
class	LinearIsotropicElasticJ2TrialStressUpdate
	Update the trial stress under the assumptions of J2 plasticity and isotropic linear elasticity. More...
class	LinearIsotropicHardening
	Simple linear map between equivalent strain and isotropic hardening. More...
class	LinearKinematicHardening
	Simple linear map between equivalent strain and hardening. More...
class	LinearSingleSlipHardeningRule
	Linear slip hardening of the type $\dot{\overline{\tau }}=\theta \sum \left|{\dot{\gamma }}_i\right|$. More...
class	LinspacePrimitiveTensor
	Create a linspace PrimitiveTensor of type T from the input file. More...
class	LinspaceTensor
	Create a linspace Tensor from the input file. More...
class	LogspacePrimitiveTensor
	Create a logspace PrimitiveTensor of type T from the input file. More...
class	LogspaceTensor
	Create a logspace Tensor from the input file. More...
class	MandelStress
class	MatrixAssembler
	Helper to assemble a matrix of tensors into a single tensor and also to split a tensor into a map of map of tensors. More...
class	MillerIndex
	Represention of a crystal direction or plane a Miller Index. More...
class	MixedControlSetup
class	Model
	The base class for all constitutive models. More...
class	ModelDriver
	A general-purpose driver that does something with a model. More...
class	MultiEnumSelection
	Selection of multiple enum value from a list of candidates. More...
class	NEML2Object
	The base class of all "manufacturable" objects in the NEML2 library. More...
class	NEMLException
class	Newton
	The nonlinear solver solves a nonlinear system of equations. More...
class	NewtonWithLineSearch
	The nonlinear solver solves a nonlinear system of equations. More...
class	NewtonWithTrustRegion
	The nonlinear solver solves a nonlinear system of equations. More...
struct	NonlinearParameter
	Nonlinear parameter. More...
class	NonlinearSolver
	The nonlinear solver solves a nonlinear system of equations. More...
class	NonlinearSystem
	Definition of a nonlinear system of equations. More...
class	Normality
class	OlevskySinteringStress
class	OnesPrimitiveTensor
	Create a ones PrimitiveTensor of type T from the input file. More...
class	OnesTensor
	Create a ones Tensor from the input file. More...
class	Option
class	OptionBase
class	OptionCollection
	A data structure that holds options of multiple objects. More...
class	OptionSet
	A custom map-like data structure. The keys are strings, and the values can be nonhomogeneously typed. More...
class	Orientation
	Create batch of rotations, with various methods. More...
class	OrientationRate
	Calculate the orientation rate from the crystal model kinetics. More...
class	ParameterStore
	Interface for object which can store parameters. More...
class	Parser
	A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
class	ParserException
class	PerzynaPlasticFlowRate
class	PhaseTransformationEigenstrain
	Define the phase transformation eigenstrain. More...
class	PlasticDeformationRate
	Plastic deformation rate with the default kinetics. More...
class	PlasticFlowRate
class	PlasticVorticity
	Calculate the plastic vorticity with the default crystal kinetics. More...
class	PowerLawIsotropicHardeningStaticRecovery
class	PowerLawKinematicHardeningStaticRecovery
class	PowerLawSlipRule
	Power law slip rate of the form ${\dot{\gamma }}_i={\dot{\gamma }}_0{\left|\frac{{\tau }_i}{{\tau }_{h,i}}\right|}^{n-1}\frac{{\tau }_i}{{\tau }_{h,i}}$. More...
class	PrimitiveTensor
	PrimitiveTensor inherits from TensorBase and additionally templates on the base shape. More...
class	PrimitiveTensorFromTorchScript
class	ProductGeometry
class	ProjectileAcceleration
class	PyrolysisConversionAmount
	Calculate the pyrolysis conversion amount. More...
class	PyrolysisKinetics
	Define the governing pyrolysis kinetics models. More...
class	Quaternion
	A batched quaternion. More...
class	R2
	Second order tensor without symmetry. More...
class	R2Base
	Base class for second order tensor. More...
class	R2toSR2
	Get the symmetric part of a full rank two tensor. More...
class	R2toWR2
	Get the skew symmetric part of a full rank two tensor. More...
class	R3
	Third order tensor without symmetry. More...
class	R4
	Fourth order tensor without symmetry. More...
class	R5
	Fifth order tensor without symmetry. More...
class	R8
	The (logical) full eighth order tensor. More...
class	RateIndependentPlasticFlowConstraint
class	ReactionMechanism
	Define the mechanism reaction function. More...
class	Registry
class	ResolvedShear
	Calculate the resolved shears. More...
class	Rot
	Rotation stored as modified Rodrigues parameters. More...
class	RotationMatrix
	Convert a Rodrigues vector (Rot) to a second order tensor (R2). More...
class	Scalar
	Scalar. More...
class	ScalarVariableMultiplication
	Define the multiplication between arbitrary number of state variables. More...
class	SDTSolidMechanicsDriver
	Small deformation total solid mechanics driver. More...
class	Settings
class	SetupException
class	SFFR4
	The fourth order tensor with minor symmetry in the 1st and 2nd dimensions. More...
class	SFR3
	The third order tensor with symmetry in the first two dimensions. More...
class	SFR4
	The fourth order tensor with symmetry in the first two dimensions. More...
class	SimpleMPIScheduler
	A simple MPI scheduler. More...
class	SimpleScheduler
	A very simple scheduler. More...
class	SingleSlipHardeningRule
	Any slip rule where all systems share the same strength. More...
class	SingleSlipStrengthMap
	A map between the internal variables and the slip strength, for the case where all systems share the same strength. More...
class	SliceGenerator
class	SlipRule
	Parent class of slip rules, mapping from resolved shear and internal state to slip rates. More...
class	SlipStrengthMap
	Parent class of maps between internal variables and the slip system strengths. More...
class	SlopeSaturationVoceIsotropicHardening
class	SolidMechanicsDriver
	The transient driver specialized for solid mechanics problems. More...
class	Solver
	The solver solves a system of equations. More...
struct	SolvingNonlinearSystem
class	SR2
	The symmetric second order tensor. More...
class	SR2Invariant
class	SR2toR2
	Convert symmetric rank two tensor to full. More...
class	SSFR5
	The fifth order tensor with minor symmetry in the 1st and 2nd dimensions as well as in the 3rd and 4th dimensions. More...
class	SSR4
	The symmetric fourth order tensor, with symmetry in the first two dimensionss as well as in the last two dimensions. More...
class	SSSSR8
	The logical eigth order tensor with minor symmetry in the 1st and 2nd dimensions, the 3rd and 4th dimensions, the 5th and 6th dimensions, and the 7th and 8th dimensions. More...
class	StaticHybridScheduler
	A scheduler for multiple devices with static priority management. More...
class	SumSlipRates
	A helper model to calculate the sum of the absolute value of the slip rates. More...
class	SWR4
	The symmetric fourth order tensor, with symmetry in the first two dimensionss and skew-symmetry in the second two. More...
class	SymmetryFromOrbifold
	Provide the correct symmetry operators for a given crystal class. More...
class	Tensor
class	TensorBase
	NEML2's enhanced tensor type. More...
struct	TensorCache
class	TensorFromTorchScript
class	TensorLoader
struct	TensorName
	The name of a tensor object that can be referenced in the input files. More...
struct	TensorTypeEnum
class	TensorValue
	Concrete definition of tensor value. More...
class	TensorValueBase
	The base class to allow us to set up a polymorphic container of Tensors. The concrete definitions will be templated on the actual tensor type. More...
class	ThermalEigenstrain
struct	TimedSection
struct	TraceableSize
	Traceable size. More...
struct	TraceableTensorShape
	Traceable tensor shape. More...
class	Transformable
	Mixin class for things that can be transformed by a symmetry operator. More...
class	TransientDriver
	The driver for a transient initial-value problem. More...
class	TrustRegionSubProblem
class	TwoStageThermalAnnealing
class	UserPrimitiveTensor
	Create raw tensor of type T from the input file. More...
class	UserTensor
	Create raw Tensor from the input file. More...
class	UserTensorBase
class	ValueMapLoader
class	Variable
	Concrete definition of a variable. More...
class	VariableBase
	Base class of variable. More...
class	VariableRate
class	VariableStore
class	Vec
	3-vector. More...
class	VecBase
	Base class 3-vector. More...
class	VectorAssembler
	Helper to assemble a vector of tensors into a single tensor and also to split a tensor into a map of tensors. More...
class	VoceIsotropicHardening
class	VoceSingleSlipHardeningRule
	Voce slip hardening when all slip systems share the same hardening value, $\dot{\overline{\tau }}={\theta }_0(1-\frac{\overline{\tau }}{{\tau }_{sat}})\sum \left|{\dot{\gamma }}_i\right|$. More...
class	VolumeChangeEigenstrain
	Define the volume change eigenstrain. More...
class	WFR4
	The fourth order tensor with skew symmetry in the first two dimensions. More...
class	WorkDispatcher
	The work dispatcher who dispatches work to a worker and reduces the results. More...
class	WorkGenerator
class	WorkScheduler
	Scheduler for work dispatching. More...
class	WR2
	A skew-symmetric second order tensor, represented as an axial vector. More...
class	WR2ExplicitExponentialTimeIntegration
	Explicit exponential time integration for rotations. More...
class	WR2ImplicitExponentialTimeIntegration
	Implicit exponential time integration for rotations. More...
class	WSR4
	The symmetric fourth order tensor, with skew symmetry in the first two dimensionss and symmetry in the second two. More...
class	WWR4
	The symmetric fourth order tensor, with skew symmetry in the first two dimensions and last two dimensions. More...
class	YieldFunction
class	ZerosPrimitiveTensor
	Create a zeros PrimitiveTensor of type T from the input file. More...
class	ZerosTensor
	Create a zeros Tensor from the input file. More...

Typedefs
using	ScalarBackwardEulerTimeIntegration = BackwardEulerTimeIntegration<Scalar>
using	VecBackwardEulerTimeIntegration = BackwardEulerTimeIntegration<Vec>
using	SR2BackwardEulerTimeIntegration = BackwardEulerTimeIntegration<SR2>
using	ScalarForwardEulerTimeIntegration = ForwardEulerTimeIntegration<Scalar>
using	VecForwardEulerTimeIntegration = ForwardEulerTimeIntegration<Vec>
using	SR2ForwardEulerTimeIntegration = ForwardEulerTimeIntegration<SR2>
using	ScalarIncrementToRate = IncrementToRate<Scalar>
using	VecIncrementToRate = IncrementToRate<Vec>
using	SR2IncrementToRate = IncrementToRate<SR2>
using	R2IncrementToRate = IncrementToRate<R2>
using	ScalarLinearCombination = LinearCombination<Scalar>
using	VecLinearCombination = LinearCombination<Vec>
using	SR2LinearCombination = LinearCombination<SR2>
using	ScalarLinearInterpolation = LinearInterpolation<Scalar>
using	VecLinearInterpolation = LinearInterpolation<Vec>
using	SR2LinearInterpolation = LinearInterpolation<SR2>
using	SR2CrystalMean = CrystalMean<SR2>
using	ScalarTwoStageThermalAnnealing = TwoStageThermalAnnealing<Scalar>
using	SR2TwoStageThermalAnnealing = TwoStageThermalAnnealing<SR2>
using	ScalarVariableRate = VariableRate<Scalar>
using	VecVariableRate = VariableRate<Vec>
using	SR2VariableRate = VariableRate<SR2>
using	VariableName = LabeledAxisAccessor
using	SubaxisName = LabeledAxisAccessor
using	BuildPtr = std::shared_ptr<NEML2Object> (*)(const OptionSet & options)
using	ATensor = at::Tensor
template<typename T, unsigned N>
using	SmallVector = c10::SmallVector<T, N>
template<typename T>
using	ArrayRef = c10::ArrayRef<T>
using	TensorOptions = c10::TensorOptions
using	Dtype = c10::ScalarType
using	DeviceIndex = c10::DeviceIndex
using	Device = c10::Device
using	Real = double
using	Size = int64_t
using	Integer = int64_t
using	TensorShape = c10::SmallVector<Size, 8>
using	TensorShapeRef = c10::ArrayRef<Size>
using	ValueMap = std::map<LabeledAxisAccessor, Tensor>
using	DerivMap = std::map<LabeledAxisAccessor, ValueMap>
using	SecDerivMap = std::map<LabeledAxisAccessor, DerivMap>
using	TensorDataContainer = torch::detail::TensorDataContainer

Enumerations
enum class	FType : int8_t {   NONE = 0 , INPUT = 1 << 0 , OUTPUT = 1 << 1 , PARAMETER = 1 << 2 ,   BUFFER = 1 << 3 }
	Role in a function definition. More...
enum class	ElasticConstant : std::uint8_t {   INVALID = 0 , LAME_LAMBDA = 1 , BULK_MODULUS = 2 , SHEAR_MODULUS = 3 ,   YOUNGS_MODULUS = 4 , POISSONS_RATIO = 5 , P_WAVE_MODULUS = 6 , CUBIC_C1 = 7 ,   CUBIC_C2 = 8 , CUBIC_C3 = 9 }
enum class	TensorType : int8_t { FOR_ALL_TENSORBASE_COMMA =(_tensor_type_enum) , kUknown }

Functions
DiagnosticState &	current_diagnostic_state ()
	Get the current diagnostic state.
std::vector< Diagnosis > &	current_diagnoses ()
	Get the current diagnoses.
std::vector< Diagnosis >	diagnose (const DiagnosticsInterface &)
	A helper function to diagnose common setup errors.
std::ostream &	operator<< (std::ostream &os, const EnumSelection &es)
std::stringstream &	operator>> (std::stringstream &ss, EnumSelection &es)
void	load_input (const std::filesystem::path &path, const std::string &additional_input="")
	A convenient function to parse all options from an input file.
void	reload_input (const std::filesystem::path &path, const std::string &additional_input="")
	Similar to neml2::load_input, but additionally clear the Factory before loading the options, therefore all previously loaded models become dangling.
std::map< std::string, std::map< std::string, unsigned long > > &	timed_sections ()
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_ADD_VARIABLE)
std::ostream &	operator<< (std::ostream &os, const LabeledAxis &axis)
bool	operator== (const LabeledAxis &a, const LabeledAxis &b)
bool	operator!= (const LabeledAxis &a, const LabeledAxis &b)
std::vector< std::string >	reserved_subaxis_names ()
	LabeledAxisAccessor::operator std::vector< std::string > () const
bool	operator!= (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
	Compare for equality between two LabeledAxisAccessor.
bool	operator== (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
	Compare for equality between two LabeledAxisAccessor.
bool	operator< (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
	The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.
std::ostream &	operator<< (std::ostream &os, const LabeledAxisAccessor &accessor)
	Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".
std::ostream &	operator<< (std::ostream &os, const MultiEnumSelection &es)
std::stringstream &	operator>> (std::stringstream &ss, MultiEnumSelection &es)
	FOR_ALL_TENSORBASE (INSTANTIATE_TENSORNAME)
std::ostream &	operator<< (std::ostream &os, const OptionBase &opt)
std::ostream &	operator<< (std::ostream &os, const OptionCollection &p)
bool	options_compatible (const OptionSet &opts, const OptionSet &additional_opts)
std::ostream &	operator<< (std::ostream &os, const OptionSet &p)
	FOR_ALL_TENSORBASE (INSTANTIATE)
DerivMap	derivmap_cat_reduce (std::vector< DerivMap > &&results, Size batch_dim)
	Concatenate the tensors in the DerivMap along the batch dimension.
DerivMap	derivmap_move_device (DerivMap &&x, Device device)
	Move all tensors in a DerivMap to a device.
DerivMap	derivmap_no_operation (DerivMap &&x)
	No operation.
	register_NEML2_object (SimpleMPIScheduler)
	register_NEML2_object (SimpleScheduler)
	register_NEML2_object (StaticHybridScheduler)
ValueMap	valuemap_cat_reduce (std::vector< ValueMap > &&results, Size batch_dim)
	Concatenate the tensors in the ValueMap along the batch dimension.
ValueMap	valuemap_move_device (ValueMap &&x, Device device)
	Move all tensors in a ValueMap to a device.
ValueMap	valuemap_no_operation (ValueMap &&x)
	No operation.
std::size_t	broadcast_batch_size (const ValueMap &value_map, Size batch_dim)
Driver &	get_driver (const std::string &dname)
	A convenient function to manufacture a neml2::Driver.
	register_NEML2_object (LDISolidMechanicsDriver)
	register_NEML2_object (SDTSolidMechanicsDriver)
	register_NEML2_object (TransientDriver)
template<typename T>
void	set_ic (ValueMap &storage, const OptionSet &options, const std::string &name_opt, const std::string &value_opt, const Device &device)
template<typename T>
void	get_force (std::vector< VariableName > &names, std::vector< Tensor > &values, const OptionSet &options, const std::string &name_opt, const std::string &value_opt, const Device &device)
std::ostream &	operator<< (std::ostream &os, const TraceableSize &s)
	Streaming operator.
void	neml_assert_tracing ()
	Assert that we are currently tracing.
void	neml_assert_not_tracing ()
	Assert that we are currently NOT tracing.
void	neml_assert_tracing_dbg ()
	Assert that we are currently tracing (only effective in debug mode)
void	neml_assert_not_tracing_dbg ()
	Assert that we are currently NOT tracing (only effective in debug mode)
bool &	require_double_precision ()
	Require double precision for all computations.
std::ostream &	operator<< (std::ostream &os, FType f)
	register_NEML2_object (ArrheniusParameter)
	register_NEML2_object (ScalarBackwardEulerTimeIntegration)
	register_NEML2_object (VecBackwardEulerTimeIntegration)
	register_NEML2_object (SR2BackwardEulerTimeIntegration)
	FOR_ALL_TENSORBASE (BUFFERSTORE_INTANTIATE_TENSORBASE)
	register_NEML2_object (ComposedModel)
	FOR_ALL_PRIMITIVETENSOR (REGISTER_CONSTANTPARAMETER)
	FOR_ALL_PRIMITIVETENSOR (REGISTER_COPYVARIABLE)
	register_NEML2_object (FischerBurmeister)
	register_NEML2_object (ScalarForwardEulerTimeIntegration)
	register_NEML2_object (VecForwardEulerTimeIntegration)
	register_NEML2_object (SR2ForwardEulerTimeIntegration)
	register_NEML2_object (HermiteSmoothStep)
	register_NEML2_object (ImplicitUpdate)
	register_NEML2_object (ScalarIncrementToRate)
	register_NEML2_object (VecIncrementToRate)
	register_NEML2_object (SR2IncrementToRate)
	register_NEML2_object (R2IncrementToRate)
	FOR_ALL_PRIMITIVETENSOR (REGISTER)
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE)
	register_NEML2_object (ScalarLinearCombination)
	register_NEML2_object (VecLinearCombination)
	register_NEML2_object (SR2LinearCombination)
	register_NEML2_object (ScalarLinearInterpolation)
	register_NEML2_object (VecLinearInterpolation)
	register_NEML2_object (SR2LinearInterpolation)
Model &	get_model (const std::string &mname)
	A convenient function to manufacture a neml2::Model.
Model &	load_model (const std::filesystem::path &path, const std::string &mname)
	A convenient function to load an input file and get a model.
Model &	reload_model (const std::filesystem::path &path, const std::string &mname)
	Similar to neml2::load_model, but additionally clear the Factory before loading the model, therefore all previously loaded models become dangling.
void	check_precision ()
	Check the current default precision and warn if it's not double precision.
std::ostream &	operator<< (std::ostream &os, const Model &model)
template<typename T>
const T &	resolve_tensor_name (const TensorName< T > &tn, Model *caller, const std::string &pname)
	FOR_ALL_TENSORBASE (PARAMETERSTORE_INTANTIATE_TENSORBASE)
	FOR_ALL_PRIMITIVETENSOR (PARAMETERSTORE_INTANTIATE_PRIMITIVETENSOR)
	register_NEML2_object (AvramiErofeevNucleation)
	register_NEML2_object (ChemicalReactionMechanism)
	register_NEML2_object (PyrolysisConversionAmount)
	register_NEML2_object (PyrolysisKinetics)
	register_NEML2_object (R2toSR2)
	register_NEML2_object (R2toWR2)
	register_NEML2_object (DiffusionLimitedReaction)
	register_NEML2_object (ProductGeometry)
	register_NEML2_object (RotationMatrix)
	register_NEML2_object (ScalarVariableMultiplication)
	register_NEML2_object (AssociativeIsotropicPlasticHardening)
	register_NEML2_object (AssociativeJ2FlowDirection)
	register_NEML2_object (AssociativeKinematicPlasticHardening)
	register_NEML2_object (AssociativePlasticFlow)
	register_NEML2_object (ChabochePlasticHardening)
	register_NEML2_object (SR2CrystalMean)
	register_NEML2_object (ElasticStrainRate)
SR2	skew_and_sym_to_sym (const SR2 &e, const WR2 &w)
SSR4	d_skew_and_sym_to_sym_d_sym (const WR2 &w)
SWR4	d_skew_and_sym_to_sym_d_skew (const SR2 &e)
	register_NEML2_object (FixOrientation)
	register_NEML2_object (LinearSingleSlipHardeningRule)
	register_NEML2_object (OrientationRate)
WR2	multiply_and_make_skew (const SR2 &a, const SR2 &b)
WSR4	d_multiply_and_make_skew_d_first (const SR2 &b)
WSR4	d_multiply_and_make_skew_d_second (const SR2 &a)
	register_NEML2_object (PlasticDeformationRate)
	register_NEML2_object (PlasticVorticity)
	register_NEML2_object (PowerLawSlipRule)
	register_NEML2_object (ResolvedShear)
	register_NEML2_object (SingleSlipStrengthMap)
	register_NEML2_object (SumSlipRates)
	register_NEML2_object (VoceSingleSlipHardeningRule)
	register_NEML2_object (CubicElasticityTensor)
std::string	name (ElasticConstant p)
	register_NEML2_object (GeneralElasticity)
	register_NEML2_object (IsotropicElasticityTensor)
	register_NEML2_object (LinearIsotropicElasticity)
	register_NEML2_object (FredrickArmstrongPlasticHardening)
	register_NEML2_object (GTNYieldFunction)
	register_NEML2_object (GursonCavitation)
	register_NEML2_object (IsotropicMandelStress)
	register_NEML2_object (KocksMeckingActivationEnergy)
	register_NEML2_object (KocksMeckingFlowSwitch)
	register_NEML2_object (KocksMeckingFlowViscosity)
	register_NEML2_object (KocksMeckingIntercept)
	register_NEML2_object (KocksMeckingRateSensitivity)
	register_NEML2_object (KocksMeckingYieldStress)
	register_NEML2_object (LinearIsotropicElasticJ2TrialStressUpdate)
	register_NEML2_object (LinearIsotropicHardening)
	register_NEML2_object (LinearKinematicHardening)
	register_NEML2_object (MixedControlSetup)
	register_NEML2_object (Normality)
	register_NEML2_object (OlevskySinteringStress)
	register_NEML2_object (PerzynaPlasticFlowRate)
	register_NEML2_object (PhaseTransformationEigenstrain)
	register_NEML2_object (PowerLawIsotropicHardeningStaticRecovery)
	register_NEML2_object (PowerLawKinematicHardeningStaticRecovery)
	register_NEML2_object (RateIndependentPlasticFlowConstraint)
	register_NEML2_object (SlopeSaturationVoceIsotropicHardening)
	register_NEML2_object (ThermalEigenstrain)
	register_NEML2_object (ScalarTwoStageThermalAnnealing)
	register_NEML2_object (SR2TwoStageThermalAnnealing)
	register_NEML2_object (VoceIsotropicHardening)
	register_NEML2_object (VolumeChangeEigenstrain)
	register_NEML2_object (YieldFunction)
	register_NEML2_object (SR2Invariant)
	register_NEML2_object (SR2toR2)
void	assign_or_add (Tensor &dest, const Tensor &val)
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_VARIABLE)
	register_NEML2_object (ScalarVariableRate)
	register_NEML2_object (VecVariableRate)
	register_NEML2_object (SR2VariableRate)
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_DECLARE_INPUT_VARIABLE)
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_DECLARE_OUTPUT_VARIABLE)
	FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_CREATE_VARIABLE)
	register_NEML2_object (WR2ExplicitExponentialTimeIntegration)
	register_NEML2_object (WR2ImplicitExponentialTimeIntegration)
	register_NEML2_object (Newton)
	register_NEML2_object (NewtonWithLineSearch)
	register_NEML2_object (NewtonWithTrustRegion)
bool &	currently_solving_nonlinear_system ()
	FOR_ALL_TENSORBASE (DEFINE_ABS)
	FOR_ALL_TENSORBASE (DEFINE_ARCCOS)
	FOR_ALL_TENSORBASE (DEFINE_ARCSIN)
	FOR_ALL_TENSORBASE (DEFINE_ARCTAN)
Tensor	bmm (const Tensor &a, const Tensor &b)
	Batched matrix-matrix product.
Tensor	bmv (const Tensor &a, const Tensor &v)
	Batched matrix-vector product.
Scalar	bvv (const Tensor &a, const Tensor &b)
	Batched vector-vector (dot) product.
	FOR_ALL_TENSORBASE (DEFINE_CAT)
Tensor	base_cat (const std::vector< Tensor > &tensors, Size d)
	FOR_ALL_TENSORBASE (DEFINE_CBRT)
	FOR_ALL_TENSORBASE (DEFINE_CLAMP)
	FOR_ALL_TENSORBASE (DEFINE_COS)
	FOR_ALL_TENSORBASE (DEFINE_COSH)
	FOR_ALL_TENSORBASE (DEFINE_DEG2RAD)
	FOR_ALL_TENSORBASE (DEFINE_BATCH_DIAG_EMDED)
Tensor	base_diag_embed (const Tensor &a, Size offset, Size d1, Size d2)
	FOR_ALL_TENSORBASE (DEFINE_DIFF)
	FOR_ALL_TENSORBASE (DEFINE_EXP)
	FOR_ALL_TENSORBASE (DEFINE_FMOD)
	FOR_ALL_TENSORBASE (DEFINE_GCD)
	FOR_ALL_TENSORBASE (DEFINE_HEAVISIDE)
std::vector< Tensor >	jacrev (const Tensor &y, const std::vector< Tensor > &xs, bool retain_graph=false, bool create_graph=false, bool allow_unused=false)
	Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.
Tensor	jacrev (const Tensor &y, const Tensor &x, bool retain_graph=false, bool create_graph=false, bool allow_unused=false)
	Similar to the other jacrev, but for a single input.
	FOR_ALL_TENSORBASE (DEFINE_LOG)
	FOR_ALL_TENSORBASE (DEFINE_LOG10)
	FOR_ALL_TENSORBASE (DEFINE_MACAULAY)
	FOR_ALL_TENSORBASE (DEFINE_BATCH_MEAN)
Tensor	base_mean (const Tensor &a, Size d)
	FOR_ALL_TENSORBASE (DEFINE_MINIMUM)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SELF)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SYM_REAL)
Tensor	operator+ (const Tensor &a, const Tensor &b)
Tensor	operator+ (const Tensor &a, const Scalar &b)
Tensor	operator+ (const Scalar &a, const Tensor &b)
Tensor	operator+ (const Tensor &a, const Real &b)
Tensor	operator+ (const Real &a, const Tensor &b)
Scalar	operator+ (const Scalar &a, const Scalar &b)
Scalar	operator+ (const Scalar &a, const Real &b)
Scalar	operator+ (const Real &a, const Scalar &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SELF)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SYM_REAL)
Tensor	operator- (const Tensor &a, const Tensor &b)
Tensor	operator- (const Tensor &a, const Scalar &b)
Tensor	operator- (const Scalar &a, const Tensor &b)
Tensor	operator- (const Tensor &a, const Real &b)
Tensor	operator- (const Real &a, const Tensor &b)
Scalar	operator- (const Scalar &a, const Scalar &b)
Scalar	operator- (const Scalar &a, const Real &b)
Scalar	operator- (const Real &a, const Scalar &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_SYM_REAL)
Tensor	operator* (const Tensor &a, const Tensor &b)
Tensor	operator* (const Tensor &a, const Scalar &b)
Tensor	operator* (const Scalar &a, const Tensor &b)
Tensor	operator* (const Tensor &a, const Real &b)
Tensor	operator* (const Real &a, const Tensor &b)
Scalar	operator* (const Scalar &a, const Scalar &b)
Scalar	operator* (const Scalar &a, const Real &b)
Scalar	operator* (const Real &a, const Scalar &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_SYM_REAL)
Tensor	operator/ (const Tensor &a, const Tensor &b)
Tensor	operator/ (const Tensor &a, const Scalar &b)
Tensor	operator/ (const Scalar &a, const Tensor &b)
Tensor	operator/ (const Tensor &a, const Real &b)
Tensor	operator/ (const Real &a, const Tensor &b)
Scalar	operator/ (const Scalar &a, const Scalar &b)
Scalar	operator/ (const Scalar &a, const Real &b)
Scalar	operator/ (const Real &a, const Scalar &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_EQ)
Tensor &	operator+= (Tensor &a, const Real &b)
Scalar &	operator+= (Scalar &a, const Real &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_EQ)
Tensor &	operator-= (Tensor &a, const Real &b)
Scalar &	operator-= (Scalar &a, const Real &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_EQ)
Tensor &	operator*= (Tensor &a, const Real &b)
Scalar &	operator*= (Scalar &a, const Real &b)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_EQ)
Tensor &	operator/= (Tensor &a, const Real &b)
Scalar &	operator/= (Scalar &a, const Real &b)
	FOR_ALL_NONSCALAR_TENSORBASE (DEFINE_POW)
Scalar	pow (const Scalar &a, const Real &n)
Scalar	pow (const Scalar &a, const Scalar &n)
Scalar	pow (const Real &a, const Scalar &n)
Tensor	pow (const Tensor &a, const Tensor &n)
	Element-wise pow.
Tensor	pow (const Real &a, const Tensor &n)
	Element-wise pow.
	FOR_ALL_TENSORBASE (DEFINE_SIGN)
	FOR_ALL_TENSORBASE (DEFINE_SIN)
	FOR_ALL_TENSORBASE (DEFINE_SINH)
	FOR_ALL_TENSORBASE (DEFINE_SQRT)
	FOR_ALL_TENSORBASE (DEFINE_BATCH_STACK)
Tensor	base_stack (const std::vector< Tensor > &tensors, Size d)
	FOR_ALL_TENSORBASE (DEFINE_BATCH_SUM)
Tensor	base_sum (const Tensor &a, Size d)
	FOR_ALL_TENSORBASE (DEFINE_TAN)
	FOR_ALL_TENSORBASE (DEFINE_TANH)
	FOR_ALL_TENSORBASE (DEFINE_WHERE)
const Tensor &	full_to_mandel_map (const TensorOptions &opt)
const Tensor &	mandel_to_full_map (const TensorOptions &opt)
const Tensor &	full_to_mandel_factor (const TensorOptions &opt)
const Tensor &	mandel_to_full_factor (const TensorOptions &opt)
const Tensor &	full_to_skew_map (const TensorOptions &opt)
const Tensor &	skew_to_full_map (const TensorOptions &opt)
const Tensor &	full_to_skew_factor (const TensorOptions &opt)
const Tensor &	skew_to_full_factor (const TensorOptions &opt)
Tensor	full_to_reduced (const Tensor &full, const Tensor &rmap, const Tensor &rfactors, Size dim=0)
	Generic function to reduce two axes to one with some map.
Tensor	reduced_to_full (const Tensor &reduced, const Tensor &rmap, const Tensor &rfactors, Size dim=0)
	Convert a Tensor from reduced notation to full notation.
Tensor	full_to_mandel (const Tensor &full, Size dim=0)
	Convert a Tensor from full notation to Mandel notation.
Tensor	mandel_to_full (const Tensor &mandel, Size dim=0)
	Convert a Tensor from Mandel notation to full notation.
Tensor	full_to_skew (const Tensor &full, Size dim=0)
	Convert a Tensor from full notation to skew vector notation.
Tensor	skew_to_full (const Tensor &skew, Size dim=0)
	Convert a Tensor from skew vector notation to full notation.
template<class Derived1, class Derived2, typename, typename>
Vec	operator* (const Derived1 &A, const Derived2 &b)
	matrix-vector product
template<class Derived1, class Derived2, typename, typename>
R2	operator* (const Derived1 &A, const Derived2 &B)
	matrix-matrix product
template Vec	operator* (const R2 &A, const Vec &b)
template R2	operator* (const R2 &A, const R2 &B)
Rot	operator* (const Rot &r1, const Rot &r2)
	Composition of rotations r3 = r1 * r2 (r2 first, then r1)
SR2	operator* (const SSR4 &a, const SR2 &b)
SR2	operator* (const SR2 &a, const SSR4 &b)
SSR4	operator* (const SSR4 &a, const SSR4 &b)
	FOR_ALL_TENSORBASE (INSTANTIATE_TENSORBASE)
std::ostream &	operator<< (std::ostream &os, const TensorType &t)
	FOR_ALL_TENSORBASE (INSTANTIATE_TENSORVALUE)
R2	transform_from_quaternion (const Quaternion &q)
	Construct from quaternions, useful for comparison to old NEML.
R2	identity_transform (const TensorOptions &options=default_tensor_options())
	The identity transformation, i.e.e the Rank2 identity tensor.
R2	proper_rotation_transform (const Rot &rot)
	A proper rotation, here provided by a Rot object.
R2	improper_rotation_transform (const Rot &rot)
	An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.
R2	reflection_transform (const Vec &v)
	A reflection, defined by the reflection plane.
R2	inversion_transform (const TensorOptions &options=default_tensor_options())
	An inversion center.
	FOR_ALL_VECBASE (VECBASE_INSTANTIATE)
	FOR_ALL_PRIMITIVETENSOR (EMPTYPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (EmptyTensor)
	register_NEML2_object (FillMillerIndex)
	register_NEML2_object (FillR2)
	register_NEML2_object (FillRot)
	register_NEML2_object (FillSR2)
	register_NEML2_object (FillWR2)
	FOR_ALL_PRIMITIVETENSOR (FULLPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (FullTensor)
	register_NEML2_object (IdentityTensor)
	FOR_ALL_PRIMITIVETENSOR (LINSPACEPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (LinspaceTensor)
	FOR_ALL_PRIMITIVETENSOR (LOGSPACEPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (LogspaceTensor)
	FOR_ALL_PRIMITIVETENSOR (ONESPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (OnesTensor)
	register_NEML2_object (Orientation)
	FOR_ALL_PRIMITIVETENSOR (REGISTER_PRIMITIVETENSORFROMTORCHSCRIPT)
	register_NEML2_object (SymmetryFromOrbifold)
	register_NEML2_object (TensorFromTorchScript)
	FOR_ALL_PRIMITIVETENSOR (USERPRIMITIVETENSOR_REGISTER)
	register_NEML2_object_alias (UserTensor, "Tensor")
	FOR_ALL_PRIMITIVETENSOR (ZEROSPRIMITIVETENSOR_REGISTER)
	register_NEML2_object (ZerosTensor)
template<typename... Args>
void	diagnostic_assert (bool, Args &&...)
	Helper assertion function for diagnostics.
template<typename... Args>
void	diagnostic_assert (bool assertion, Args &&... args)
template<typename T>
std::stringstream &	operator>> (std::stringstream &ss, TensorName< T > &t)
	Stream into a TensorName (used by Parsers to extract input options)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const TensorName< T > &t)
	Stream out a TensorName (used for printing OptionSet)
template<typename... Args>
void	neml_assert (bool assertion, Args &&... args)
template<typename... Args>
void	neml_assert_dbg (bool assertion, Args &&... args)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto	operator+ (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto	operator- (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto	operator* (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto	operator/ (const T1 &a, const T2 &b)
template<class... T>
void	neml_assert_broadcastable (const T &...)
	A helper function to assert that all tensors are broadcastable.
template<class... T>
void	neml_assert_broadcastable_dbg (const T &...)
	A helper function to assert (in Debug mode) that all tensors are broadcastable.
template<class... T>
void	neml_assert_batch_broadcastable (const T &...)
	A helper function to assert that all tensors are batch-broadcastable.
template<class... T>
void	neml_assert_batch_broadcastable_dbg (const T &...)
	A helper function to assert that (in Debug mode) all tensors are batch-broadcastable.
template<class... T>
void	neml_assert_base_broadcastable (const T &...)
	A helper function to assert that all tensors are base-broadcastable.
template<class... T>
void	neml_assert_base_broadcastable_dbg (const T &...)
	A helper function to assert that (in Debug mode) all tensors are base-broadcastable.
template<class... T>
void	neml_assert_broadcastable (const T &... tensors)
template<class... T>
void	neml_assert_broadcastable_dbg (const T &... tensors)
template<class... T>
void	neml_assert_batch_broadcastable (const T &... tensors)
template<class... T>
void	neml_assert_batch_broadcastable_dbg (const T &... tensors)
template<class... T>
void	neml_assert_base_broadcastable (const T &... tensors)
template<class... T>
void	neml_assert_base_broadcastable_dbg (const T &... tensors)
	FOR_ALL_TENSORBASE (DECLARE_ABS)
	FOR_ALL_TENSORBASE (DECLARE_ACOS)
	FOR_ALL_TENSORBASE (DECLARE_ASIN)
	FOR_ALL_TENSORBASE (DECLARE_ATAN)
	FOR_ALL_TENSORBASE (DECLARE_BATCH_CAT)
	FOR_ALL_TENSORBASE (DECLARE_CBRT)
	FOR_ALL_TENSORBASE (DECLARE_CLAMP)
	FOR_ALL_TENSORBASE (DECLARE_COS)
	FOR_ALL_TENSORBASE (DECLARE_COSH)
	FOR_ALL_TENSORBASE (DECLARE_DEG2RAD)
	FOR_ALL_TENSORBASE (DECLARE_BATCH_DIAG_EMBED)
	FOR_ALL_TENSORBASE (DECLARE_DIFF)
	FOR_ALL_TENSORBASE (DECLARE_EXP)
	FOR_ALL_TENSORBASE (DECLARE_FMOD)
	FOR_ALL_TENSORBASE (DECLARE_GCD)
	FOR_ALL_TENSORBASE (DECLARE_HEAVISIDE)
	FOR_ALL_TENSORBASE (DECLARE_LOG)
	FOR_ALL_TENSORBASE (DECLARE_LOG10)
	FOR_ALL_TENSORBASE (DECLARE_MACAULAY)
	FOR_ALL_TENSORBASE (DECLARE_BATCH_MEAN)
	FOR_ALL_TENSORBASE (DECLARE_MINIMUM)
	FOR_ALL_TENSORBASE (FORWARD_DECLARATION)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SELF)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SYM_REAL)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SELF)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SYM_REAL)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_SYM_REAL)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_SYM_SCALAR)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_SYM_REAL)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_EQ)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_EQ)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_EQ)
	FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_EQ)
	FOR_ALL_TENSORBASE (DECLARE_POW)
	FOR_ALL_TENSORBASE (DECLARE_SIGN)
	FOR_ALL_TENSORBASE (DECLARE_SIN)
	FOR_ALL_TENSORBASE (DECLARE_SINH)
	FOR_ALL_TENSORBASE (DECLARE_SQRT)
	FOR_ALL_TENSORBASE (DECLARE_BATCH_STACK)
	FOR_ALL_TENSORBASE (DECLARE_BATCH_SUM)
	FOR_ALL_TENSORBASE (DECLARE_TAN)
	FOR_ALL_TENSORBASE (DECLARE_TANH)
	FOR_ALL_TENSORBASE (DECLARE_WHERE)
template<typename F, typename T1, typename T2>
Tensor	list_derivative_outer_product_a (F &&f, const T1 &a, const T2 &b)
	outer product on lists, where the first input is a list tensor
template<typename F, typename T1, typename T2>
Tensor	list_derivative_outer_product_b (F &&f, const T1 &a, const T2 &b)
	outer product on lists, where the second input is a list tensor
template<typename F, typename T1, typename T2>
Tensor	list_derivative_outer_product_ab (F &&f, const T1 &a, const T2 &b)
	outer product on lists where both inputs are list tensors
constexpr Real	mandel_factor (Size i)
	FOR_ALL_TENSORBASE (SPECIALIZE_TENSORTYPEENUM)
	FOR_ALL_TENSORBASE (DECLARE_TENSOR)
	register_NEML2_object (ProjectileAcceleration)
bool	operator== (const TraceableSize &lhs, const TraceableSize &rhs)
bool	operator!= (const TraceableSize &lhs, const TraceableSize &rhs)
bool	operator== (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs)
bool	operator!= (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs)
RAII style default tensor options
The factory methods like at::arange, at::ones, at::zeros, at::rand etc. accept a common argument to configure the properties of the tensor being created. We predefine a default tensor configuration in NEML2. This default configuration is consistently used throughout NEML2. See https://pytorch.org/cppdocs/notes/tensor_creation.html#configuring-properties-of-the-tensor for more details.
void	set_default_dtype (Dtype dtype)
Dtype	get_default_dtype ()
	Get default dtype.
TensorOptions	default_tensor_options ()
	Default floating point tensor options.
TensorOptions	default_integer_tensor_options ()
	Default integral tensor options.
Dtype &	default_integer_dtype ()
	Default integral type.
Default tolerances
Real &	machine_precision ()
Real &	tolerance ()
	The tolerance used in various algorithms.
Real &	tighter_tolerance ()
	A tighter tolerance used in various algorithms.
Default name separators
std::string &	buffer_name_separator ()
std::string &	parameter_name_separator ()
	Default nested parameter name separator.

Variables
const std::string	STATE = "state"
const std::string	OLD_STATE = "old_state"
const std::string	FORCES = "forces"
const std::string	OLD_FORCES = "old_forces"
const std::string	RESIDUAL = "residual"
const std::string	PARAMETERS = "parameters"
constexpr auto	kInt8 = c10::kChar
	Fixed width dtypes (mirroring the definition in <torch/csrc/api/include/torch/types.h>)
constexpr auto	kInt16 = c10::kShort
constexpr auto	kInt32 = c10::kInt
constexpr auto	kInt64 = c10::kLong
constexpr auto	kFloat16 = c10::kHalf
constexpr auto	kFloat32 = c10::kFloat
constexpr auto	kFloat64 = c10::kDouble
constexpr auto	kCPU = c10::DeviceType::CPU
constexpr auto	kCUDA = c10::DeviceType::CUDA
constexpr std::array< std::array< Size, 3 >, 3 >	mandel_reverse_index
constexpr std::array< std::array< Size, 2 >, 6 >	mandel_index
constexpr std::array< std::array< Size, 3 >, 3 >	skew_reverse_index
constexpr std::array< std::array< Real, 3 >, 3 >	skew_factor
constexpr auto	eps = std::numeric_limits<Real>::epsilon()
	Constants.
constexpr Real	sqrt2 = 1.4142135623730951
constexpr Real	invsqrt2 = 0.7071067811865475

Detailed Description

This file contains implementation details of the TensorBase class. Refer to TensorBase.h for the class definition.

Typedef Documentation

ArrayRef

template<typename T>

using ArrayRef = c10::ArrayRef<T>

ATensor

using ATensor = at::Tensor

BuildPtr

using BuildPtr = std::shared_ptr<NEML2Object> (*)(const OptionSet & options)

DerivMap

using DerivMap = std::map<LabeledAxisAccessor, ValueMap>

Device

using Device = c10::Device

DeviceIndex

using DeviceIndex = c10::DeviceIndex

Dtype

using Dtype = c10::ScalarType

Integer

using Integer = int64_t

R2IncrementToRate

using R2IncrementToRate = IncrementToRate<R2>

Real

using Real = double

ScalarBackwardEulerTimeIntegration

typedef BackwardEulerTimeIntegration< Scalar > ScalarBackwardEulerTimeIntegration = BackwardEulerTimeIntegration<Scalar>

ScalarForwardEulerTimeIntegration

using ScalarForwardEulerTimeIntegration = ForwardEulerTimeIntegration<Scalar>

ScalarIncrementToRate

using ScalarIncrementToRate = IncrementToRate<Scalar>

ScalarLinearCombination

using ScalarLinearCombination = LinearCombination<Scalar>

ScalarLinearInterpolation

using ScalarLinearInterpolation = LinearInterpolation<Scalar>

ScalarTwoStageThermalAnnealing

using ScalarTwoStageThermalAnnealing = TwoStageThermalAnnealing<Scalar>

ScalarVariableRate

using ScalarVariableRate = VariableRate<Scalar>

SecDerivMap

using SecDerivMap = std::map<LabeledAxisAccessor, DerivMap>

Size

using Size = int64_t

SmallVector

template<typename T, unsigned N>

using SmallVector = c10::SmallVector<T, N>

SR2BackwardEulerTimeIntegration

typedef BackwardEulerTimeIntegration< SR2 > SR2BackwardEulerTimeIntegration = BackwardEulerTimeIntegration<SR2>

SR2CrystalMean

using SR2CrystalMean = CrystalMean<SR2>

SR2ForwardEulerTimeIntegration

using SR2ForwardEulerTimeIntegration = ForwardEulerTimeIntegration<SR2>

SR2IncrementToRate

using SR2IncrementToRate = IncrementToRate<SR2>

SR2LinearCombination

using SR2LinearCombination = LinearCombination<SR2>

SR2LinearInterpolation

using SR2LinearInterpolation = LinearInterpolation<SR2>

SR2TwoStageThermalAnnealing

using SR2TwoStageThermalAnnealing = TwoStageThermalAnnealing<SR2>

SR2VariableRate

using SR2VariableRate = VariableRate<SR2>

SubaxisName

using SubaxisName = LabeledAxisAccessor

TensorDataContainer

using TensorDataContainer = torch::detail::TensorDataContainer

TensorOptions

using TensorOptions = c10::TensorOptions

TensorShape

using TensorShape = c10::SmallVector<Size, 8>

TensorShapeRef

using TensorShapeRef = c10::ArrayRef<Size>

ValueMap

using ValueMap = std::map<LabeledAxisAccessor, Tensor>

VariableName

using VariableName = LabeledAxisAccessor

VecBackwardEulerTimeIntegration

typedef BackwardEulerTimeIntegration< Vec > VecBackwardEulerTimeIntegration = BackwardEulerTimeIntegration<Vec>

VecForwardEulerTimeIntegration

using VecForwardEulerTimeIntegration = ForwardEulerTimeIntegration<Vec>

VecIncrementToRate

using VecIncrementToRate = IncrementToRate<Vec>

VecLinearCombination

using VecLinearCombination = LinearCombination<Vec>

VecLinearInterpolation

using VecLinearInterpolation = LinearInterpolation<Vec>

VecVariableRate

using VecVariableRate = VariableRate<Vec>

Enumeration Type Documentation

ElasticConstant

enum class ElasticConstant : std::uint8_t

strong

Enumerator
INVALID
LAME_LAMBDA
BULK_MODULUS
SHEAR_MODULUS
YOUNGS_MODULUS
POISSONS_RATIO
P_WAVE_MODULUS
CUBIC_C1
CUBIC_C2
CUBIC_C3

FType

enum class FType : int8_t

strong

Role in a function definition.

NONE is the default value, INPUT stands for input variable, OUTPUT stands for output variable, PARAMETER stands for parameter (could request AD), BUFFER stands for buffer.

Enumerator
NONE
INPUT
OUTPUT
PARAMETER
BUFFER

TensorType

enum class TensorType : int8_t

strong

Enumerator
FOR_ALL_TENSORBASE_COMMA
kUknown

Function Documentation

assign_or_add()

void assign_or_add	(	Tensor &	dest,
		const Tensor &	val )

base_cat()

Tensor base_cat	(	const std::vector< Tensor > &	tensors,
		Size	d )

base_diag_embed()

Tensor base_diag_embed	(	const Tensor &	a,
		Size	offset,
		Size	d1,
		Size	d2 )

base_mean()

Tensor base_mean	(	const Tensor &	a,
		Size	d )

base_stack()

neml2::Tensor base_stack	(	const std::vector< Tensor > &	tensors,
		Size	d )

base_sum()

Tensor base_sum	(	const Tensor &	a,
		Size	d )

bmm()

Tensor bmm	(	const Tensor &	a,
		const Tensor &	b )

Batched matrix-matrix product.

The input matrices a and b must have exactly 2 base dimensions. The batch shapes must broadcast.

bmv()

Tensor bmv	(	const Tensor &	a,
		const Tensor &	v )

Batched matrix-vector product.

The input tensor a must have exactly 2 base dimensions. The input tensor v must have exactly 1 base dimension. The batch shapes must broadcast.

broadcast_batch_size()

std::size_t broadcast_batch_size	(	const ValueMap &	value_map,
		Size	batch_dim )

buffer_name_separator()

std::string & buffer_name_separator

(

)

Default nested buffer name separator

bvv()

Scalar bvv	(	const Tensor &	a,
		const Tensor &	b )

Batched vector-vector (dot) product.

The input tensor a must have exactly 1 base dimension. The input tensor b must have exactly 1 base dimension. The batch shapes must broadcast.

check_precision()

void check_precision

(

)

Check the current default precision and warn if it's not double precision.

current_diagnoses()

std::vector< Diagnosis > & current_diagnoses

(

)

Get the current diagnoses.

current_diagnostic_state()

DiagnosticState & current_diagnostic_state

(

)

Get the current diagnostic state.

currently_solving_nonlinear_system()

bool & currently_solving_nonlinear_system

(

)

A model can be _implicit. An implicit model need to be "solved": the state variables should be iteratively updated until the residual becomes zero. During the solve, we only need derivatives with respect to the input state. Therefore, the model can/should avoid unnecessary computations by examining whether the current evaluation is part of the solve.

d_multiply_and_make_skew_d_first()

WSR4 d_multiply_and_make_skew_d_first

(

const SR2 &

b

)

d_multiply_and_make_skew_d_second()

WSR4 d_multiply_and_make_skew_d_second

(

const SR2 &

a

)

d_skew_and_sym_to_sym_d_skew()

SWR4 d_skew_and_sym_to_sym_d_skew

(

const SR2 &

e

)

d_skew_and_sym_to_sym_d_sym()

SSR4 d_skew_and_sym_to_sym_d_sym

(

const WR2 &

w

)

default_integer_dtype()

Dtype & default_integer_dtype

(

)

Default integral type.

default_integer_tensor_options()

TensorOptions default_integer_tensor_options

(

)

Default integral tensor options.

default_tensor_options()

TensorOptions default_tensor_options

(

)

Default floating point tensor options.

derivmap_cat_reduce()

DerivMap derivmap_cat_reduce	(	std::vector< DerivMap > &&	results,
		Size	batch_dim )

Concatenate the tensors in the DerivMap along the batch dimension.

Parameters

results	The results to concatenate
batch_dim	The batch dimension along which to concatenate

Returns

DerivMap with the tensors concatenated along the batch dimension

derivmap_move_device()

DerivMap derivmap_move_device	(	DerivMap &&	x,
		Device	device )

Move all tensors in a DerivMap to a device.

Parameters

x	input DerivMap
device	target device

Returns

DerivMap with all tensors moved

derivmap_no_operation()

DerivMap derivmap_no_operation

(

DerivMap &&

x

)

No operation.

diagnose()

std::vector< Diagnosis > diagnose

(

const DiagnosticsInterface &

patient

)

A helper function to diagnose common setup errors.

diagnostic_assert() [1/2]

template<typename... Args>

void diagnostic_assert	(	bool	assertion,
		Args &&...	args )

diagnostic_assert() [2/2]

template<typename... Args>

void diagnostic_assert	(	bool	,
		Args &&	... )

Helper assertion function for diagnostics.

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [1/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_ADD_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [2/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_ADD_SELF

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [3/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_ADD_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [4/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_ADD_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [5/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_DIV_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [6/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_DIV_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [7/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_DIV_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [8/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_MUL_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [9/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_MUL_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [10/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_MUL_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [11/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_SUB_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [12/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_SUB_SELF

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [13/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_SUB_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [14/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DECLARE_SUB_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [15/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_ADD_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [16/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_ADD_SELF

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [17/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_ADD_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [18/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_ADD_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [19/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_DIV_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [20/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_DIV_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [21/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_DIV_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [22/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_MUL_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [23/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_MUL_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [24/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_MUL_SYM_SCALAR

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [25/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_SUB_EQ

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [26/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_SUB_SELF

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [27/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_SUB_SYM_REAL

)

FOR_ALL_NONSCALAR_PRIMITIVETENSOR() [28/28]

FOR_ALL_NONSCALAR_PRIMITIVETENSOR

(

DEFINE_SUB_SYM_SCALAR

)

FOR_ALL_NONSCALAR_TENSORBASE()

FOR_ALL_NONSCALAR_TENSORBASE

(

DEFINE_POW

)

FOR_ALL_PRIMITIVETENSOR() [1/18]

FOR_ALL_PRIMITIVETENSOR

(

EMPTYPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [2/18]

FOR_ALL_PRIMITIVETENSOR

(

FULLPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [3/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE

)

FOR_ALL_PRIMITIVETENSOR() [4/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE_ADD_VARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [5/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE_CREATE_VARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [6/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE_DECLARE_INPUT_VARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [7/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE_DECLARE_OUTPUT_VARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [8/18]

FOR_ALL_PRIMITIVETENSOR

(

INSTANTIATE_VARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [9/18]

FOR_ALL_PRIMITIVETENSOR

(

LINSPACEPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [10/18]

FOR_ALL_PRIMITIVETENSOR

(

LOGSPACEPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [11/18]

FOR_ALL_PRIMITIVETENSOR

(

ONESPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [12/18]

FOR_ALL_PRIMITIVETENSOR

(

PARAMETERSTORE_INTANTIATE_PRIMITIVETENSOR

)

FOR_ALL_PRIMITIVETENSOR() [13/18]

FOR_ALL_PRIMITIVETENSOR

(

REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [14/18]

FOR_ALL_PRIMITIVETENSOR

(

REGISTER_CONSTANTPARAMETER

)

FOR_ALL_PRIMITIVETENSOR() [15/18]

FOR_ALL_PRIMITIVETENSOR

(

REGISTER_COPYVARIABLE

)

FOR_ALL_PRIMITIVETENSOR() [16/18]

FOR_ALL_PRIMITIVETENSOR

(

REGISTER_PRIMITIVETENSORFROMTORCHSCRIPT

)

FOR_ALL_PRIMITIVETENSOR() [17/18]

FOR_ALL_PRIMITIVETENSOR

(

USERPRIMITIVETENSOR_REGISTER

)

FOR_ALL_PRIMITIVETENSOR() [18/18]

FOR_ALL_PRIMITIVETENSOR

(

ZEROSPRIMITIVETENSOR_REGISTER

)

FOR_ALL_TENSORBASE() [1/70]

FOR_ALL_TENSORBASE

(

BUFFERSTORE_INTANTIATE_TENSORBASE

)

FOR_ALL_TENSORBASE() [2/70]

FOR_ALL_TENSORBASE

(

DECLARE_ABS

)

FOR_ALL_TENSORBASE() [3/70]

FOR_ALL_TENSORBASE

(

DECLARE_ACOS

)

FOR_ALL_TENSORBASE() [4/70]

FOR_ALL_TENSORBASE

(

DECLARE_ASIN

)

FOR_ALL_TENSORBASE() [5/70]

FOR_ALL_TENSORBASE

(

DECLARE_ATAN

)

FOR_ALL_TENSORBASE() [6/70]

FOR_ALL_TENSORBASE

(

DECLARE_BATCH_CAT

)

FOR_ALL_TENSORBASE() [7/70]

FOR_ALL_TENSORBASE

(

DECLARE_BATCH_DIAG_EMBED

)

FOR_ALL_TENSORBASE() [8/70]

FOR_ALL_TENSORBASE

(

DECLARE_BATCH_MEAN

)

FOR_ALL_TENSORBASE() [9/70]

FOR_ALL_TENSORBASE

(

DECLARE_BATCH_STACK

)

FOR_ALL_TENSORBASE() [10/70]

FOR_ALL_TENSORBASE

(

DECLARE_BATCH_SUM

)

FOR_ALL_TENSORBASE() [11/70]

FOR_ALL_TENSORBASE

(

DECLARE_CBRT

)

FOR_ALL_TENSORBASE() [12/70]

FOR_ALL_TENSORBASE

(

DECLARE_CLAMP

)

FOR_ALL_TENSORBASE() [13/70]

FOR_ALL_TENSORBASE

(

DECLARE_COS

)

FOR_ALL_TENSORBASE() [14/70]

FOR_ALL_TENSORBASE

(

DECLARE_COSH

)

FOR_ALL_TENSORBASE() [15/70]

FOR_ALL_TENSORBASE

(

DECLARE_DEG2RAD

)

FOR_ALL_TENSORBASE() [16/70]

FOR_ALL_TENSORBASE

(

DECLARE_DIFF

)

FOR_ALL_TENSORBASE() [17/70]

FOR_ALL_TENSORBASE

(

DECLARE_EXP

)

FOR_ALL_TENSORBASE() [18/70]

FOR_ALL_TENSORBASE

(

DECLARE_FMOD

)

FOR_ALL_TENSORBASE() [19/70]

FOR_ALL_TENSORBASE

(

DECLARE_GCD

)

FOR_ALL_TENSORBASE() [20/70]

FOR_ALL_TENSORBASE

(

DECLARE_HEAVISIDE

)

FOR_ALL_TENSORBASE() [21/70]

FOR_ALL_TENSORBASE

(

DECLARE_LOG

)

FOR_ALL_TENSORBASE() [22/70]

FOR_ALL_TENSORBASE

(

DECLARE_LOG10

)

FOR_ALL_TENSORBASE() [23/70]

FOR_ALL_TENSORBASE

(

DECLARE_MACAULAY

)

FOR_ALL_TENSORBASE() [24/70]

FOR_ALL_TENSORBASE

(

DECLARE_MINIMUM

)

FOR_ALL_TENSORBASE() [25/70]

FOR_ALL_TENSORBASE

(

DECLARE_POW

)

FOR_ALL_TENSORBASE() [26/70]

FOR_ALL_TENSORBASE

(

DECLARE_SIGN

)

FOR_ALL_TENSORBASE() [27/70]

FOR_ALL_TENSORBASE

(

DECLARE_SIN

)

FOR_ALL_TENSORBASE() [28/70]

FOR_ALL_TENSORBASE

(

DECLARE_SINH

)

FOR_ALL_TENSORBASE() [29/70]

FOR_ALL_TENSORBASE

(

DECLARE_SQRT

)

FOR_ALL_TENSORBASE() [30/70]

FOR_ALL_TENSORBASE

(

DECLARE_TAN

)

FOR_ALL_TENSORBASE() [31/70]

FOR_ALL_TENSORBASE

(

DECLARE_TANH

)

FOR_ALL_TENSORBASE() [32/70]

FOR_ALL_TENSORBASE

(

DECLARE_TENSOR

)

FOR_ALL_TENSORBASE() [33/70]

FOR_ALL_TENSORBASE

(

DECLARE_WHERE

)

FOR_ALL_TENSORBASE() [34/70]

FOR_ALL_TENSORBASE

(

DEFINE_ABS

)

FOR_ALL_TENSORBASE() [35/70]

FOR_ALL_TENSORBASE

(

DEFINE_ARCCOS

)

FOR_ALL_TENSORBASE() [36/70]

FOR_ALL_TENSORBASE

(

DEFINE_ARCSIN

)

FOR_ALL_TENSORBASE() [37/70]

FOR_ALL_TENSORBASE

(

DEFINE_ARCTAN

)

FOR_ALL_TENSORBASE() [38/70]

FOR_ALL_TENSORBASE

(

DEFINE_BATCH_DIAG_EMDED

)

FOR_ALL_TENSORBASE() [39/70]

FOR_ALL_TENSORBASE

(

DEFINE_BATCH_MEAN

)

FOR_ALL_TENSORBASE() [40/70]

FOR_ALL_TENSORBASE

(

DEFINE_BATCH_STACK

)

FOR_ALL_TENSORBASE() [41/70]

FOR_ALL_TENSORBASE

(

DEFINE_BATCH_SUM

)

FOR_ALL_TENSORBASE() [42/70]

FOR_ALL_TENSORBASE

(

DEFINE_CAT

)

FOR_ALL_TENSORBASE() [43/70]

FOR_ALL_TENSORBASE

(

DEFINE_CBRT

)

FOR_ALL_TENSORBASE() [44/70]

FOR_ALL_TENSORBASE

(

DEFINE_CLAMP

)

FOR_ALL_TENSORBASE() [45/70]

FOR_ALL_TENSORBASE

(

DEFINE_COS

)

FOR_ALL_TENSORBASE() [46/70]

FOR_ALL_TENSORBASE

(

DEFINE_COSH

)

FOR_ALL_TENSORBASE() [47/70]

FOR_ALL_TENSORBASE

(

DEFINE_DEG2RAD

)

FOR_ALL_TENSORBASE() [48/70]

FOR_ALL_TENSORBASE

(

DEFINE_DIFF

)

FOR_ALL_TENSORBASE() [49/70]

FOR_ALL_TENSORBASE

(

DEFINE_EXP

)

FOR_ALL_TENSORBASE() [50/70]

FOR_ALL_TENSORBASE

(

DEFINE_FMOD

)

FOR_ALL_TENSORBASE() [51/70]

FOR_ALL_TENSORBASE

(

DEFINE_GCD

)

FOR_ALL_TENSORBASE() [52/70]

FOR_ALL_TENSORBASE

(

DEFINE_HEAVISIDE

)

FOR_ALL_TENSORBASE() [53/70]

FOR_ALL_TENSORBASE

(

DEFINE_LOG

)

FOR_ALL_TENSORBASE() [54/70]

FOR_ALL_TENSORBASE

(

DEFINE_LOG10

)

FOR_ALL_TENSORBASE() [55/70]

FOR_ALL_TENSORBASE

(

DEFINE_MACAULAY

)

FOR_ALL_TENSORBASE() [56/70]

FOR_ALL_TENSORBASE

(

DEFINE_MINIMUM

)

FOR_ALL_TENSORBASE() [57/70]

FOR_ALL_TENSORBASE

(

DEFINE_SIGN

)

FOR_ALL_TENSORBASE() [58/70]

FOR_ALL_TENSORBASE

(

DEFINE_SIN

)

FOR_ALL_TENSORBASE() [59/70]

FOR_ALL_TENSORBASE

(

DEFINE_SINH

)

FOR_ALL_TENSORBASE() [60/70]

FOR_ALL_TENSORBASE

(

DEFINE_SQRT

)

FOR_ALL_TENSORBASE() [61/70]

FOR_ALL_TENSORBASE

(

DEFINE_TAN

)

FOR_ALL_TENSORBASE() [62/70]

FOR_ALL_TENSORBASE

(

DEFINE_TANH

)

FOR_ALL_TENSORBASE() [63/70]

FOR_ALL_TENSORBASE

(

DEFINE_WHERE

)

FOR_ALL_TENSORBASE() [64/70]

FOR_ALL_TENSORBASE

(

FORWARD_DECLARATION

)

FOR_ALL_TENSORBASE() [65/70]

FOR_ALL_TENSORBASE

(

INSTANTIATE

)

FOR_ALL_TENSORBASE() [66/70]

FOR_ALL_TENSORBASE

(

INSTANTIATE_TENSORBASE

)

FOR_ALL_TENSORBASE() [67/70]

FOR_ALL_TENSORBASE

(

INSTANTIATE_TENSORNAME

)

FOR_ALL_TENSORBASE() [68/70]

FOR_ALL_TENSORBASE

(

INSTANTIATE_TENSORVALUE

)

FOR_ALL_TENSORBASE() [69/70]

FOR_ALL_TENSORBASE

(

PARAMETERSTORE_INTANTIATE_TENSORBASE

)

FOR_ALL_TENSORBASE() [70/70]

FOR_ALL_TENSORBASE

(

SPECIALIZE_TENSORTYPEENUM

)

FOR_ALL_VECBASE()

FOR_ALL_VECBASE

(

VECBASE_INSTANTIATE

)

full_to_mandel()

Tensor full_to_mandel	(	const Tensor &	full,
		Size	dim = 0 )

Convert a Tensor from full notation to Mandel notation.

The tensor in full notation full can have arbitrary batch shape. The optional argument dim denotes the base dimension starting from which the conversion should take place.

For example, a full tensor has shape (2, 3, 1, 5; 2, 9, 3, 3, 2, 3) where the semicolon separates batch and base shapes. The symmetric axes have base dim 2 and 3. After converting to Mandel notation, the resulting tensor will have shape (2, 3, 1, 5; 2, 9, 6, 2, 3). Note how the shape of the symmetric dimensions (3, 3) becomes (6). In this example, the base dim (the second argument to this function) should be 2.

Parameters

full	The input tensor in full notation
dim	The base dimension where the symmetric axes start

Returns

Tensor The resulting tensor using Mandel notation to represent the symmetric axes.

full_to_mandel_factor()

const Tensor & full_to_mandel_factor

(

const TensorOptions &

opt

)

full_to_mandel_map()

const Tensor & full_to_mandel_map

(

const TensorOptions &

opt

)

full_to_reduced()

Tensor full_to_reduced	(	const Tensor &	full,
		const Tensor &	rmap,
		const Tensor &	rfactors,
		Size	dim = 0 )

Generic function to reduce two axes to one with some map.

The tensor in full notation full can have arbitrary batch shape. The optional argument dim denotes the base dimension starting from which the conversion should take place.

The function will reduce the two axis at the desired location down to one, using the provided maps.

For example, a full tensor has shape (2, 3, 1, 5; 2, 9, 3, 3, 2, 3) where the semicolon separates batch and base shapes. The reduction axes have base dim 2 and 3. After applying the reduction, the resulting tensor will have shape (2, 3, 1, 5; 2, 9, X, 2, 3) where X is the reduced shape. In this example, the base dim (the second argument to this function) should be 2.

Parameters

full	The input tensor in full notation
rmap	The reduction map
rfactors	The reduction factors
dim	The base dimension where the reduced axes start

Returns

Tensor The reduced tensor

full_to_skew()

Tensor full_to_skew	(	const Tensor &	full,
		Size	dim = 0 )

Convert a Tensor from full notation to skew vector notation.

The tensor in full notation full can have arbitrary batch shape. The optional argument dim denotes the base dimension starting from which the conversion should take place.

For example, a full tensor has shape (2, 3, 1, 5; 2, 9, 3, 3, 2, 3) where the semicolon separates batch and base shapes. The symmetric axes have base dim 2 and 3. After converting to skew notation, the resulting tensor will have shape (2, 3, 1, 5; 2, 9, 3, 2, 3). Note how the shape of the symmetric dimensions (3, 3) becomes (3). In this example, the base dim (the second argument to this function) should be 2.

Parameters

full	The input tensor in full notation
dim	The base dimension where the symmetric axes start

Returns

Tensor The resulting tensor using skew notation to represent the skew-symmetric axes.

full_to_skew_factor()

const Tensor & full_to_skew_factor

(

const TensorOptions &

opt

)

full_to_skew_map()

const Tensor & full_to_skew_map

(

const TensorOptions &

opt

)

get_default_dtype()

Dtype get_default_dtype

(

)

Get default dtype.

get_driver()

Driver & get_driver

(

const std::string &

dname

)

A convenient function to manufacture a neml2::Driver.

The input file must have already been parsed and loaded.

Parameters

dname

Name of the driver

get_force()

template<typename T>

void get_force	(	std::vector< VariableName > &	names,
		std::vector< Tensor > &	values,
		const OptionSet &	options,
		const std::string &	name_opt,
		const std::string &	value_opt,
		const Device &	device )

get_model()

Model & get_model

(

const std::string &

mname

)

A convenient function to manufacture a neml2::Model.

The input file must have already been parsed and loaded.

Parameters

mname

Name of the model

identity_transform()

R2 identity_transform

(

const TensorOptions &

options

)

The identity transformation, i.e.e the Rank2 identity tensor.

improper_rotation_transform()

R2 improper_rotation_transform

(

const Rot &

rot

)

An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.

inversion_transform()

R2 inversion_transform

(

const TensorOptions &

option

)

An inversion center.

jacrev() [1/2]

std::vector< Tensor > jacrev	(	const Tensor &	y,
		const std::vector< Tensor > &	xs,
		bool	retain_graph = false,
		bool	create_graph = false,
		bool	allow_unused = false )

Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.

Warning

Torch (and hence NEML2) AD wasn't designed to compute the full Jacobian from the very beginning. Using this method to calculate the full Jacobian is inefficient and is subjected to some restrictions on batch shapes.

Parameters

y	The Tensor to to be differentiated
xs	The arguments to take derivatives with respect to
retain_graph	Whether to retain the computation graph (necessary if y has base storage size>1)
create_graph	Whether to create the computation graph (necessary if you want to differentiate the returned Jacobian)
allow_unused	Whether to allow unused input argument x

Returns

Tensor $\partial y/\partial p$

jacrev() [2/2]

Tensor jacrev	(	const Tensor &	y,
		const Tensor &	x,
		bool	retain_graph,
		bool	create_graph,
		bool	allow_unused )

Similar to the other jacrev, but for a single input.

LabeledAxisAccessor::operator std::vector< std::string >()

LabeledAxisAccessor::operator std::vector< std::string >

(

)

const

list_derivative_outer_product_a()

template<typename F, typename T1, typename T2>

Tensor list_derivative_outer_product_a	(	F &&	f,
		const T1 &	a,
		const T2 &	b )

outer product on lists, where the first input is a list tensor

list_derivative_outer_product_ab()

template<typename F, typename T1, typename T2>

Tensor list_derivative_outer_product_ab	(	F &&	f,
		const T1 &	a,
		const T2 &	b )

outer product on lists where both inputs are list tensors

list_derivative_outer_product_b()

template<typename F, typename T1, typename T2>

Tensor list_derivative_outer_product_b	(	F &&	f,
		const T1 &	a,
		const T2 &	b )

outer product on lists, where the second input is a list tensor

load_input()

void load_input	(	const std::filesystem::path &	path,
		const std::string &	additional_input = "" )

A convenient function to parse all options from an input file.

Previously loaded input options will be discarded!

Warning

All threads share the same input options, so in principle this function is not intended to be called inside a threaded region.

Parameters

path	Path to the input file to be parsed
additional_input	Additional cliargs to pass to the parser

load_model()

Model & load_model	(	const std::filesystem::path &	path,
		const std::string &	mname )

A convenient function to load an input file and get a model.

Warning

All threads share the same input options, so in principle this function is not intended to be called inside a threaded region.

Parameters

path	Path to the input file to be parsed
mname	Name of the model

machine_precision()

Real & machine_precision

(

)

Machine precision

mandel_factor()

Real mandel_factor ( Size i )

inlineconstexpr

mandel_to_full()

Tensor mandel_to_full	(	const Tensor &	mandel,
		Size	dim = 0 )

Convert a Tensor from Mandel notation to full notation.

See full_to_mandel for a detailed explanation.

Parameters

mandel	The input tensor in Mandel notation
dim	The base dimension where the symmetric axes start

Returns

Tensor The resulting tensor in full notation.

mandel_to_full_factor()

const Tensor & mandel_to_full_factor

(

const TensorOptions &

opt

)

mandel_to_full_map()

const Tensor & mandel_to_full_map

(

const TensorOptions &

opt

)

multiply_and_make_skew()

WR2 multiply_and_make_skew	(	const SR2 &	a,
		const SR2 &	b )

name()

std::string name

(

ElasticConstant

p

)

neml_assert()

template<typename... Args>

void neml_assert	(	bool	assertion,
		Args &&...	args )

neml_assert_base_broadcastable() [1/2]

template<class... T>

void neml_assert_base_broadcastable

(

const T &...

tensors

)

neml_assert_base_broadcastable() [2/2]

template<class... T>

void neml_assert_base_broadcastable

(

const T &

...

)

A helper function to assert that all tensors are base-broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_base_broadcastable_dbg() [1/2]

template<class... T>

void neml_assert_base_broadcastable_dbg

(

const T &...

tensors

)

neml_assert_base_broadcastable_dbg() [2/2]

template<class... T>

void neml_assert_base_broadcastable_dbg

(

const T &

...

)

A helper function to assert that (in Debug mode) all tensors are base-broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_batch_broadcastable() [1/2]

template<class... T>

void neml_assert_batch_broadcastable

(

const T &...

tensors

)

neml_assert_batch_broadcastable() [2/2]

template<class... T>

void neml_assert_batch_broadcastable

(

const T &

...

)

A helper function to assert that all tensors are batch-broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_batch_broadcastable_dbg() [1/2]

template<class... T>

void neml_assert_batch_broadcastable_dbg

(

const T &...

tensors

)

neml_assert_batch_broadcastable_dbg() [2/2]

template<class... T>

void neml_assert_batch_broadcastable_dbg

(

const T &

...

)

A helper function to assert that (in Debug mode) all tensors are batch-broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_broadcastable() [1/2]

template<class... T>

void neml_assert_broadcastable

(

const T &...

tensors

)

neml_assert_broadcastable() [2/2]

template<class... T>

void neml_assert_broadcastable

(

const T &

...

)

A helper function to assert that all tensors are broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_broadcastable_dbg() [1/2]

template<class... T>

void neml_assert_broadcastable_dbg

(

const T &...

tensors

)

neml_assert_broadcastable_dbg() [2/2]

template<class... T>

void neml_assert_broadcastable_dbg

(

const T &

...

)

A helper function to assert (in Debug mode) that all tensors are broadcastable.

In most cases, this assertion is necessary as libTorch will raise runtime_errors if things go wrong. Therefore, this function is just so that we can detect errors before libTorch does and emit some more mearningful error messages within the NEML2 context.

neml_assert_dbg()

template<typename... Args>

void neml_assert_dbg	(	bool	assertion,
		Args &&...	args )

neml_assert_not_tracing()

void neml_assert_not_tracing

(

)

Assert that we are currently NOT tracing.

neml_assert_not_tracing_dbg()

void neml_assert_not_tracing_dbg

(

)

Assert that we are currently NOT tracing (only effective in debug mode)

neml_assert_tracing()

void neml_assert_tracing

(

)

Assert that we are currently tracing.

neml_assert_tracing_dbg()

void neml_assert_tracing_dbg

(

)

Assert that we are currently tracing (only effective in debug mode)

operator!=() [1/4]

bool operator!=	(	const LabeledAxis &	a,
		const LabeledAxis &	b )

operator!=() [2/4]

bool operator!=	(	const LabeledAxisAccessor &	a,
		const LabeledAxisAccessor &	b )

Compare for equality between two LabeledAxisAccessor.

operator!=() [3/4]

bool operator!=	(	const TraceableSize &	lhs,
		const TraceableSize &	rhs )

operator!=() [4/4]

bool operator!=	(	const TraceableTensorShape &	lhs,
		const TraceableTensorShape &	rhs )

operator*() [1/17]

template<class Derived1, class Derived2, typename, typename>

R2 operator*	(	const Derived1 &	A,
		const Derived2 &	B )

matrix-matrix product

operator*() [2/17]

template<class Derived1, class Derived2, typename, typename>

Vec operator*	(	const Derived1 &	A,
		const Derived2 &	b )

matrix-vector product

operator*() [3/17]

template R2 operator*	(	const R2 &	A,
		const R2 &	B )

operator*() [4/17]

template Vec operator*	(	const R2 &	A,
		const Vec &	b )

operator*() [5/17]

Scalar operator*	(	const Real &	a,
		const Scalar &	b )

operator*() [6/17]

Tensor operator*	(	const Real &	a,
		const Tensor &	b )

operator*() [7/17]

Rot operator*	(	const Rot &	r1,
		const Rot &	r2 )

Composition of rotations r3 = r1 * r2 (r2 first, then r1)

operator*() [8/17]

Scalar operator*	(	const Scalar &	a,
		const Real &	b )

operator*() [9/17]

Scalar operator*	(	const Scalar &	a,
		const Scalar &	b )

operator*() [10/17]

Tensor operator*	(	const Scalar &	a,
		const Tensor &	b )

operator*() [11/17]

SR2 operator*	(	const SR2 &	a,
		const SSR4 &	b )

operator*() [12/17]

SR2 operator*	(	const SSR4 &	a,
		const SR2 &	b )

operator*() [13/17]

SSR4 operator*	(	const SSR4 &	a,
		const SSR4 &	b )

operator*() [14/17]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>

auto operator*	(	const T1 &	a,
		const T2 &	b )

operator*() [15/17]

Tensor operator*	(	const Tensor &	a,
		const Real &	b )

operator*() [16/17]

Tensor operator*	(	const Tensor &	a,
		const Scalar &	b )

operator*() [17/17]

Tensor operator*	(	const Tensor &	a,
		const Tensor &	b )

operator*=() [1/2]

Scalar & operator*=	(	Scalar &	a,
		const Real &	b )

operator*=() [2/2]

Tensor & operator*=	(	Tensor &	a,
		const Real &	b )

operator+() [1/9]

Scalar operator+	(	const Real &	a,
		const Scalar &	b )

operator+() [2/9]

Tensor operator+	(	const Real &	a,
		const Tensor &	b )

operator+() [3/9]

Scalar operator+	(	const Scalar &	a,
		const Real &	b )

operator+() [4/9]

Scalar operator+	(	const Scalar &	a,
		const Scalar &	b )

operator+() [5/9]

Tensor operator+	(	const Scalar &	a,
		const Tensor &	b )

operator+() [6/9]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>

auto operator+	(	const T1 &	a,
		const T2 &	b )

operator+() [7/9]

Tensor operator+	(	const Tensor &	a,
		const Real &	b )

operator+() [8/9]

Tensor operator+	(	const Tensor &	a,
		const Scalar &	b )

operator+() [9/9]

Tensor operator+	(	const Tensor &	a,
		const Tensor &	b )

operator+=() [1/2]

Scalar & operator+=	(	Scalar &	a,
		const Real &	b )

operator+=() [2/2]

Tensor & operator+=	(	Tensor &	a,
		const Real &	b )

operator-() [1/9]

Scalar operator-	(	const Real &	a,
		const Scalar &	b )

operator-() [2/9]

Tensor operator-	(	const Real &	a,
		const Tensor &	b )

operator-() [3/9]

Scalar operator-	(	const Scalar &	a,
		const Real &	b )

operator-() [4/9]

Scalar operator-	(	const Scalar &	a,
		const Scalar &	b )

operator-() [5/9]

Tensor operator-	(	const Scalar &	a,
		const Tensor &	b )

operator-() [6/9]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>

auto operator-	(	const T1 &	a,
		const T2 &	b )

operator-() [7/9]

Tensor operator-	(	const Tensor &	a,
		const Real &	b )

operator-() [8/9]

Tensor operator-	(	const Tensor &	a,
		const Scalar &	b )

operator-() [9/9]

Tensor operator-	(	const Tensor &	a,
		const Tensor &	b )

operator-=() [1/2]

Scalar & operator-=	(	Scalar &	a,
		const Real &	b )

operator-=() [2/2]

Tensor & operator-=	(	Tensor &	a,
		const Real &	b )

operator/() [1/9]

Scalar operator/	(	const Real &	a,
		const Scalar &	b )

operator/() [2/9]

Tensor operator/	(	const Real &	a,
		const Tensor &	b )

operator/() [3/9]

Scalar operator/	(	const Scalar &	a,
		const Real &	b )

operator/() [4/9]

Scalar operator/	(	const Scalar &	a,
		const Scalar &	b )

operator/() [5/9]

Tensor operator/	(	const Scalar &	a,
		const Tensor &	b )

operator/() [6/9]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>

auto operator/	(	const T1 &	a,
		const T2 &	b )

operator/() [7/9]

Tensor operator/	(	const Tensor &	a,
		const Real &	b )

operator/() [8/9]

Tensor operator/	(	const Tensor &	a,
		const Scalar &	b )

operator/() [9/9]

Tensor operator/	(	const Tensor &	a,
		const Tensor &	b )

operator/=() [1/2]

Scalar & operator/=	(	Scalar &	a,
		const Real &	b )

operator/=() [2/2]

Tensor & operator/=	(	Tensor &	a,
		const Real &	b )

operator<()

bool operator<	(	const LabeledAxisAccessor &	a,
		const LabeledAxisAccessor &	b )

The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.

operator<<() [1/12]

std::ostream & operator<<	(	std::ostream &	os,
		const EnumSelection &	es )

operator<<() [2/12]

std::ostream & operator<<	(	std::ostream &	os,
		const LabeledAxis &	axis )

operator<<() [3/12]

std::ostream & operator<<	(	std::ostream &	os,
		const LabeledAxisAccessor &	accessor )

Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".

operator<<() [4/12]

std::ostream & operator<<	(	std::ostream &	os,
		const Model &	model )

operator<<() [5/12]

std::ostream & operator<<	(	std::ostream &	os,
		const MultiEnumSelection &	es )

operator<<() [6/12]

std::ostream & operator<<	(	std::ostream &	os,
		const OptionBase &	opt )

operator<<() [7/12]

std::ostream & operator<<	(	std::ostream &	os,
		const OptionCollection &	p )

operator<<() [8/12]

std::ostream & operator<<	(	std::ostream &	os,
		const OptionSet &	p )

operator<<() [9/12]

template<typename T>

std::ostream & operator<<	(	std::ostream &	os,
		const TensorName< T > &	t )

Stream out a TensorName (used for printing OptionSet)

operator<<() [10/12]

std::ostream & operator<<	(	std::ostream &	os,
		const TensorType &	t )

operator<<() [11/12]

std::ostream & operator<<	(	std::ostream &	os,
		const TraceableSize &	s )

Streaming operator.

operator<<() [12/12]

std::ostream & operator<<	(	std::ostream &	os,
		FType	f )

operator==() [1/4]

bool operator==	(	const LabeledAxis &	a,
		const LabeledAxis &	b )

operator==() [2/4]

bool operator==	(	const LabeledAxisAccessor &	a,
		const LabeledAxisAccessor &	b )

Compare for equality between two LabeledAxisAccessor.

operator==() [3/4]

bool operator==	(	const TraceableSize &	lhs,
		const TraceableSize &	rhs )

Comparison operators

operator==() [4/4]

bool operator==	(	const TraceableTensorShape &	lhs,
		const TraceableTensorShape &	rhs )

Comparison operators

operator>>() [1/3]

std::stringstream & operator>>	(	std::stringstream &	ss,
		EnumSelection &	es )

operator>>() [2/3]

std::stringstream & operator>>	(	std::stringstream &	ss,
		MultiEnumSelection &	es )

operator>>() [3/3]

template<typename T>

std::stringstream & operator>>	(	std::stringstream &	ss,
		TensorName< T > &	t )

Stream into a TensorName (used by Parsers to extract input options)

options_compatible()

bool options_compatible	(	const OptionSet &	opts,
		const OptionSet &	additional_opts )

parameter_name_separator()

std::string & parameter_name_separator

(

)

Default nested parameter name separator.

pow() [1/5]

Scalar pow	(	const Real &	a,
		const Scalar &	n )

pow() [2/5]

Tensor pow	(	const Real &	a,
		const Tensor &	n )

Element-wise pow.

pow() [3/5]

Scalar pow	(	const Scalar &	a,
		const Real &	n )

pow() [4/5]

Scalar pow	(	const Scalar &	a,
		const Scalar &	n )

pow() [5/5]

Tensor pow	(	const Tensor &	a,
		const Tensor &	n )

Element-wise pow.

proper_rotation_transform()

R2 proper_rotation_transform

(

const Rot &

rot

)

A proper rotation, here provided by a Rot object.

reduced_to_full()

Tensor reduced_to_full	(	const Tensor &	reduced,
		const Tensor &	rmap,
		const Tensor &	rfactors,
		Size	dim = 0 )

Convert a Tensor from reduced notation to full notation.

See full_to_reduced for a detailed explanation.

Parameters

reduced	The input tensor in reduced notation
rmap	The unreduction map
rfactors	The unreduction factors
dim	The base dimension where the reduced axes start

Returns

Tensor The resulting tensor in full notation.

reflection_transform()

R2 reflection_transform

(

const Vec &

v

)

A reflection, defined by the reflection plane.

register_NEML2_object() [1/112]

register_NEML2_object

(

ArrheniusParameter

)

register_NEML2_object() [2/112]

register_NEML2_object

(

AssociativeIsotropicPlasticHardening

)

register_NEML2_object() [3/112]

register_NEML2_object

(

AssociativeJ2FlowDirection

)

register_NEML2_object() [4/112]

register_NEML2_object

(

AssociativeKinematicPlasticHardening

)

register_NEML2_object() [5/112]

register_NEML2_object

(

AssociativePlasticFlow

)

register_NEML2_object() [6/112]

register_NEML2_object

(

AvramiErofeevNucleation

)

register_NEML2_object() [7/112]

register_NEML2_object

(

ChabochePlasticHardening

)

register_NEML2_object() [8/112]

register_NEML2_object

(

ChemicalReactionMechanism

)

register_NEML2_object() [9/112]

register_NEML2_object

(

ComposedModel

)

register_NEML2_object() [10/112]

register_NEML2_object

(

CubicElasticityTensor

)

register_NEML2_object() [11/112]

register_NEML2_object

(

DiffusionLimitedReaction

)

register_NEML2_object() [12/112]

register_NEML2_object

(

ElasticStrainRate

)

register_NEML2_object() [13/112]

register_NEML2_object

(

EmptyTensor

)

register_NEML2_object() [14/112]

register_NEML2_object

(

FillMillerIndex

)

register_NEML2_object() [15/112]

register_NEML2_object

(

FillR2

)

register_NEML2_object() [16/112]

register_NEML2_object

(

FillRot

)

register_NEML2_object() [17/112]

register_NEML2_object

(

FillSR2

)

register_NEML2_object() [18/112]

register_NEML2_object

(

FillWR2

)

register_NEML2_object() [19/112]

register_NEML2_object

(

FischerBurmeister

)

register_NEML2_object() [20/112]

register_NEML2_object

(

FixOrientation

)

register_NEML2_object() [21/112]

register_NEML2_object

(

FredrickArmstrongPlasticHardening

)

register_NEML2_object() [22/112]

register_NEML2_object

(

FullTensor

)

register_NEML2_object() [23/112]

register_NEML2_object

(

GeneralElasticity

)

register_NEML2_object() [24/112]

register_NEML2_object

(

GTNYieldFunction

)

register_NEML2_object() [25/112]

register_NEML2_object

(

GursonCavitation

)

register_NEML2_object() [26/112]

register_NEML2_object

(

HermiteSmoothStep

)

register_NEML2_object() [27/112]

register_NEML2_object

(

IdentityTensor

)

register_NEML2_object() [28/112]

register_NEML2_object

(

ImplicitUpdate

)

register_NEML2_object() [29/112]

register_NEML2_object

(

IsotropicElasticityTensor

)

register_NEML2_object() [30/112]

register_NEML2_object

(

IsotropicMandelStress

)

register_NEML2_object() [31/112]

register_NEML2_object

(

KocksMeckingActivationEnergy

)

register_NEML2_object() [32/112]

register_NEML2_object

(

KocksMeckingFlowSwitch

)

register_NEML2_object() [33/112]

register_NEML2_object

(

KocksMeckingFlowViscosity

)

register_NEML2_object() [34/112]

register_NEML2_object

(

KocksMeckingIntercept

)

register_NEML2_object() [35/112]

register_NEML2_object

(

KocksMeckingRateSensitivity

)

register_NEML2_object() [36/112]

register_NEML2_object

(

KocksMeckingYieldStress

)

register_NEML2_object() [37/112]

register_NEML2_object

(

LDISolidMechanicsDriver

)

register_NEML2_object() [38/112]

register_NEML2_object

(

LinearIsotropicElasticity

)

register_NEML2_object() [39/112]

register_NEML2_object

(

LinearIsotropicElasticJ2TrialStressUpdate

)

register_NEML2_object() [40/112]

register_NEML2_object

(

LinearIsotropicHardening

)

register_NEML2_object() [41/112]

register_NEML2_object

(

LinearKinematicHardening

)

register_NEML2_object() [42/112]

register_NEML2_object

(

LinearSingleSlipHardeningRule

)

register_NEML2_object() [43/112]

register_NEML2_object

(

LinspaceTensor

)

register_NEML2_object() [44/112]

register_NEML2_object

(

LogspaceTensor

)

register_NEML2_object() [45/112]

register_NEML2_object

(

MixedControlSetup

)

register_NEML2_object() [46/112]

register_NEML2_object

(

Newton

)

register_NEML2_object() [47/112]

register_NEML2_object

(

NewtonWithLineSearch

)

register_NEML2_object() [48/112]

register_NEML2_object

(

NewtonWithTrustRegion

)

register_NEML2_object() [49/112]

register_NEML2_object

(

Normality

)

register_NEML2_object() [50/112]

register_NEML2_object

(

OlevskySinteringStress

)

register_NEML2_object() [51/112]

register_NEML2_object

(

OnesTensor

)

register_NEML2_object() [52/112]

register_NEML2_object

(

Orientation

)

register_NEML2_object() [53/112]

register_NEML2_object

(

OrientationRate

)

register_NEML2_object() [54/112]

register_NEML2_object

(

PerzynaPlasticFlowRate

)

register_NEML2_object() [55/112]

register_NEML2_object

(

PhaseTransformationEigenstrain

)

register_NEML2_object() [56/112]

register_NEML2_object

(

PlasticDeformationRate

)

register_NEML2_object() [57/112]

register_NEML2_object

(

PlasticVorticity

)

register_NEML2_object() [58/112]

register_NEML2_object

(

PowerLawIsotropicHardeningStaticRecovery

)

register_NEML2_object() [59/112]

register_NEML2_object

(

PowerLawKinematicHardeningStaticRecovery

)

register_NEML2_object() [60/112]

register_NEML2_object

(

PowerLawSlipRule

)

register_NEML2_object() [61/112]

register_NEML2_object

(

ProductGeometry

)

register_NEML2_object() [62/112]

register_NEML2_object

(

ProjectileAcceleration

)

register_NEML2_object() [63/112]

register_NEML2_object

(

PyrolysisConversionAmount

)

register_NEML2_object() [64/112]

register_NEML2_object

(

PyrolysisKinetics

)

register_NEML2_object() [65/112]

register_NEML2_object

(

R2IncrementToRate

)

register_NEML2_object() [66/112]

register_NEML2_object

(

R2toSR2

)

register_NEML2_object() [67/112]

register_NEML2_object

(

R2toWR2

)

register_NEML2_object() [68/112]

register_NEML2_object

(

RateIndependentPlasticFlowConstraint

)

register_NEML2_object() [69/112]

register_NEML2_object

(

ResolvedShear

)

register_NEML2_object() [70/112]

register_NEML2_object

(

RotationMatrix

)

register_NEML2_object() [71/112]

register_NEML2_object

(

ScalarBackwardEulerTimeIntegration

)

register_NEML2_object() [72/112]

register_NEML2_object

(

ScalarForwardEulerTimeIntegration

)

register_NEML2_object() [73/112]

register_NEML2_object

(

ScalarIncrementToRate

)

register_NEML2_object() [74/112]

register_NEML2_object

(

ScalarLinearCombination

)

register_NEML2_object() [75/112]

register_NEML2_object

(

ScalarLinearInterpolation

)

register_NEML2_object() [76/112]

register_NEML2_object

(

ScalarTwoStageThermalAnnealing

)

register_NEML2_object() [77/112]

register_NEML2_object

(

ScalarVariableMultiplication

)

register_NEML2_object() [78/112]

register_NEML2_object

(

ScalarVariableRate

)

register_NEML2_object() [79/112]

register_NEML2_object

(

SDTSolidMechanicsDriver

)

register_NEML2_object() [80/112]

register_NEML2_object

(

SimpleMPIScheduler

)

register_NEML2_object() [81/112]

register_NEML2_object

(

SimpleScheduler

)

register_NEML2_object() [82/112]

register_NEML2_object

(

SingleSlipStrengthMap

)

register_NEML2_object() [83/112]

register_NEML2_object

(

SlopeSaturationVoceIsotropicHardening

)

register_NEML2_object() [84/112]

register_NEML2_object

(

SR2BackwardEulerTimeIntegration

)

register_NEML2_object() [85/112]

register_NEML2_object

(

SR2CrystalMean

)

register_NEML2_object() [86/112]

register_NEML2_object

(

SR2ForwardEulerTimeIntegration

)

register_NEML2_object() [87/112]

register_NEML2_object

(

SR2IncrementToRate

)

register_NEML2_object() [88/112]

register_NEML2_object

(

SR2Invariant

)

register_NEML2_object() [89/112]

register_NEML2_object

(

SR2LinearCombination

)

register_NEML2_object() [90/112]

register_NEML2_object

(

SR2LinearInterpolation

)

register_NEML2_object() [91/112]

register_NEML2_object

(

SR2toR2

)

register_NEML2_object() [92/112]

register_NEML2_object

(

SR2TwoStageThermalAnnealing

)

register_NEML2_object() [93/112]

register_NEML2_object

(

SR2VariableRate

)

register_NEML2_object() [94/112]

register_NEML2_object

(

StaticHybridScheduler

)

register_NEML2_object() [95/112]

register_NEML2_object

(

SumSlipRates

)

register_NEML2_object() [96/112]

register_NEML2_object

(

SymmetryFromOrbifold

)

register_NEML2_object() [97/112]

register_NEML2_object

(

TensorFromTorchScript

)

register_NEML2_object() [98/112]

register_NEML2_object

(

ThermalEigenstrain

)

register_NEML2_object() [99/112]

register_NEML2_object

(

TransientDriver

)

register_NEML2_object() [100/112]

register_NEML2_object

(

VecBackwardEulerTimeIntegration

)

register_NEML2_object() [101/112]

register_NEML2_object

(

VecForwardEulerTimeIntegration

)

register_NEML2_object() [102/112]

register_NEML2_object

(

VecIncrementToRate

)

register_NEML2_object() [103/112]

register_NEML2_object

(

VecLinearCombination

)

register_NEML2_object() [104/112]

register_NEML2_object

(

VecLinearInterpolation

)

register_NEML2_object() [105/112]

register_NEML2_object

(

VecVariableRate

)

register_NEML2_object() [106/112]

register_NEML2_object

(

VoceIsotropicHardening

)

register_NEML2_object() [107/112]

register_NEML2_object

(

VoceSingleSlipHardeningRule

)

register_NEML2_object() [108/112]

register_NEML2_object

(

VolumeChangeEigenstrain

)

register_NEML2_object() [109/112]

register_NEML2_object

(

WR2ExplicitExponentialTimeIntegration

)

register_NEML2_object() [110/112]

register_NEML2_object

(

WR2ImplicitExponentialTimeIntegration

)

register_NEML2_object() [111/112]

register_NEML2_object

(

YieldFunction

)

register_NEML2_object() [112/112]

register_NEML2_object

(

ZerosTensor

)

register_NEML2_object_alias()

register_NEML2_object_alias	(	UserTensor	,
		"Tensor"	)

reload_input()

void reload_input	(	const std::filesystem::path &	path,
		const std::string &	additional_input = "" )

Similar to neml2::load_input, but additionally clear the Factory before loading the options, therefore all previously loaded models become dangling.

Previously loaded input options will be discarded!

Warning

All threads share the same input options, so in principle this function is not intended to be called inside a threaded region.

Parameters

path	Path to the input file to be parsed
additional_input	Additional cliargs to pass to the parser

reload_model()

Model & reload_model	(	const std::filesystem::path &	path,
		const std::string &	mname )

Similar to neml2::load_model, but additionally clear the Factory before loading the model, therefore all previously loaded models become dangling.

Warning

All threads share the same input options, so in principle this function is not intended to be called inside a threaded region.

Parameters

path	Path to the input file to be parsed
mname	Name of the model

require_double_precision()

bool & require_double_precision

(

)

Require double precision for all computations.

reserved_subaxis_names()

std::vector< std::string > reserved_subaxis_names

(

)

resolve_tensor_name()

template<typename T>

const T & resolve_tensor_name	(	const TensorName< T > &	tn,
		Model *	caller,
		const std::string &	pname )

set_default_dtype()

void set_default_dtype

(

Dtype

dtype

)

Set default dtype

set_ic()

template<typename T>

void set_ic	(	ValueMap &	storage,
		const OptionSet &	options,
		const std::string &	name_opt,
		const std::string &	value_opt,
		const Device &	device )

skew_and_sym_to_sym()

SR2 skew_and_sym_to_sym	(	const SR2 &	e,
		const WR2 &	w )

skew_to_full()

Tensor skew_to_full	(	const Tensor &	skew,
		Size	dim = 0 )

Convert a Tensor from skew vector notation to full notation.

See full_to_skew for a detailed explanation.

Parameters

skew	The input tensor in skew notation
dim	The base dimension where the symmetric axes start

Returns

Tensor The resulting tensor in full notation.

skew_to_full_factor()

const Tensor & skew_to_full_factor

(

const TensorOptions &

opt

)

skew_to_full_map()

const Tensor & skew_to_full_map

(

const TensorOptions &

opt

)

tighter_tolerance()

Real & tighter_tolerance

(

)

A tighter tolerance used in various algorithms.

timed_sections()

std::map< std::string, std::map< std::string, unsigned long > > & timed_sections

(

)

tolerance()

Real & tolerance

(

)

The tolerance used in various algorithms.

transform_from_quaternion()

R2 transform_from_quaternion

(

const Quaternion &

q

)

Construct from quaternions, useful for comparison to old NEML.

valuemap_cat_reduce()

ValueMap valuemap_cat_reduce	(	std::vector< ValueMap > &&	results,
		Size	batch_dim )

Concatenate the tensors in the ValueMap along the batch dimension.

Parameters

results	The results to concatenate
batch_dim	The batch dimension along which to concatenate

Returns

ValueMap with the tensors concatenated along the batch dimension

valuemap_move_device()

ValueMap valuemap_move_device	(	ValueMap &&	x,
		Device	device )

Move all tensors in a ValueMap to a device.

Parameters

x	input ValueMap
device	target device

Returns

ValueMap with all tensors moved

valuemap_no_operation()

ValueMap valuemap_no_operation

(

ValueMap &&

x

)

No operation.

Variable Documentation

eps

auto eps = std::numeric_limits<Real>::epsilon()

constexpr

Constants.

FORCES

const std::string FORCES = "forces"

inline

invsqrt2

Real invsqrt2 = 0.7071067811865475

constexpr

kCPU

auto kCPU = c10::DeviceType::CPU

constexpr

kCUDA

auto kCUDA = c10::DeviceType::CUDA

constexpr

kFloat16

auto kFloat16 = c10::kHalf

constexpr

kFloat32

auto kFloat32 = c10::kFloat

constexpr

kFloat64

auto kFloat64 = c10::kDouble

constexpr

kInt16

auto kInt16 = c10::kShort

constexpr

kInt32

auto kInt32 = c10::kInt

constexpr

kInt64

auto kInt64 = c10::kLong

constexpr

kInt8

auto kInt8 = c10::kChar

constexpr

Fixed width dtypes (mirroring the definition in <torch/csrc/api/include/torch/types.h>)

mandel_index

std::array<std::array<Size, 2>, 6> mandel_index

constexpr

Initial value:

{std::array<Size, 2>{0, 0},
                                                          std::array<Size, 2>{1, 1},
                                                          std::array<Size, 2>{2, 2},
                                                          std::array<Size, 2>{1, 2},
                                                          std::array<Size, 2>{0, 2},
                                                          std::array<Size, 2>{0, 1}}

mandel_reverse_index

std::array<std::array<Size, 3>, 3> mandel_reverse_index

constexpr

Initial value:

{
    std::array<Size, 3>{0, 5, 4}, std::array<Size, 3>{5, 1, 3}, std::array<Size, 3>{4, 3, 2}}

OLD_FORCES

const std::string OLD_FORCES = "old_forces"

inline

OLD_STATE

const std::string OLD_STATE = "old_state"

inline

PARAMETERS

const std::string PARAMETERS = "parameters"

inline

RESIDUAL

const std::string RESIDUAL = "residual"

inline

skew_factor

std::array<std::array<Real, 3>, 3> skew_factor

constexpr

Initial value:

{std::array<Real, 3>{0.0, -1.0, 1.0},
                                                         std::array<Real, 3>{1.0, 0.0, -1.0},
                                                         std::array<Real, 3>{-1.0, 1.0, 0.0}}

skew_reverse_index

std::array<std::array<Size, 3>, 3> skew_reverse_index

constexpr

Initial value:

{
    std::array<Size, 3>{0, 2, 1}, std::array<Size, 3>{2, 0, 0}, std::array<Size, 3>{1, 0, 0}}

sqrt2

Real sqrt2 = 1.4142135623730951

constexpr

STATE

const std::string STATE = "state"

inline