Inputs

BC

BC::BC

This is the mechanism for impositing boundary conditions on Set::Field objects of scalar type. Typical convention is for [prefix] to be given by the field name. For instance,

bc.temp.type.xhi = dirichlet dirichlet dirichlet
bc.temp.val.xhi  = 0.0 1.0 0.0

corresponds to the boundary condition for temperature. See the specific integrator for details.

BC::Constant

src/BC/Constant.cpp src/BC/Constant.H

This is the most commonly used standard boundary condition implementation. The name “Constant” refers to the invariance of the BC value or character along each face of the simulation domain; however, you may cause a change in the value with time by using a Numeric::Interpolator::Linear string.

The BC on each face is specified with a type string that specifies the nature of the BC, and a val that specifies the value. By default, all types are Dirichlet and all values are 0.0. The complete list of BC types are below:

Dirichlet boundary condition types can be specified with Dirichlet, dirichlet, EXT_DIR. Neumann boundary condition types are specified with Neumann, neumann. Periodic boundary conditions can be specified with Periodic, periodic, INT_DIR. Important: Ensure that your geometry is specified to be periodic using geometry.is_periodic. For instance, if periodic in x, set to 1 0 0

The BC values can be specified either as a number (e.g. 1.0) or using a linear interpolator string (e.g. (0,1:2.3,-0.1)).

The number of values and types must be either 0 (for defaults), 1 (to set the same for all field components) or N (where N=number of field components).

Parameter	Type	Values
type.xlo	BC type on the lower x edge (2d) face (3d)	{"dirichlet"}
type.xhi	BC type on the upper x edge (2d) face (3d)	{"dirichlet"}
type.ylo	BC type on the lower y edge (2d) face (3d)	{"dirichlet"}
type.yhi	BC type on the upper y edge (2d) face (3d)	{"dirichlet"}
type.zlo	BC type on the lower z face (processed but ignored in 2d to prevent unused input errors)	{"dirichlet"}
type.zhi	BC type on the upper z face (processed but ignored in 2d to prevent unused input errors)	{"dirichlet"}
val.xlo	BC value on the lower x edge (2d) face (3d)	{"0.0"}
val.xhi	BC value on the upper x edge (2d) face (3d)	{"0.0"}
val.ylo	BC value on the lower y edge (2d) face (3d)	{"0.0"}
val.yhi	BC value on the upper y edge (2d) face (3d)	{"0.0"}
val.zlo	BC value on the lower z face (processed but ignored in 2d to prevent unused input errors)	{"0.0"}
val.zhi	BC value on the upper z face (processed but ignored in 2d to prevent unused input errors)	{"0.0"}

BC::Expression

src/BC/Expression.cpp src/BC/Expression.H

Boundary condition similar to BC::Constant, except that “values” are given as strings which are functions of x,y,z,t.

Parameter	Type	Values
type.xlo	BC type on the lower x edge (2d) face (3d)	{"dirichlet"}
type.xhi	BC type on the upper x edge (2d) face (3d)	{"dirichlet"}
type.ylo	BC type on the lower y edge (2d) face (3d)	{"dirichlet"}
type.yhi	BC type on the upper y edge (2d) face (3d)	{"dirichlet"}
type.zlo	BC type on the lower z face (processed but ignored in 2d to prevent unused input errors)	{"dirichlet"}
type.zhi	BC type on the upper z face (processed but ignored in 2d to prevent unused input errors)	{"dirichlet"}

BC::Nothing

src/BC/Nothing.H

Empty BC class, used when specifying boundaries that have no ghost cells/nodes but a BC object is still required.

BC::Operator

BC::Operator::Operator

src/BC/Operator/Operator.H

The BC::Operator family of BC classes are designed to work with implicit operators. They are not the same thing as other BC types and cannot be used in that same way. (This is not an ideal taxonomy for BC structures - we may transition other BC types to be subspaces of BC::Integrator.)

BC::Operator::Elastic

BC::Operator::Elastic::Elastic

src/BC/Operator/Elastic/Elastic.H

Class of BC operators that work with Operator::Elastic.

BC::Operator::Elastic::Constant

src/BC/Operator/Elastic/Constant.H

This BC defines boundary conditions that are constant with respect to space. However they may change in time using the Numeric::Interpolator::Linear method.

In 2D, BCs are prescribed for each edge (4) and corner (4) on the boundary, for a total of 8 possible regions. In 3D, BCs are prescribed for each face (6), each edge (12), and each corner (8), for a total of 26 possible regions. Care must be taken to define BCs for edges/corners consistently with the faces/edges, or you will get poor convergence and inaccurate behavior. (See BC::Operator::Elastic::TensionTest for a reduced BC with streamlined load options.)

To define a boundary condition, you must define both a “type” and a “value” in each direction. The type can be “displacement”, “disp”, “neumann”, “traction”, “trac”. The value is the corresponding value. All BCs are, by default, dirichlet (displacement) with a value of zero.

Parameter	Type	Values
type.xloylozlo	3D Corner
type.xloylozhi	3D Corner
type.xloyhizlo	3D Corner
type.xloyhizhi	3D Corner
type.xhiylozlo	3D Corner
type.xhiylozhi	3D Corner
type.xhiyhizlo	3D Corner
type.xhiyhizhi	3D Corner
type.ylozlo	3D Edge
type.ylozhi	3D Edge
type.yhizlo	3D Edge
type.yhizhi	3D Edge
type.zloxlo	3D Edge
type.zloxhi	3D Edge
type.zhixlo	3D Edge
type.zhixhi	3D Edge
type.xloylo	3D Edge / 2D Corner
type.xloyhi	3D Edge / 2D Corner
type.xhiylo	3D Edge / 2D Corner
type.xhiyhi	3D Edge / 2D Corner
type.xlo	3D Face / 2D Edge
type.xhi	3D Face / 2D Edge
type.ylo	3D Face / 2D Edge
type.yhi	3D Face / 2D Edge
type.zlo	3D Face
type.zhi	3D Face
val.xloylozlo	3D Corner
val.xloylozhi	3D Corner
val.xloyhizlo	3D Corner
val.xloyhizhi	3D Corner
val.xhiylozlo	3D Corner
val.xhiylozhi	3D Corner
val.xhiyhizlo	3D Corner
val.xhiyhizhi	3D Corner
val.ylozlo	3D Edge
val.ylozhi	3D Edge
val.yhizlo	3D Edge
val.yhizhi	3D Edge
val.zloxlo	3D Edge
val.zloxhi	3D Edge
val.zhixlo	3D Edge
val.zhixhi	3D Edge
val.xloylo	3D Edge / 2D Corner
val.xloyhi	3D Edge / 2D Corner
val.xhiylo	3D Edge / 2D Corner
val.xhiyhi	3D Edge / 2D Corner
val.xlo	3D Face / 2D Edge
val.xhi	3D Face / 2D Edge
val.ylo	3D Face / 2D Edge
val.yhi	3D Face / 2D Edge
val.zlo	3D Face
val.zhi	3D Face

BC::Operator::Elastic::Expression

src/BC/Operator/Elastic/Expression.H

Use expressions to define space and time varying boundary conditions for elastic problems.

Parameter	Type	Values
type.xlo	3D Face / 2D Edge type	{"disp"}
val.xlo	3D Face / 2D Edge value	{"0.0"}
type.xhi	3D Face / 2D Edge type	{"disp"}
val.xhi	3D Face / 2D Edge value	{"0.0"}
type.ylo	3D Face / 2D Edge type	{"disp"}
val.ylo	3D Face / 2D Edge value	{"0.0"}
type.yhi	3D Face / 2D Edge type	{"disp"}
val.yhi	3D Face / 2D Edge value	{"0.0"}
type.zlo	3D Face type	{"disp"}
val.zlo	3D Face value	{"0.0"}
type.zhi	3D Face type	{"disp"}
val.zhi	3D Face value	{"0.0"}
type.xloylo	3D Edge / 2D Corner type	{"disp"}
val.xloylo	3D Edge / 2D Corner value	{"0.0"}
type.xloyhi	3D Edge / 2D Corner type	{"disp"}
val.xloyhi	3D Edge / 2D Corner value	{"0.0"}
type.xhiylo	3D Edge / 2D Corner type	{"disp"}
val.xhiylo	3D Edge / 2D Corner value	{"0.0"}
type.xhiyhi	3D Edge / 2D Corner type	{"disp"}
val.xhiyhi	3D Edge / 2D Corner value	{"0.0"}
type.xloylozlo	3D Corner type	{"disp"}
val.xloylozlo	3D Corner value	{"0.0"}
type.xloylozhi	3D Corner type	{"disp"}
val.xloylozhi	3D Corner value	{"0.0"}
type.xloyhizlo	3D Corner type	{"disp"}
val.xloyhizlo	3D Corner value	{"0.0"}
type.xloyhizhi	3D Corner type	{"disp"}
val.xloyhizhi	3D Corner value	{"0.0"}
type.xhiylozlo	3D Corner type	{"disp"}
val.xhiylozlo	3D Corner value	{"0.0"}
type.xhiylozhi	3D Corner type	{"disp"}
val.xhiylozhi	3D Corner value	{"0.0"}
type.xhiyhizlo	3D Corner type	{"disp"}
val.xhiyhizlo	3D Corner value	{"0.0"}
type.xhiyhizhi	3D Corner type	{"disp"}
val.xhiyhizhi	3D Corner value	{"0.0"}
type.ylozlo	3D Edge type	{"disp"}
val.ylozlo	3D Edge value	{"0.0"}
type.ylozhi	3D Edge type	{"disp"}
val.ylozhi	3D Edge value	{"0.0"}
type.yhizlo	3D Edge type	{"disp"}
val.yhizlo	3D Edge value	{"0.0"}
type.yhizhi	3D Edge type	{"disp"}
val.yhizhi	3D Edge value	{"0.0"}
type.zloxlo	3D Edge type	{"disp"}
val.zloxlo	3D Edge value	{"0.0"}
type.zloxhi	3D Edge type	{"disp"}
val.zloxhi	3D Edge value	{"0.0"}
type.zhixlo	3D Edge type	{"disp"}
val.zhixlo	3D Edge value	{"0.0"}
type.zhixhi	3D Edge type	{"disp"}
val.zhixhi	3D Edge value	{"0.0"}

BC::Operator::Elastic::TensionTest

src/BC/Operator/Elastic/TensionTest.H

A boundary condition for mechanics operators that simplifies frequently-used conditions for uniaxial loading.

Types include:

uniaxial_stress_clamp: fixes both ends and allows for stress concentrations at the corners.
uniaxial_kolsky
uniaxial_stress: 1D stress problem
uniaxial_strain: 1D strain problem

Parameter	Type	Values
type	Tension test type.	uniaxial_stress_clamp uniaxial_kolsky uniaxial_stress uniaxial_strain
disp	Applied displacement (can be interpolator)
trac	Applied traction (can be interpolator)

IC

IC::IC

src/IC/IC.H

Initial condition (IC) objects are used to set fields to specified values, through mathematical expressions, images, etc. They are often used as initial conditions, but may be used generally to incorporate static or time-dependent values. All IC methods inherit from the base IC class, and are implemented by overriding the “Add” method. (Initialize uses Add after setting the field to zero.)

IC::BMP

src/IC/BMP.H

Initialize a field using a bitmap image. (2D only)

Note that in GIMP, you must select “do not write color space information” and “24 bit R8 G8 B8” when exporting the BMP file.

Parameter	Type	Values
filename	BMP filename.	file path
fit	How to position image in space	stretch fitheight fitwidth coord
coord.lo	Location of lower-left corner in the domain
coord.hi	Location of upper-right corner in the domain
channel	Color channel to use	r g b R G B
min	Scaling value - minimum	0.0
max	Scaling value - maximum	255.0

IC::Constant

src/IC/Constant.H

Basic IC that just sets the entire field to a constant value. Works with a single or multiple-component field.

Parameter	Type	Values
value	Value (or values if multicomponent) to set field to	required

IC::Ellipsoid

src/IC/Ellipsoid.H

This IC initializes a single-component fab using the formula

\[\begin{split}\phi = \begin{cases} \alpha_{in} & (\mathbf{x}-\mathbf{x}_0)^T\mathbf{A}(\mathbf{x}-\mathbf{x}_0) \le r \\ \alpha_{out} & \text{else} \end{cases}\end{split}\]

The boundary can be mollified using an error function with parameter $\varepsilon$

Warning

This IC is redundant with IC::Ellipse and IC::Expression and will probably be consolidated

Parameter	Type	Values
center	Center of the ellipse $\mathbf{x}_0$
A	Matrix defining elipse radii and orientation
radius	"Vector of radii (use instead of A)"
eps	Mollifying value for erf
in_value	Value of field inside ellipse	0.0
out_value	Value of field outside ellipse	1.0
mollifier	Type of mollifier to use (options: dirac, [gaussian])

IC::Ellipse

src/IC/Ellipse.H

If number_of_inclusions is specified, then multiple ellipses are specified. In this case, each parameter must have number_of_inclusion*M values, where M is the number of values specified for the single ellipse case.

Parameter	Type	Values
x0	Coorinates of ellipse center
eps	Diffuse boundary thickness	0.0
A	DxD square matrix defining an ellipse.
a	If `A` is not defined, then assume a sphere with radius `a`
number_of_inclusions	Number of ellipses
center	center of the ellipse
x0	center of the ellipse
A	either a vector containing ellipse radii, or a matrix defining the ellipse
A	Same
radius	Array of radii [depricated]
eps	Regularization for smooth boundary
invert	Flip the inside and the outside

IC::Expression

src/IC/Expression.H

Initialize a field using a mathematical expression. Expressions are imported as strings and are compiled real-time using the AMReX Parser.

Works for single or multiple-component fields. Use the regionN (N=0,1,2, etc. up to number of components) to pass expression. For example:

ic.region0 = "sin(x*y*z)"
ic.region1 = "3.0*(x > 0.5 and y > 0.5)"

for a two-component field. It is up to you to make sure your expressions are parsed correctly; otherwise you will get undefined behavior.

Constants You can add constants to your expressions using the constant directive. For instance, in the following code

psi.ic.type=expression
psi.ic.expression.constant.eps = 0.05
psi.ic.expression.constant.R   = 0.25
psi.ic.expression.region0 = "0.5 + 0.5*tanh((x^2 + y^2 - R)/eps)"

the constants eps and R are defined by the user and then used in the subsequent expression. The variables can have any name made up of characters that is not reserved. However, if multiple ICs are used, they must be defined each time for each IC.

Parameter	Type	Values
coord	coordinate system to use	cartesian polar
unit	Units of the value that is returned by the expression	""

IC::Laminate

src/IC/Laminate.H

Create a single laminate with specified orientation, thickness, and offset.

Parameter	Type	Values
number_of_inclusions	How many laminates (MUST be greater than or equal to 1).	1
center	(x,y,[z]) values for the center point of the laminate
thickness	thickness of the laminate
orientation	Vector normal to the interface of the laminate
eps	Diffuse thickness
mollifier	Type of mollifer to use (options: dirac, [gaussian])	dirac gaussian
singlefab	Switch to mode where only one component is used.
invert	Take the complement of the laminate

IC::Notch

src/IC/Notch.H

Create a simple notch in an otherwise uniformly filled region. (This was created for, and mostly used for, Mode II fracture tests.)

This is an old IC that should be replaced by IC::Expression

Parameter	Type	Values
center	Center of notch
orientation	Vector describing notch orientation
thickness	Thickness of notch
length	Length of notch
radius	Radius of notch ends
eps	Magnitude of mollifier
mollifier	What kind of smoother to use {dirac,gauss,erf,cos}

IC::PSRead

src/IC/PSRead.H

Fill a domain (region where field=0) with packed spheres (regions where field=1). Sphere locations and radii are determined from an xyzr file.

Parameter	Type	Values
eps	Diffuseness of the sphere boundary
filename	Location of .xyzr file	file path
verbose	Verbosity (used in parser only)
mult	Coordinate multiplier
invert	Coordinate multiplier
x0	Coordinate offset

IC::PerturbedInterface

src/IC/PerturbedInterface.H

Initialize a perturbed interface using Fourier Modes

Notes: 1. todo Extend this class to allow for 3D perturbations, currently only 2D are allowed 2. todo Allow for cosine (or complex exponential) expansions rather than just sin. 3. note This is a two grain only initial condition. 4. note This replaces the depricated “perturbed_bar” initial condition from previous versions

The interface is defined as the $x=0$ plane (2D), or the $x=0,z=0$ plane (3D). The equation for the interface is given by $y(x,z) = \sum_{n\in \{n_1,\ldots,n_N\}} A_n \sin(n\pi x/L_x)$ where $A_n$ are the amplitudes (stored in #wave_amplitudes), $n_1,\ldots,n_N\subset\mathbb{Z}_+$ are wave numbers (stored in #wave_numbers), and $L_x$ is the length in the x direction (obtained using the #geom object).

Grain 1 is defined as being above $y(x,z)$, Grain 2 is defined as being below.

Parameter	Type	Values
wave_numbers	Wave numbers
wave_amplitudes	Wave amplitudes
normal	Which axis is normal to the interface (x,y,z)
offset	Interface offset from origin
reverse	If true, flip the interface (default:false)
mollifier	Mollifier (options: dirac, [gaussian])
eps	Magnitude of mollifier

IC::PNG

src/IC/PNG.H

Initialize a field using a PNG image. (2D only)

Parameter	Type	Values
channel	Color channel to use (options: r, R, g, G, b, B, a, A)	r g b a R G B A

IC::Random

src/IC/Random.H

Set each point in the field to a random value between 0 and 1

Parameter	Type	Values
offset	offset from the [0,1] random number range	0.0
mult	multiplier for the [0,1] random number range	1.0

IC::Sphere

src/IC/Sphere.H

Initialize a sphere region in which the field (eta=1). Can be a 3D sphere (xyz) or oriented around any of the three axes.

This functionality is replaced by IC::Expression.

Parameter	Type	Values
radius	Radius of the sphere	"1.0"
center	Vector location of the sphere center
inside	Value of the field inside the sphere	"1.0"
outside	Value of the field outside teh sphere	"0.0"
type	Type - can be cylinder oriented along the x, y, z directions or full sphere.	xyz yz zx xy

IC::Trig2

src/IC/Trig2.H

This is an old IC that exist only to support some of the old operator tests. IC::Expression should be used instead. .. dropdown:: API definitions in src/IC/Trig2.H

Classes

IC::Trig2 - Initialize using a trigonometric series.

Methods

Trig2(amrex::Vector< amrex::Geometry > &_geom, Set::Scalar _alpha=1.0, AMREX_D_DECL(Set::Scalar _theta1=0, Set::Scalar _theta2=0, Set::Scalar _theta3=0), AMREX_D_DECL(int _n1=0, int _n2=0, int _n3=0), int _dim=AMREX_SPACEDIM)

Define(Set::Scalar _alpha=1.0, AMREX_D_DECL(Set::Scalar _theta1=0, Set::Scalar _theta2=0, Set::Scalar _theta3=0), AMREX_D_DECL(int _n1=0, int _n2=0, int _n3=0), int _dim=AMREX_SPACEDIM)

Add(const int &lev, Set::Field< Set::Scalar > &field, Set::Scalar)

AMREX_D_DECL(n1, n2, n3)

AMREX_D_DECL(theta1, theta2, theta3)

Variables

int IC::Trig2::dim

Set::Scalar IC::Trig2::alpha

IC::Trig

src/IC/Trig.H

This is an old-fashioned IC. It is kept because it is still used with the Trig regression test, but it is recommended to use IC::Expression instead.

Parameter	Type	Values
nr	Number of real (cosin) waves
ni	Number of imaginary (sin) waves
dim	Spatial dimension
alpha	Multiplier

IC::TabulatedInterface

src/IC/TabulatedInterface.H

Initialize a 2D interface in a 2 component field defind by (x,y) which are an array of points along the interface.

Parameter	Type	Values
xs	x location of points
ys	y location of points

IC::Voronoi

src/IC/Voronoi.H

Initialize an N component field with a Voronoi tessellation. (Mostly used by Integrator::PhaseFieldMicrostructure).

Parameter	Type	Values
number_of_grains	Number of grains
alpha	Value to take in the region [1.0]
seed	Random seed to use

IO

IO::FileNameParse

src/IO/FileNameParse.cpp src/IO/FileNameParse.H

This manages the processing of the plot_file input, which defines the output file. Both variable substitution and time wildcards are supported.

Variable substitution: you can use braces to substitute variable names in the input file. For example, if your input file contains myinput.value = 3, then you can specify plot_file = output_{myinput.value} to substitute the input’s value.

Time and dimension wildcards: You can use the following strings:

%Y: 4-digit year
%m: 2-digit month (01-12)
%d: 2-digit day (00-31)
%H: 2 digit hour (00-23)
%M: 2 digit minute (00-59)
%S: 2 digit second (00-59)
%f: 2 digit microsecond (00-59)
%D: spatial dimension

So a plot_file = output_%Y%m%d_%H%M%S may resolve to output_20250307_211201 (etc) depending on the time the output was created. .. dropdown:: API definitions in src/IO/FileNameParse.H

Classes

IO::ParmParse

src/IO/ParmParse.cpp src/IO/ParmParse.H

This is a thin wrapper to the amrex::ParmParse class This class exists to add some additional parsing capability, e.g. parsing Set::Matrix and Set::Vector data types.

IO::ParmParse uses static Parse() functions to perform cascading class-based input parsing. See the Autodoc and Autotest section for instructions on adding documentation.

This is standard infrastructure code; make sure you know what you ard doing before you change it.

Query directives

Alamo uses different query directives to standardize reading inputs and automatic documentation. The type of query that is used (query vs query_required, etc) triggers different handlers and different automatic documentation procedures. For instance, the use of a query_default causes a default value to be set and added to the metadata file, and it also serves as a flag for the autodoc system to document that a default value is available. The following table is a reference for the different kinds of query directives.

BC Type	Description
query	Standard IO for bool, string, Set::Scalarthat does not enforce defaults or required values. Not recommended for general use.
query_required	Similar to query, but will abort if no value is specified. Required values are indicated by required.
query_default	Similar to query, but will fill with default value if no value is provided. Will also add default value to metadata. Default values are indicated by green badge values, e.g. 0.0.
query_validate	For strings, read in a value and enforce that the value is one of a supplied number of values. Optionally make required, or set the default value to the first supplied value. Acceptable options are indicated by blue badge values, e.g. 1.0, 2.0. If a default value is available, it is indicated by a green badge, e.g. 1.0.
query_file	Read in a string that defines a file name. Check to make sure that the file exists and is a regular file, and print an informative error message if not (this can be disabled). Also, copy the file to the output directory, with the full path preserved by replacing / with _. (This can also be disabled, but doing so is discouraged.) Default values are not allowed. File paths are indicated by file path.
queryarr	Read in an array of numbers into either a standard vector or into a `Set::Vector` or `Set::Scalar`. No defaults or existence checking is performed.
queryclass	Read a class object with a specified prefix. How that class is read in is determined by its `Parse` function.

Query macros

A set of preprocessor macros are defined so that you can call a query function using pp_ instead of pp.. For instance, the following two can be used interchangeably:

pp.query_required("myvar",myvar); /* function version */
pp_query_required("myvar",myvar); /* preprocessor macro version - preferred*/

Using the preprocessor macros enables code location information to be passed to the parser, so that more informative error messages will be printed out. Note that the ParmParse object must always be called pp for this to work.

API definitions in src/IO/ParmParse.H

Classes

IO::ParmParse

Methods
- Define()
- static_polymorphism_parser(CLASS &value)
- ParmParse(std::string arg)
- ParmParse()
- getPrefix() const
- ignore(std::string name)
- pushPrefix(const std::string prefix)
- popPrefix()
- forbid(std::string name, std::string explanation)
- contains(std::string name)
- queryunit(std::string name, Unit &value)
- queryunit(std::string name, Unit &value, const Unit type)
- queryunit(std::string name, Set::Scalar &value, const Unit type)
- query_required(std::string name, T &value)
- query_required(std::string name, T &value, const Unit type)
- query_default(std::string name, T &value, T defaultvalue)
- query_default(std::string name, T &value, std::string defaultvalue, const Unit type)
- query_validate(std::string name, int &value, std::vector< int > possibleintvals)
- query_validate(std::string name, std::string &value, std::vector< const char * > possiblecharvals, bool firstbydefault)
- query_validate(std::string name, std::string &value, std::vector< const char * > possiblecharvals)
- query_default(std::string name, std::string &value, const char *defaultvalue)
- query_default(std::string name, int &value, bool defaultvalue)
- query_file(std::string name, std::string &value, bool copyfile, bool checkfile)
- query_file(std::string name, std::string &value, bool copyfile)
- query_file(std::string name, std::string &value)
- queryarr(std::string name, std::vector< T > &value)
- queryarr(std::string name, std::vector< Set::Scalar > &value, Unit unit=Unit::Less())
- queryarr(std::string name, Set::Vector &value, Unit unit=Unit::Less())
- queryarr(std::string name, Set::Matrix &value, Unit unit=Unit::Less())
- queryarr_required(std::string name, std::vector< T > &value)
- queryarr_required(std::string name, std::vector< Set::Scalar > &value, Unit unit=Unit::Less())
- queryarr_default(std::string name, std::vector< std::string > &value, std::vector< std::string > defaultvalue)
- queryarr_default(std::string name, Set::Vector &value, Set::Vector defaultvalue)
- queryarr_default(std::string name, Set::Matrix &value, Set::Matrix defaultvalue)
- queryarr_default(std::string name, std::vector< double > &value, std::vector< double > defaultvalue)
- queryarr_default(std::string name, std::vector< double > &value, std::vector< std::string > defaultvalue, Unit unit)
- queryclass_enumerate(std::string a_name, std::vector< T > &value, int number=1)
- query_enumerate(std::string a_name, std::vector< T > &value, int number=1)
- AnyUnusedInputs(bool inscopeonly=true, bool verbose=false)
- GetUnusedInputs()
- prefix()
- full(std::string name)
- queryclass(std::string name, T *value)
- queryclass(std::string name, T &value)
- queryclass(T *value)
- queryclass(T &value)
- select(std::string name, PTRTYPE *&ic_eta, Args &&... args)
- select_default(std::string name, PTRTYPE *&ic_eta, Args &&... args)
- select_enumerate(std::string a_name, std::vector< PTRTYPE * > &value, Args &&... args)
- select_main(PTRTYPE *&ic_eta, Args &&... args)
- select_only(PTRTYPE *&ic_eta, Args &&args)
- select_only(PTRTYPE *&ic_eta)
- select(std::string name, CLASS &value)
- query_exactly(std::vector< std::string > names, std::pair< std::string, Set::Scalar > values[N], std::vector< Unit > units=std::vector< Unit >())

IO::WriteMetaData

src/IO/WriteMetaData.cpp src/IO/WriteMetaData.H

This provide an IO routine for generating run-specific output. Every Alamo run produces a metadata file and (if applicable) a diff.patch file that reflects the exact state when the simulation was run. Note that the file WriteMetaData.cpp file is _always_ recompiled upon make, in order to pull the latest information about the local state at build.

This is standard infrastructure code; make sure you know what you ard doing before you change it.

Integrator

Integrator::Integrator

src/Integrator/Integrator.cpp src/Integrator/Integrator.H

Pure abstract class for managing data structures, time integration (with substepping), mesh refinement, and I/O.

Native input file parameters:

max_step  = [maximum number of timesteps]
stop_time = [maximum simulation time]
timestep  = [time step for coarsest level]

amr.regrid_int = [number of timesteps between regridding]
amr.plot_int   = [number of timesteps between dumping output]
amr.plot_file  = [base name of output directory]

amr.nsubsteps  = [number of temporal substeps at each level. This can be
                  either a single int (which is then applied to every refinement
                  level) or an array of ints (equal to amr.max_level)
                  corresponding to the refinement for each level.]

Inherited input file parameters (from amrex AmrMesh class):

amr.v                  = [verbosity level]
amr.max_level          = [maximum level of refinement]
amr.n_proper           =
amr.grid_eff           =
amr.n_error_buff       =
amr.ref_ratio_vect     = [refinement ratios in each direction]
amr.ref_ratio          = [refinement ratio in all directions (cannot be used with ref_ratio_vect)]
amr.max_grid_x         =
amr.blocking_factor    =
amr.n_cell             = [number of cells on coarsest level]
amr.refine_grid_layout =
amr.check_input        =

Parameter	Type	Values
max_step	Number of iterations before ending (default is maximum possible int)	2147483647
stop_time	Simulation time before ending	required
timestep	Nominal timestep on amrlev = 0	required
restart	Name of restart file to READ from
restart_cell	Name of cell-fab restart file to read from
restart_node	Name of node-fab restart file to read from
ignore	Space-separated list of entries to ignore
regrid_int	Regridding interval in step numbers	2
base_regrid_int	Regridding interval based on coarse level only	0
plot_int	Interval (in timesteps) between plotfiles (Default negative value will cause the plot interval to be ignored.)	-1
plot_dt	Interval (in simulation time) between plotfiles (Default negative value will cause the plot dt to be ignored.)	"-1.0"
plot_file	Output file: see IO::FileNameParse for wildcards and variable substitution	"output"
cell.all	Turn on to write all output in cell fabs (default: off)	false
cell.any	Turn off to prevent any cell based output (default: on)	true
node.all	Turn on to write all output in node fabs (default: off)	false
node.any	Turn off to prevent any node based output (default: on)	true
abort_on_nan	Abort if a plotfile contains nan or inf.	true
max_plot_level	Specify a maximum level of refinement for output files (NO REFINEMENT)	-1
nsubsteps	Number of substeps to take on each level (default: 2)
nsubsteps	Number of substeps to take on each level (set all levels to this value)	required
on	activate dynamic CFL-based timestep
verbose	how much information to print	0 1
nprevious	number of previous timesteps for rolling average	5
cfl	dynamic teimstep CFL condition	1.0
min	minimum timestep size allowed shen stepping dynamically	timestep
max	maximum timestep size allowed shen stepping dynamically	timestep
int	Integration interval (1)	1
plot_int	Interval (in timesteps) between writing (Default negative value will cause the plot interval to be ignored.)	-1
plot_dt	Interval (in simulation time) between writing (Default negative value will cause the plot dt to be ignored.)	"-1.0"
on	Use explicit mesh instead of AMR	0

API definitions in src/Integrator/Integrator.H

Classes

Integrator::Integrator

Methods
- Integrator() - This is the constructor for the intetgrator class, which reads timestep information, simulation output and AMR, initialized time substep, and creates a new directory.
- ~Integrator() - Virtual destructure; make sure delete any pointers that you create here.
- InitData() - Front-end method to initialize simulation on all levels.
- Restart(std::string restartfile, bool a_node=false) - Read in output from previous simulation and start simulation at that point - Not currently tested.
- Evolve() - Front-end method to start simulation.
- SetFilename(std::string _plot_file) - Simple setter to set filename.
- GetFilename() - Simple getter to get filename.
- regrid(int lbase, Set::Scalar time, bool initial=false) override - This overrides an AMReX method just to allow for explicit meshing when desired.
- InitFromScratch(Set::Scalar time) - This creates a new levels that have not previously been used.
- AddField(Set::Field< T > &new_field, BC::BC< T > *new_bc, int ncomp, int nghost, std::string name, bool writeout, bool evolving, std::vector< std::string >)
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, bool evolving)
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, std::string a_name, bool evolving)
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, bool writeout, std::string a_name, bool evolving)
- Initialize(int lev)=0 - You must override this function to inherit this class; this function is called before the simulation begins, and is where initial conditions should be applied.
- Advance(int lev, amrex::Real time, amrex::Real dt)=0 - You must override this function to inherit this class; Advance is called every time(sub)step, and implements the evolution of the system in time.
- TagCellsForRefinement(int lev, amrex::TagBoxArray &tags, amrex::Real time, int ngrow)=0 - You must override this function to inherit this class; Advance is called every time(sub)step, and implements the evolution of the system in time.
- TimeStepBegin(Set::Scalar, int) - This optional function is called at the beginning of every timestep, and can be used to complete additional global solves, e.g.
- TimeStepComplete(Set::Scalar, int) - This optional function is called at the end of every timestep, and can be used to complete additional global solves, e.g.
- Integrate(int, Set::Scalar, int, const amrex::MFIter &, const amrex::Box &) - This is a function that is called by to update the variables registered in RegisterIntegratedVariable; you can override this to do your integration.
- Regrid(int, Set::Scalar) - An optionally overridable method to trigger behavior whenver a regrid occurs.
- RegisterNewFab(Set::Field< Set::Scalar > &new_fab, BC::BC< Set::Scalar > *new_bc, int ncomp, int nghost, std::string name, bool writeout, bool evolving=true, std::vector< std::string > suffix={}) - Add a new cell-based scalar field.
- RegisterNewFab(Set::Field< Set::Scalar > &new_fab, int ncomp, std::string name, bool writeout, bool evolving=true, std::vector< std::string > suffix={}) - Add a new cell-based scalar field (with additional arguments).
- RegisterNodalFab(Set::Field< Set::Scalar > &new_fab, int ncomp, int nghost, std::string name, bool writeout, bool evolving=true, std::vector< std::string > suffix={}) - Add a new node-based scalar field.
- RegisterNodalFab(Set::Field< Set::Scalar > &new_fab, BC::BC< Set::Scalar > *new_bc, int ncomp, int nghost, std::string name, bool writeout, bool evolving=true, std::vector< std::string > suffix={}) - Add a new node-based scalar field (wtih additional arguments)
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, bool evolving=true) - Add a templated nodal field.
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, std::string a_name, bool evolving=true) - Add a templated nodal field (additional arguments)
- RegisterGeneralFab(Set::Field< T > &new_fab, int ncomp, int nghost, bool writeout, std::string a_name, bool evolving=true) - Add a templated nodal field (additional arguments)
- AddField(Set::Field< T > &new_field, BC::BC< T > *new_bc, int ncomp, int nghost, std::string, bool writeout, bool evolving, std::vector< std::string > suffix={}) - Add a field with arbitrary type (templated with T) and grid location (templated with d).
- SetFinestLevel(const int a_finestlevel) - Utility to ensure that all fields know what the finest level is.
- RegisterIntegratedVariable(Set::Scalar *integrated_variable, std::string name, bool extensive=true) - Register a variable to be integrated over the spatial domain using the Integrate function.
- SetTimestep(Set::Scalar _timestep) - Utility to set the coarse-grid timestep.
- SetPlotInt(int plot_int) - Utility to set the frequency (in timesteps) of plotfile dumping.
- SetThermoInt(int a_thermo_int) - Utility to set the frequency (in timesteps) of thermo data calculation.
- SetThermoPlotInt(int a_thermo_plot_int) - Utility to set the frequency (in timesteps) of thermo data writing to file.
- SetStopTime(Set::Scalar a_stop_time) - Utility to set the global stop time.
- DynamicTimestep_SyncTimeStep(int lev, Set::Scalar dt_min) - Params for the dynamic timestp.
- DynamicTimestep_Reset()
- DynamicTimestep_Update()
- IntegrateVariables(Set::Scalar cur_time, int step)
- WritePlotFile(bool initial=false) const
- WritePlotFile(std::string prefix, Set::Scalar time, int step) const
- WritePlotFile(Set::Scalar time, amrex::Vector< int > iter, bool initial=false, std::string prefix="") const
- MakeNewLevelFromScratch(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override
- MakeNewLevelFromCoarse(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override - Wrapper to call FillCoarsePatch.
- RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override - RESETS ALL MULTIFABS AT A GIVEN LEVEL.
- ClearLevel(int lev) override
- ErrorEst(int lev, amrex::TagBoxArray &tags, amrex::Real time, int ngrow) override
- FillPatch(int lev, amrex::Real time, amrex::Vector< std::unique_ptr< amrex::MultiFab > > &source_mf, amrex::MultiFab &destination_multifab, BC::BC< Set::Scalar > &physbc, int icomp) - This is the function that is responsible for updating patch data.
- CountCells(int lev) - Simple utility to count cells.
- TimeStep(int lev, amrex::Real time, int iteration) - Timestep marching.
- FillCoarsePatch(int lev, amrex::Real time, Set::Field< Set::Scalar > &mf, BC::BC< Set::Scalar > &physbc, int icomp, int ncomp) - Fill a fab at current level with the data from one level up.
- GetData(const int lev, const amrex::Real time, amrex::Vector< amrex::MultiFab * > &data, amrex::Vector< amrex::Real > &datatime)
- PlotFileName(int lev, std::string prefix="") const
Variables
- bool Integrator::Integrator::on
- int Integrator::Integrator::verbose
- int Integrator::Integrator::nprevious
- Set::Scalar Integrator::Integrator::cfl
- Set::Scalar Integrator::Integrator::min
- Set::Scalar Integrator::Integrator::max
- std::vector<Set::Scalar> Integrator::Integrator::dt_limit_min
- std::vector<Set::Scalar> Integrator::Integrator::previous_timesteps
- int Integrator::Integrator::number_of_fabs
- std::vector<Set::Field<Set::Scalar>*> Integrator::Integrator::fab_array
- std::vector<int> Integrator::Integrator::ncomp_array
- std::vector<int> Integrator::Integrator::nghost_array
- std::vector<std::vector<std::string> > Integrator::Integrator::name_array
- std::vector<BC::BC<Set::Scalar>*> Integrator::Integrator::physbc_array
- std::vector<bool> Integrator::Integrator::writeout_array
- std::vector<bool> Integrator::Integrator::evolving_array
- bool Integrator::Integrator::any
- bool Integrator::Integrator::all
- int Integrator::Integrator::interval
- Set::Scalar Integrator::Integrator::dt
- int Integrator::Integrator::plot_int - How frequently to dump plot file (default: never)
- Set::Scalar Integrator::Integrator::plot_dt
- int Integrator::Integrator::number
- std::vector<Set::Scalar*> Integrator::Integrator::vars
- std::vector<std::string> Integrator::Integrator::names
- std::vector<bool> Integrator::Integrator::extensives
- int Integrator::Integrator::on
- std::vector<amrex::Box> Integrator::Integrator::box
- struct Integrator::Integrator Integrator::Integrator::dynamictimestep
- amrex::Vector<amrex::Real> Integrator::Integrator::t_new - Keep track of current old simulation time on each level.
- amrex::Vector<int> Integrator::Integrator::istep - Keep track of where each level is.
- std::string Integrator::Integrator::plot_file - Plotfile name.
- amrex::Real Integrator::Integrator::timestep - Timestep for the base level of refinement.
- amrex::Vector<amrex::Real> Integrator::Integrator::dt - Timesteps for each level of refinement.
- amrex::Vector<int> Integrator::Integrator::nsubsteps - how many substeps on each level?
- bool Integrator::Integrator::integrate_variables_before_advance
- bool Integrator::Integrator::integrate_variables_after_advance
- struct Integrator::Integrator Integrator::Integrator::node
- struct Integrator::Integrator Integrator::Integrator::cell
- std::vector<BaseField*> Integrator::Integrator::m_basefields
- std::vector<BaseField*> Integrator::Integrator::m_basefields_cell
- BC::Nothing Integrator::Integrator::bcnothing
- struct Integrator::Integrator Integrator::Integrator::thermo
- int Integrator::Integrator::regrid_int - Determine how often to regrid (default: 2)
- int Integrator::Integrator::base_regrid_int - Determine how often to regrid based on coarse level only (default: 0)
- std::string Integrator::Integrator::restart_file_cell
- std::string Integrator::Integrator::restart_file_node
- struct Integrator::Integrator Integrator::Integrator::explicitmesh
- int Integrator::Integrator::abort_on_nan
- int Integrator::Integrator::max_plot_level
- amrex::Vector<amrex::Real> Integrator::Integrator::t_old - Keep track of current old simulation time on each level.
- int Integrator::Integrator::max_step - Maximum allowable timestep.
- amrex::Real Integrator::Integrator::tstart - Default start time (default: 0)
- amrex::Real Integrator::Integrator::stop_time - Default stop time.

Integrator::AllenCahn

src/Integrator/AllenCahn.H

This is a simple implementation of an Allen-Cahn equation governed by

\[\frac{\partial\alpha}{\partial t} = - L \Big(\frac{\lambda}{\epsilon}(2.0\alpha - 6\alpha^2 + 4\alpha^3) + \epsilon\,\kappa\,\Delta \alpha \Big)\]

where $\alpha(x,t)$ is the order parameter.

Parameter	Type	Values
refinement_threshold	Criterion for mesh refinement [0.01]	0.01
ch.chempot	Value for $\lambda$ (Chemical potential coefficient)	"1.0"
ch.direction	Force directional growth: 0=no growth, 1=only positive, -1=only negative	0 1 -1
ch.direction_tstart	Time to start forcing directional growth	0.0
alpha.ic.type	Set the initial condition for the alpha field	sphere constant expression bmp png random psread
alpha.bc.type	Use a constant BC object for temperature value.bc = new BC::Constant(1); :ref:`BC::Constant` parameters	constant

Integrator::BaseField

src/Integrator/BaseField.H

API definitions in src/Integrator/BaseField.H

Classes

Integrator::BaseField

Methods
- ~BaseField()=default
- RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm)=0
- MakeNewLevelFromCoarse(int lev, amrex::Real time, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm)=0
- MakeNewLevelFromScratch(int lev, amrex::Real t, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm)=0
- SetFinestLevel(const int a_finestlevel)=0
- FillPatch(const int lev, const Set::Scalar time)=0
- FillBoundary(const int lev, Set::Scalar time)=0
- AverageDown(const int lev, amrex::IntVect refRatio)=0
- NComp()=0
- Copy(int, amrex::MultiFab &, int, int)=0
- Name(int)=0
- setName(std::string a_name)=0
- setBC(void *a_bc)=0
- getBC()=0
Variables
- bool Integrator::BaseField::writeout
- bool Integrator::BaseField::evolving
- Set::Hypercube Integrator::BaseField::m_gridtype
Integrator::Field

Methods
- Field(Set::Field< T > &a_field, const amrex::Vector< amrex::Geometry > &a_geom, const amrex::Vector< amrex::IntVect > &a_refRatio, int a_ncomp, int a_nghost)
- FillPatch(int lev, amrex::Real time, amrex::Vector< std::unique_ptr< amrex::FabArray< amrex::BaseFab< T > > > > &source_mf, amrex::FabArray< amrex::BaseFab< T > > &destination_mf, int icomp)
- FillPatch(int lev, amrex::Real time) override
- FillCoarsePatch(int lev, amrex::Real time, int icomp, int ncomp)
- RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm) override
- MakeNewLevelFromCoarse(int lev, amrex::Real time, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm) override
- MakeNewLevelFromScratch(int lev, amrex::Real, const amrex::BoxArray &cgrids, const amrex::DistributionMapping &dm) override
- SetFinestLevel(const int a_finestlevel) override
- FillBoundary(const int lev, Set::Scalar time) override
- AverageDown(const int lev, amrex::IntVect refRatio) override
- NComp() override
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) override
- setName(std::string a_name) override
- Name(int i) override
- setBC(void *a_bc) override
- getBC() override
Variables
- Set::Field<T>& Integrator::Field< T >::m_field
- const amrex::Vector<amrex::Geometry>& Integrator::Field< T >::m_geom
- const amrex::Vector<amrex::IntVect>& Integrator::Field< T >::m_refRatio
- const int Integrator::Field< T >::m_ncomp
- const int Integrator::Field< T >::m_nghost
- BC::BC<T>* Integrator::Field< T >::m_bc
- Numeric::Interpolator::NodeBilinear<T> Integrator::Field< T >::node_bilinear
Integrator::Field::EmptyBC

Methods
- operator()(amrex::FabArray< amrex::BaseFab< T > > &, int, int, amrex::IntVect const &, amrex::Real, int)
- GetBCRec()

Integrator::CahnHilliard

src/Integrator/CahnHilliard.cpp src/Integrator/CahnHilliard.H

This implements a basic two-phase field model with Cahn-Hilliard kinetics.

The free energy is

\[F[\eta] = \int_\Omega \Big[\frac{1}{4}(\eta^2 - 1)^2 + \frac{1}{2}\gamma |\nabla\eta|^2\Big] d\mathbf{x}\]

The corresponding governing equation under conservative kinetics is

\[\frac{\partial\eta}{\partial t} = L\nabla^2\Big(\eta^3 - \eta - \gamma\nabla^2\eta\Big)\]

which is integrated using a forward Euler scheme.

This is tested in CahnHilliard

Parameter	Type	Values
gamma	Interface energy	0.0005
L	Mobility	1.0
refinement_threshold	Regridding criterion	1E100
eta.ic.type	initial condition for $\eta$	random
eta.bc.type	boundary condition for $\eta$	constant
method	Which method to use - realspace or spectral method.	realspace spectral

Integrator::Dendrite

src/Integrator/Dendrite.H

This is a BASIC phase field method for dendritic growth as described in “A Numerical Approach to Three-Dimensional Dendritic Solidification” by Ryo Kobayashi (1994) Reference: https://doi.org/10.1080/10586458.1994.10504577

Parameter	Type	Values
alpha	Pre-multiplier of "m" barrier height	required
delta	Anisotropy factor	required
gamma	Anisotropic temperature coupling factor	required
diffusion	Thermal constant	1.0
eps	Diffuse boundary width	required
tau	Diffusive timescale	required
theta	Orientation about z axis (Deg)	0.0
heat.refinement_threshold	Refinement criteria for temperature	0.01
phi.refinement_threshold	Refinement criteria for phi	0.01
bc.temp.type	boundary conditions for temperature field	constant
bc.phi.type	boundary conditions for $\phi$ field	constant

Integrator::Flame

src/Integrator/Flame.cpp src/Integrator/Flame.H

Parameter	Type	Values
plot_field	Whether to include extra fields (such as mdot, etc) in the plot output	true
pf.eps	Burn width thickness	"1.0_m"
pf.w1	Unburned rest energy	"0.0"
pf.w12	Barrier energy	"0.0"
pf.w0	Burned rest energy	"0.0"
pf.eta.bc.type	Boundary conditions for phase field order params	constant
pf.eta.ic.type	phase field initial condition	laminate constant expression bmp png
propellant.type	Select reduced order model to capture heat feedback	powerlaw fullfeedback homogenize
thermal.on	Whether to use the Thermal Transport Model	false
thermal.Tref	Reference temperature Used to set all other reference temperatures by default.	"300.0_K"
thermal.Tfluid	Effective fluid temperature	value.thermal.Tref
thermal.temp.bc.type	Temperature boundary condition	constant
laser.ic.type	laser initial condition	constant expression
temp.ic.type	thermal initial condition	constant expression bmp png
chamber.pressure	Constant pressure value	"1.0_MPa"
variable_pressure	Whether to compute the pressure evolution	false
amr.refinement_criterion	Refinement criterion for eta field	"0.001"
amr.refinement_criterion_temp	Refinement criterion for temperature field	"0.001_K"
amr.refinament_restriction	Eta value to restrict the refinament for the temperature field	"0.1"
amr.phi_refinement_criterion	Refinement criterion for phi field [infinity]	1.0e100
small	Minimum allowable threshold for $\eta$	1.0e-8
phi.ic.type	Initial condition for $\phi$ field.	psread laminate expression constant bmp png
elastic.on	Whether to use Neo-hookean Elastic model	0
elastic.traction	Body force	0.0
elastic.phirefinement	Phi refinement criteria	1
Telastic	Reference temperature for thermal expansion (temperature at which the material is strain-free)	value.thermal.Tref
allow_unused	Set this to true to allow unused inputs without error. (Not recommended.)	false

API definitions in src/Integrator/Flame.H

Classes

Integrator::Flame

Methods
- Flame()
- Flame(IO::ParmParse &pp)
- ~Flame()
- Initialize(int lev) override
- TimeStepBegin(Set::Scalar a_time, int a_iter) override
- TimeStepComplete(Set::Scalar a_time, int a_iter) override
- Advance(int lev, Set::Scalar time, Set::Scalar dt) override
- TagCellsForRefinement(int lev, amrex::TagBoxArray &tags, amrex::Real, int) override
- Regrid(int lev, Set::Scalar time) override
- Integrate(int amrlev, Set::Scalar time, int step, const amrex::MFIter &mfi, const amrex::Box &box) override
- UpdateModel(int a_step, Set::Scalar a_time) override
Variables
- Set::Field<Set::Scalar> Integrator::Flame::temp_mf
- Set::Field<Set::Scalar> Integrator::Flame::temp_old_mf
- Set::Field<Set::Scalar> Integrator::Flame::temps_mf
- Set::Field<Set::Scalar> Integrator::Flame::eta_mf
- Set::Field<Set::Scalar> Integrator::Flame::eta_old_mf
- Set::Field<Set::Scalar> Integrator::Flame::mdot_mf
- Set::Field<Set::Scalar> Integrator::Flame::phi_mf
- Set::Field<Set::Scalar> Integrator::Flame::field
- Set::Field<Set::Scalar> Integrator::Flame::alpha_mf
- Set::Field<Set::Scalar> Integrator::Flame::heatflux_mf
- Set::Field<Set::Scalar> Integrator::Flame::laser_mf
- BC::BC<Set::Scalar>* Integrator::Flame::bc_temp
- BC::BC<Set::Scalar>* Integrator::Flame::bc_eta
- IC::IC<Set::Scalar>* Integrator::Flame::ic_phi
- IC::IC<Set::Scalar>* Integrator::Flame::ic_laser
- Set::Scalar Integrator::Flame::phi_refinement_criterion
- Set::Scalar Integrator::Flame::m_refinement_criterion
- Set::Scalar Integrator::Flame::t_refinement_criterion
- Set::Scalar Integrator::Flame::t_refinement_restriction
- Set::Scalar Integrator::Flame::small
- IC::IC<Set::Scalar>* Integrator::Flame::ic_eta
- bool Integrator::Flame::plot_field
- int Integrator::Flame::variable_pressure
- struct Integrator::Flame Integrator::Flame::pf
- struct Integrator::Flame Integrator::Flame::thermal
- struct Integrator::Flame Integrator::Flame::elastic
- struct Integrator::Flame Integrator::Flame::chamber
- Model::Propellant::Propellant< Model::Propellant::PowerLaw, Model::Propellant::FullFeedback, Model::Propellant::Homogenize> Integrator::Flame::propellant
- Set::Scalar Integrator::Flame::eps
- Set::Scalar Integrator::Flame::lambda
- Set::Scalar Integrator::Flame::kappa
- Set::Scalar Integrator::Flame::w1
- Set::Scalar Integrator::Flame::w12
- Set::Scalar Integrator::Flame::w0
- Set::Scalar Integrator::Flame::min_eta
- bool Integrator::Flame::on
- Set::Scalar Integrator::Flame::hc
- Set::Scalar Integrator::Flame::Tref
- Set::Scalar Integrator::Flame::Tfluid
- IC::IC<Set::Scalar>* Integrator::Flame::ic_temp
- int Integrator::Flame::on
- Set::Scalar Integrator::Flame::Telastic
- model_type Integrator::Flame::model_ap
- model_type Integrator::Flame::model_htpb
- Set::Scalar Integrator::Flame::traction
- int Integrator::Flame::phirefinement
- Set::Scalar Integrator::Flame::volume
- Set::Scalar Integrator::Flame::area
- Set::Scalar Integrator::Flame::massflux
- Set::Scalar Integrator::Flame::pressure

Integrator::Fracture

src/Integrator/Fracture.H

This class implements second and fourth order phase field brittle fracture with near singular solver. This class inherits from the base class Base/Mechanics.H. See this link for more information on this implementation.

The energy functional for a second order model is given by .. math:

\mathcal{L}= \int_\Omega \left[\left(g(c) + \eta \right)W_0^+ + W_0^-\right] dV + \int_\Omega G_c \left[ \frac{w(c)}{4\xi} + \xi |\nabla c|^2\right] dV

where $g(c)$ and $w(c)$ are interpolation functions specified by the user. The fracture energy $G_c$ and crack length scale $xi$ are also read from input file. The tension compression asymmetry is accounted by splitting the strain energy $W_0$ as .. math:

W_0^pm = frac{1}{2} lambda (operatorname{tr}bm{varepsilon}_pm)^2 + mu operatorname{tr}left(bm{varepsilon}_pm^2right), quad bm{varepsilon_pm} = sum_{i=1}^d left(varepsilon_i right)_pm hat{bm{v}}_iotimeshat{bm{v}}_i

where $\lambda$ and $\mu$ are material models for linear elastic isotropic material, $\bm{\varepsilon}_\pm$ are the positive and negative components of the strain tensor $\bm{\varepsilon}$ computed through eigenvalue decomposition. The fourth order model adds a laplacian term to the free energy functional. The code performs a staggered solve where it solves the elastic problem implicitly and crack problem explicitly.

Class methods:

Fracture(): Basic constructor. Does nothing, and leaves all values initiated as NAN.
Fracture(IO::ParmParse &pp): Calls the parser.
static void Parse(Fracture &value, IO::ParmParse &pp) Parses input file, ICs, BCs, and sets up multifabs appropriately
void Initialize(int lev) override Calls IC and sets up the initial crack geometry.
virtual void UpdateModel(int a_step) override Performs degradation by updating the $\psi$ field using $g(c)$.
void TimeStepBegin(Set::Scalar a_time, int a_step) override Solves the elastic problem, performs eigen value decomposition of strain, and computes the positive part of the strain energy.
void Advance(int a_lev, amrex::Real a_time, amrex::Real a_dt) Advances the crack field by computing the variational derivative of energy functional with $c$.
void TagCellsForRefinement(int lev, amrex::TagBoxArray &a_tags, Set::Scalar a_time, int a_ngrow) override Refines the grid based on the crack field.
void Integrate(int amrlev, Set::Scalar time, int step, const amrex::MFIter &mfi, const amrex::Box &a_box) override Performs spatial integration of the driving force to check for convergence of crack problem
void TimeStepComplete(Set::Scalar /*time*/, int /* iter*/) Checks whether the solver should work on crack problem or elastic problem.

Parameter	Type	Values
material.refinement_threshold	Material field related parsing
driving_force_refinement_threshold	Driving force threshold	1E100
material.ic.type	IC determining material distribution	laminate ellipse perturbedinterface bmp png expression
crack.refinement_threshold	Crack related parsing mesh refinement criteria	0.0001
crack.df.beta	constant multiplier for fourth orther model with bilaplacian	0.0
crack.df.tol_rel	relative tolerance for convergence of driving force	1E-3
crack.df.tol_abs	absolute tolerance for convergence of driving force	1E-3
crack.df.max_iter	Maximum number of solver iterations	500.
crack.df.mult_Gc	constant multiplier for controlling fracture energy of interface	1.0
crack.df.mult_lap	constant multiplier for second order model with laplacian	1.0
crack.df.el_mult	unit conversion multiplier between elastic problem and crack problem	1.0

API definitions in src/Integrator/Fracture.H

Classes

Integrator::Fracture

Methods
- Fracture()
- Fracture(IO::ParmParse &pp)
- Initialize(int lev) override
- UpdateModel(int a_step, Set::Scalar) override
- TimeStepBegin(Set::Scalar, int a_step) override
- Advance(int a_lev, amrex::Real a_time, amrex::Real a_dt) override
- TagCellsForRefinement(int lev, amrex::TagBoxArray &a_tags, Set::Scalar a_time, int a_ngrow) override
- Integrate(int amrlev, Set::Scalar time, int step, const amrex::MFIter &mfi, const amrex::Box &a_box) override
- TimeStepComplete(Set::Scalar, int) override
Variables
- Set::Field<Set::Scalar> Integrator::Fracture::c_mf
- Set::Field<Set::Scalar> Integrator::Fracture::c_old_mf
- Set::Field<Set::Scalar> Integrator::Fracture::energy_pristine_mf
- Set::Field<Set::Scalar> Integrator::Fracture::history_var_mf
- Set::Field<Set::Scalar> Integrator::Fracture::driving_force_mf
- std::vector<pfczm_crack_type> Integrator::Fracture::cracktype
- std::vector<std::string> Integrator::Fracture::ic_type
- std::vector<IC::IC<Set::Scalar> *> Integrator::Fracture::ic
- bool Integrator::Fracture::is_ic
- Set::Scalar Integrator::Fracture::scaleModulusMax
- Set::Scalar Integrator::Fracture::refinement_threshold
- Set::Scalar Integrator::Fracture::mult_lap
- Set::Scalar Integrator::Fracture::mult_Gc
- Set::Scalar Integrator::Fracture::el_mult
- Set::Scalar Integrator::Fracture::driving_force_reference
- Set::Scalar Integrator::Fracture::driving_force_reference_prev
- Set::Scalar Integrator::Fracture::driving_force_norm
- Set::Scalar Integrator::Fracture::driving_force_refinement_threshold
- Set::Scalar Integrator::Fracture::tol_rel
- Set::Scalar Integrator::Fracture::tol_abs
- Set::Scalar Integrator::Fracture::max_iter
- Set::Scalar Integrator::Fracture::crack_l2_err
- Set::Scalar Integrator::Fracture::crack_norm
- Set::Scalar Integrator::Fracture::crack_prop_iter
- Set::Scalar Integrator::Fracture::beta
- Set::Field<Set::Scalar> Integrator::Fracture::eta_mf
- Set::Scalar Integrator::Fracture::m_eta_ref_threshold
- std::vector<brittle_model> Integrator::Fracture::models
- IC::IC<Set::Scalar>* Integrator::Fracture::ic
- int Integrator::Fracture::num_mat
- struct Integrator::Fracture Integrator::Fracture::crack
- struct Integrator::Fracture Integrator::Fracture::material
- bool Integrator::Fracture::elastic_do_solve_now
- bool Integrator::Fracture::increase_load_step
- bool Integrator::Fracture::set_initial_df_once
- bool Integrator::Fracture::set_new_reference
- int Integrator::Fracture::loadstep
- BC::BC<Set::Scalar>* Integrator::Fracture::bc_psi

Integrator::Hydro

src/Integrator/Hydro.cpp src/Integrator/Hydro.H

Parameter	Type	Values
scheme	time integration scheme to use	forwardeuler ssprk3 rk4
eta_refinement_criterion	eta-based refinement	0.01
omega_refinement_criterion	vorticity-based refinement	0.01
gradu_refinement_criterion	velocity gradient-based refinement	0.01
p_refinement_criterion	pressure-based refinement	1e100
rho_refinement_criterion	density-based refinement	1e100
gamma	gamma for gamma law	required
cfl	cfl condition	required
cfl_v	cfl condition	1E100
mu	linear viscosity coefficient	required
pref	pp_query_default("Pfactor", value.Pfactor,1.0); // (to be removed) test factor for viscous source reference pressure for Roe solver	1.0
density.bc.type	Boundary condition for density	constant expression
energy.bc.type	Boundary condition for energy	constant expression
momentum.bc.type	Boundary condition for momentum	constant expression
pf.eta.bc.type	Boundary condition for phase field order parameter	constant expression
small	small regularization value	1E-8
cutoff	cutoff value	-1E100
lagrange	lagrange no-penetration factor	0.0
eta.ic.type	eta initial condition	constant laminate expression bmp png
velocity.ic.type	velocity initial condition	constant expression
pressure.ic.type	solid pressure initial condition	constant expression
density.ic.type	density initial condition type	constant expression
solid.momentum.ic.type	solid momentum initial condition	constant expression
solid.density.ic.type	solid density initial condition	constant expression
solid.energy.ic.type	solid energy initial condition	constant expression
m0.ic.type	diffuse boundary prescribed mass flux	constant expression
u0.ic.type	diffuse boundary prescribed velocity	constant expression
q.ic.type	diffuse boundary prescribed heat flux	constant expression
solver.type	Riemann solver	roe hlle hllc
allow_unused	Set this to true to allow unused inputs without error. (Not recommended.)	false

Integrator::HeatConduction

src/Integrator/HeatConduction.H

This implements a basic heat conduction method in Alamo. The partial differential equation to be solved is

\[\frac{\partial T}{\partial t} = \alpha\,\Delta T\]

where $T$ is temperature, $t$ is time, and $alpha$ is the thermal diffusivity. Integration is performed explicitly in time using forward Euler, and differentiation is performed using the finite difference method.

Parameter	Type	Values
heat.alpha	Diffusion coefficient $\alpha$. This is an example of a required input variable - - program will terminate unless it is provided.	required
heat.refinement_threshold	Criterion for mesh refinement. This is an example of a default input variable. The default value is provided here, not in the definition of the variable.	"0.01_K"
ic.type	Initial condition type.	constant sphere expression
bc.temp.type	Select BC object for temperature	constant expression
method	Select between using a realspace solve or the spectral method	realspace spectral

Integrator::Mechanics

src/Integrator/Mechanics.H

This is a general purpose integrator that focuses on solving elasticity/mechanics equations in the absence of other multiphysics simulations. It is enabled by alamo.program=mechanics if used on its own, in which case there is no prefix. If it is being used by another integrator, see that integrator to determine the value of [prefix] (often equal to elastic).

This integrator inherits from Integrator::Base::Mechanics; see documentation for that integrator for additional parameters.

Model setup There are two basic tools for setting up a mechanics problem in this integrator.

The eta field: this is used to mix models of different types. Use nmodels to specify how many material models to use, and then specify each model as model1, model2, etc. The type of moel is specified using the alamo.program.mechanics.model input.

Once you have done this, you must determine the spatial distribution of each model. This is done by choosing an IC for the eta field with ic.type. The IC::Expression is the most general and recommended. The models are then mixed linearly, i.e.

\[W_{\textrm{eff}} = \sum_{i=1}^N W_i\,\eta_i(\mathbf{x})\]

See the Eshelby test for an example of model mixing.
The psi field: this is used specifically for cases where a “void” region is desired. Its usage is similar to the eta case, and is conceptually similar in that it scales the model field to near-zero in order to mimic the (lack of) mechanical behavior in an empty region. It is important to use psi here, for reasons that are discussed in detail in this paper. The initialization of psi is similar to that for eta.

See the PlateHole and RubberPlateHole for canonical exmaples. The Integrator::Fracture and Integrator::TopOp integrators are examples of integrators that leverage the psi property.

Body forces currently have limited support due to the relatively low number of times they are needed. See the Integrator::Base::Mechanics documentation for detail. See the TrigTest test for examples of current body force implementation.

Boundary conditions are implemented using the BC::Operator::Elastic classes. See the documentation on these classes for more detail. See any of the mechanics-based tests for examples of boundary condition application.

Parameter	Type	Values
nmodels	Number of elastic model varieties	1
eta_ref_threshold	Refinement threshold for eta field	0.01
ref_threshold	Refinement threshold for strain gradient	0.01
model_neumann_boundary	Explicity impose neumann condition on model at domain boundaries (2d only)	false
ic.type	Select the initial condition for eta	constant ellipse voronoi bmp png expression psread
eta.reset_on_regrid	Whether to re-initialize eta when re-gridding occurs. Default is false unless eta ic is set, then default is. true.	true
psi.ic.type	Select initial condition for psi field	ellipse constant expression psread png
psi.reset_on_regrid	Whether to re-initialize psi when re-gridding occurs. Default is false unless a psi ic is set, then default is true.	true
trac_normal.ic.type	Read in IC for the "normal traction" field (applied at diffuse boundaries)	ellipse constant expression psread

Integrator::PhaseFieldMicrostructure

src/Integrator/PhaseFieldMicrostructure.cpp src/Integrator/PhaseFieldMicrostructure.H

file PhaseFieldMicrostructure.H

Parameter	Type	Values
pf.number_of_grains	Number of grain fields (may be more if using different IC)	2
pf.M	Mobility	required
pf.gamma	Phase field $\gamma$	required
pf.sigma0	Initial GB energy if not using anisotropy	required
pf.l_gb	Mobility	required
pf.elastic_df	Determine whether to use elastic driving force	false
pf.elastic_mult	Multiplier of elastic energy	1.0
pf.threshold.value	Value used for thresholding kinetic relation	0.0
pf.threshold.chempot	Whether to include chemical potential in threshold	false
pf.threshold.boundary	Whether to include boundary energy in threshold	false
pf.threshold.corner	Whether to include corner regularization in threshold	false
pf.threshold.lagrange	Whether to include lagrange multiplier in threshold	false
pf.threshold.mechanics	Whether to include mechanical driving force in threshold	false
pf.threshold.type	Type of thresholding to use	continuous chop
amr.max_level	Maximum AMR level	required
amr.ref_threshold	Phase field refinement threshold	0.1
mechanics.type	Reading this is redundant but necessary because of the way the code was originally structured (need to fix eventually)	disable static dynamic
mechanics.tstart	Elasticity	0.0
mechanics.mix_order	Mixing order	1 2
mechanics.model_neuman_boundary	Force Neumann BCs on the model	false
lagrange.on	Lagrange multiplier method for enforcing volumes	false
lagrange.lambda	Lagrange multiplier value	required
lagrange.vol0	Prescribed volume	required
lagrange.tstart	Lagrange multipler start time	0.0
sdf.on	synthetic driving force (SDF)	false
sdf.val	value of SDF for each grain
sdf.tstart	time to begin applying SDF	0.0
anisotropy.on	Turn on	false
anisotropy.beta	Regularization para m	required
anisotropy.tstart	Time to turn on anisotropy	required
anisotropy.timestep	Modify timestep when turned on	required
anisotropy.plot_int	Modify plot_int when turned on	-1
anisotropy.plot_dt	Modify plot_dt when turned on	-1.0
anisotropy.thermo_int	Modify thermo int when turned on	-1
anisotropy.thermo_plot_int	Modify thermo plot int when turned on	-1
anisotropy.elastic_int	Frequency of elastic calculation	-1
anisotropy.regularization	Type of regularization to use	k12 wilmore
anisotropy.type	Type of GB to use	abssin sin read sh
fluctuation.on	Thermal fluctuations
fluctuation.amp	fluctuation amplitude
fluctuation.sd	fluctuation stadard deviation
fluctuation.tstart	time to start applying fluctuation
disconnection.on	Disconnection generation
shearcouple.on	Shear coupling matrices	false
bc.eta.type	Boundary condition for eta	constant
ic.type	Initial condition for the order parameter eta	constant perturbedinterface voronoi expression sphere ellipse random
anisotropic_kinetics.on	Anisotropic mobility	0
anisotropic_kinetics.tstart	simulation time when anisotropic kinetics is activated	0.0
anisotropic_kinetics.mobility	file containing anisotropic mobility data	file path
anisotropic_kinetics.threshold	file containing anisotropic mobility data	file path

API definitions in src/Integrator/PhaseFieldMicrostructure.H

Classes

Integrator::PhaseFieldMicrostructure - Solve the Allen-Cahn evolution equation for microstructure with parameters , where n corresponds to the number of grains.

Methods
- PhaseFieldMicrostructure()
- PhaseFieldMicrostructure(IO::ParmParse &pp)
- ~PhaseFieldMicrostructure()
- Advance(int lev, Real time, Real dt) override - Evolve phase field in time.
- Initialize(int lev) override
- TagCellsForRefinement(int lev, amrex::TagBoxArray &tags, amrex::Real time, int ngrow) override
- TimeStepBegin(amrex::Real time, int iter) override
- TimeStepComplete(amrex::Real time, int iter) override
- Integrate(int amrlev, Set::Scalar time, int step, const amrex::MFIter &mfi, const amrex::Box &box) override
- UpdateEigenstrain(int lev)
- UpdateEigenstrain()
- UpdateModel(int, Set::Scalar) override
Variables
- const std::string Integrator::PhaseFieldMicrostructure< model_type >::name
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::M
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::L
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::mu
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::gamma
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::sigma0
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::l_gb
- bool Integrator::PhaseFieldMicrostructure< model_type >::elastic_df
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::elastic_mult
- bool Integrator::PhaseFieldMicrostructure< model_type >::on
- bool Integrator::PhaseFieldMicrostructure< model_type >::chempot
- bool Integrator::PhaseFieldMicrostructure< model_type >::boundary
- bool Integrator::PhaseFieldMicrostructure< model_type >::corner
- bool Integrator::PhaseFieldMicrostructure< model_type >::lagrange
- bool Integrator::PhaseFieldMicrostructure< model_type >::mechanics
- bool Integrator::PhaseFieldMicrostructure< model_type >::sdf
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::value
- ThresholdType Integrator::PhaseFieldMicrostructure< model_type >::type
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::threshold
- int Integrator::PhaseFieldMicrostructure< model_type >::on
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::tstart
- Numeric::Interpolator::Linear<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::mobility
- Numeric::Interpolator::Linear<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::threshold
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::L_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::threshold_mf
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::beta
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::timestep
- int Integrator::PhaseFieldMicrostructure< model_type >::plot_int
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::plot_dt
- int Integrator::PhaseFieldMicrostructure< model_type >::thermo_int
- int Integrator::PhaseFieldMicrostructure< model_type >::thermo_plot_int
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::theta0
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::sigma1
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::phi0
- int Integrator::PhaseFieldMicrostructure< model_type >::elastic_int
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::vol0
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::lambda
- std::vector<Numeric::Interpolator::Linear<Set::Scalar> > Integrator::PhaseFieldMicrostructure< model_type >::val
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::amp
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::sd
- std::normal_distribution<double> Integrator::PhaseFieldMicrostructure< model_type >::norm_dist
- std::default_random_engine Integrator::PhaseFieldMicrostructure< model_type >::rand_num_gen
- Model::Defect::Disconnection Integrator::PhaseFieldMicrostructure< model_type >::model
- std::vector<Set::Matrix> Integrator::PhaseFieldMicrostructure< model_type >::Fgb
- std::vector<model_type> Integrator::PhaseFieldMicrostructure< model_type >::model
- int Integrator::PhaseFieldMicrostructure< model_type >::model_mix_order
- bool Integrator::PhaseFieldMicrostructure< model_type >::model_neumann_boundary
- int Integrator::PhaseFieldMicrostructure< model_type >::number_of_grains
- int Integrator::PhaseFieldMicrostructure< model_type >::number_of_ghost_cells
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::ref_threshold
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::eta_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::eta_old_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::driving_force_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::driving_force_threshold_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::fluct_mf
- Set::Field<Set::Scalar> Integrator::PhaseFieldMicrostructure< model_type >::totaldf_mf
- BC::BC<Set::Scalar>* Integrator::PhaseFieldMicrostructure< model_type >::mybc
- RegularizationType Integrator::PhaseFieldMicrostructure< model_type >::regularization
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::pf
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::anisotropic_kinetics
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::anisotropy
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::lagrange
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::sdf
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::fluctuation
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::disconnection
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::shearcouple
- std::string Integrator::PhaseFieldMicrostructure< model_type >::gb_type
- std::string Integrator::PhaseFieldMicrostructure< model_type >::filename
- Model::Interface::GB::GB* Integrator::PhaseFieldMicrostructure< model_type >::boundary
- IC::IC<Set::Scalar>* Integrator::PhaseFieldMicrostructure< model_type >::ic
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::volume
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::area
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::gbenergy
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::realgbenergy
- Set::Scalar Integrator::PhaseFieldMicrostructure< model_type >::regenergy
- struct Integrator::PhaseFieldMicrostructure Integrator::PhaseFieldMicrostructure< model_type >::mechanics

Integrator::PFC

src/Integrator/PFC.cpp src/Integrator/PFC.H

Basic implementation of the phase field crystal model of Elder et al, 2002.

Free energy functional is:

\[\mathcal{F} = \int \Big[ \frac{1}{2}\eta\Big((q^2+\nabla^2)^2 - \epsilon\Big)\eta + \frac{1}{4}\eta^4 \Big]d\mathbf{x}\]

Order parameter evolves with Cahn-Hilliard kinetics:

\[\frac{\partial \eta}{\partial t} = \nabla^2 \frac{\delta\mathcal{F}}{\delta\eta}\]

The variational derivative is

\[\frac{\delta\mathcal{F}}{\delta\eta} = \eta^3 + (q^4-\epsilon)\eta + 2q^2\nabla^2\eta + \nabla^4\eta\]

The semi-implicit spectral update is

\[\eta_{n+1} = \frac{\hat{\eta}_n - dt\,\mathbf{\omega}^2 \mathcal{F}[\eta^3_n]} {1 + dt\,[(q^4-\epsilon)\mathbf{\omega}^2 - 2q^2\mathbf{\omega}^4 + \mathbf{\omega}^6]}\]

Parameter	Type	Values
q0	frequency term	required
eps	chemical potential width	required
eta.ic.type	initial condition for $\eta$	random
eta.bc.type	boundary condition for $\eta$	constant

Integrator::SFI

src/Integrator/SFI.H

Parameter	Type	Values
tstart	time to activate hydro integrator	0.0
invert	If true, set hydro_eta to 1-pf_eta	false

Integrator::SutureCrack

src/Integrator/SutureCrack.H

Parameter	Type	Values
type	Crack type to use {notch}

API definitions in src/Integrator/SutureCrack.H

Classes

Integrator::SutureCrack

Methods
- SutureCrack()
- Initialize(int ilev) override
- TimeStepBegin(Set::Scalar, int iter) override
- Advance(int lev, Set::Scalar, Set::Scalar dt) override
- TagCellsForRefinement(int lev, amrex::TagBoxArray &a_tags, amrex::Real, int) override
- Integrate(int amrlev, Set::Scalar, int, const amrex::MFIter &mfi, const amrex::Box &box)
- TimeStepComplete(amrex::Real, int)
Variables
- int Integrator::SutureCrack::number_of_ghost_nodes - Number of ghost nodes.
- int Integrator::SutureCrack::number_of_materials
- int Integrator::SutureCrack::nlevels
- struct Integrator::SutureCrack Integrator::SutureCrack::elastic
- struct Integrator::SutureCrack Integrator::SutureCrack::crack
- struct Integrator::SutureCrack Integrator::SutureCrack::material
- struct Integrator::SutureCrack Integrator::SutureCrack::sol
- struct Integrator::SutureCrack Integrator::SutureCrack::loading
- Set::Field<Set::Scalar> Integrator::SutureCrack::disp - displacement field
- Set::Field<Set::Scalar> Integrator::SutureCrack::strain - total strain field (gradient of displacement)
- Set::Field<Set::Scalar> Integrator::SutureCrack::stress - stress field
- Set::Field<Set::Scalar> Integrator::SutureCrack::rhs - rhs fab for elastic solution
- Set::Field<Set::Scalar> Integrator::SutureCrack::residual - residual field for solver
- Set::Field<Set::Scalar> Integrator::SutureCrack::energy - total elastic energy
- Set::Field<Set::Scalar> Integrator::SutureCrack::energy_pristine - energy of the prisitne material as if no crack is present
- Set::Field<Set::Scalar> Integrator::SutureCrack::energy_pristine_old - energy of the pristine material for previous time step.
- BC::Operator::Elastic::Constant Integrator::SutureCrack::brittlebc - elastic if using brittle fracture
- Set::Scalar Integrator::SutureCrack::df_mult - mulitplier for elastic driving force.
- bool Integrator::SutureCrack::do_solve_now
- Set::Field<Set::Scalar> Integrator::SutureCrack::field - crack field at current time step
- Set::Field<Set::Scalar> Integrator::SutureCrack::field_old - crack field at previous time step
- Set::Field<Set::Scalar> Integrator::SutureCrack::driving_force - crack driving forces.
- Set::Scalar Integrator::SutureCrack::driving_force_reference
- Set::Scalar Integrator::SutureCrack::driving_force_norm
- Set::Scalar Integrator::SutureCrack::driving_force_tolerance_rel
- Set::Scalar Integrator::SutureCrack::driving_force_tolerance_abs
- Model::Interface::Crack::Crack* Integrator::SutureCrack::cracktype - type of crack. See Crack/Constant or Crack/Sin
- std::string Integrator::SutureCrack::ic_type - crack type. See IC/Notch and IC/Ellipsoid
- IC::IC* Integrator::SutureCrack::ic - crack . See IC/Notch and IC/Ellipsoid
- bool Integrator::SutureCrack::is_ic
- Set::Scalar Integrator::SutureCrack::scaleModulusMax - material modulus ratio inside crack (default = 0.02).
- Set::Scalar Integrator::SutureCrack::refinement_threshold
- Set::Scalar Integrator::SutureCrack::mult_df_Gc - Multiplier for Gc/zeta term.
- Set::Scalar Integrator::SutureCrack::mult_df_lap - Multiplier for the laplacian term.
- suture_fracture_model_type Integrator::SutureCrack::brittlemodeltype
- Set::Field<Set::Scalar> Integrator::SutureCrack::modulus_field
- Set::Field<suture_fracture_model_type> Integrator::SutureCrack::brittlemodel
- std::string Integrator::SutureCrack::input_material
- Set::Scalar Integrator::SutureCrack::bottom_tol
- int Integrator::SutureCrack::interval
- std::string Integrator::SutureCrack::type
- int Integrator::SutureCrack::max_iter
- int Integrator::SutureCrack::max_fmg_iter
- int Integrator::SutureCrack::bottom_max_iter
- int Integrator::SutureCrack::max_fixed_iter
- int Integrator::SutureCrack::verbose
- int Integrator::SutureCrack::cgverbose
- Set::Scalar Integrator::SutureCrack::tol_rel
- Set::Scalar Integrator::SutureCrack::tol_abs
- Set::Scalar Integrator::SutureCrack::cg_tol_rel
- Set::Scalar Integrator::SutureCrack::cg_tol_abs
- Set::Scalar Integrator::SutureCrack::tstart
- Set::Scalar Integrator::SutureCrack::tend
- std::string Integrator::SutureCrack::bottom_solver
- int Integrator::SutureCrack::linop_maxorder
- bool Integrator::SutureCrack::use_fsmooth
- int Integrator::SutureCrack::max_coarsening_level
- bool Integrator::SutureCrack::agglomeration
- bool Integrator::SutureCrack::consolidation
- int Integrator::SutureCrack::pre_smooth
- int Integrator::SutureCrack::post_smooth
- Set::Vector Integrator::SutureCrack::body_force
- Set::Scalar Integrator::SutureCrack::val

Integrator::ThermoElastic

src/Integrator/ThermoElastic.H

Parameter	Type	Values
alpha	Diffusion coefficient

Integrator::TopOp

src/Integrator/TopOp.H

Parameter	Type	Values
psi.ic.type	Initial condition for psi field	ellipse constant
eta_ref_threshold	Refinement threshold based on eta	0.01
alpha	$\alpha$ parameter	1.0
beta	$\beta$ parameter	1.0
gamma	$\gamma$ parameter	1.0
volume0frac	Prescribed volume fraction	0.5
volume0	Prescribed total vlume	0.5

Integrator::Base

Integrator::Base::Mechanics

src/Integrator/Base/Mechanics.H

Parameter	Type	Values
type	Type of mecahnics to use. Static: do full implicit solve. Dynamic: evolve dynamic equations with explicit dynamics Disable: do nothing.	disable static dynamic
time_evolving	Treat mechanics fields as changing in time. [false] You should use this if you care about other physics driven by the output of this integrator.	false
plot_disp	Include displacement field in output	true
plot_rhs	Include right-hand side in output	true
plot_psi	Include $\psi$ field in output	true
plot_stress	Include stress in output	true
plot_strain	Include strain in output	true
viscous.mu_dashpot	Dashpot damping (damps velocity)	0.0
viscous.mu_newton	Newtonian viscous damping (damps velocity gradient)	0.0
velocity.ic.type	Initializer for RHS	none expression
bc.type	Select the mechanical boundary conditions	constant tensiontest expression
print_model	Print out model variables (if enabled by model)	false
rhs.type	initial condition for right hand side (body force)	constant expression trig
interval	Timestep interval for elastic solves (default - solve every time)	0
max_coarsening_level	Maximum multigrid coarsening level (default - none, maximum coarsening)	-1
print_residual	Whether to include residual output field	false
elastic_ref_threshold	Whether to refine based on elastic solution	0.01
zero_out_displacement	Set this to true to zero out the displacement before each solve. (This is a temporary fix - we need to figure out why this is needed.)	false
tstart	Time to start doing the elastic solve (by default, start immediately)	-1.0

API definitions in src/Integrator/Base/Mechanics.H

Classes

Integrator::Base::Mechanics

Methods
- Mechanics()
- ~Mechanics()
- Initialize(int lev) override - Use the #ic object to initialize::Temp.
- UpdateModel(int a_step, Set::Scalar a_time)=0
- TimeStepBegin(Set::Scalar a_time, int a_step) override
- Advance(int lev, Set::Scalar time, Set::Scalar dt) override
- Integrate(int amrlev, Set::Scalar, int, const amrex::MFIter &mfi, const amrex::Box &a_box) override
- TagCellsForRefinement(int lev, amrex::TagBoxArray &a_tags, Set::Scalar, int) override
Variables
- Set::Field<MODEL> Integrator::Base::Mechanics< MODEL >::model_mf
- Set::Field<MATRIX4> Integrator::Base::Mechanics< MODEL >::ddw_mf
- Set::Field<Set::Scalar> Integrator::Base::Mechanics< MODEL >::psi_mf
- bool Integrator::Base::Mechanics< MODEL >::psi_on
- int Integrator::Base::Mechanics< MODEL >::m_interval
- Type Integrator::Base::Mechanics< MODEL >::m_type
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::disp_mf
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::rhs_mf
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::res_mf
- Set::Field<Set::Matrix> Integrator::Base::Mechanics< MODEL >::stress_mf
- Set::Field<Set::Matrix> Integrator::Base::Mechanics< MODEL >::strain_mf
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::disp_old_mf
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::vel_mf
- Set::Field<Set::Vector> Integrator::Base::Mechanics< MODEL >::vel_old_mf
- Set::Scalar Integrator::Base::Mechanics< MODEL >::rho
- Set::Scalar Integrator::Base::Mechanics< MODEL >::mu_dashpot
- Set::Scalar Integrator::Base::Mechanics< MODEL >::mu_newton
- Set::Vector Integrator::Base::Mechanics< MODEL >::trac_hi[AMREX_SPACEDIM]
- Set::Vector Integrator::Base::Mechanics< MODEL >::disp_hi[AMREX_SPACEDIM]
- IC::IC<Set::Vector>* Integrator::Base::Mechanics< MODEL >::ic_rhs
- IC::IC<Set::Vector>* Integrator::Base::Mechanics< MODEL >::velocity_ic
- Solver::Nonlocal::Newton<MODEL> Integrator::Base::Mechanics< MODEL >::solver
- BC::Operator::Elastic::Elastic* Integrator::Base::Mechanics< MODEL >::bc
- Set::Scalar Integrator::Base::Mechanics< MODEL >::m_elastic_ref_threshold
- bool Integrator::Base::Mechanics< MODEL >::m_print_model
- bool Integrator::Base::Mechanics< MODEL >::m_print_residual
- bool Integrator::Base::Mechanics< MODEL >::m_time_evolving
- int Integrator::Base::Mechanics< MODEL >::m_max_coarsening_level
- bool Integrator::Base::Mechanics< MODEL >::m_zero_out_displacement
- bool Integrator::Base::Mechanics< MODEL >::plot_disp
- bool Integrator::Base::Mechanics< MODEL >::plot_stress
- bool Integrator::Base::Mechanics< MODEL >::plot_strain
- bool Integrator::Base::Mechanics< MODEL >::plot_psi
- bool Integrator::Base::Mechanics< MODEL >::plot_rhs
- Set::Scalar Integrator::Base::Mechanics< MODEL >::tstart

Model

Model::Model

src/Model/Model.H

In Alamo, any type of constitutive behavior is encapsulated in a “Model”. There is a broad range of model types, and so there is no abstract Model class. Rather, the base Model classes are stored in subsets of Model.

Model::Defect

Model::Defect::Disconnection

src/Model/Defect/Disconnection.H

This simulates the creation of “disconnection pairs” at a GB by perturbing the order parameter $\eta$ with a gaussian.

Disconnections can be nucleated randomly, or they can be added in a controlled way through the “fixed” option.

See the following reference for further details

[GR21]

Mahi Gokuli and Brandon Runnels. Multiphase field modeling of grain boundary migration mediated by emergent disconnections. Acta Materialia, 217:117149, 2021.

Parameter	Type	Values
tstart	time to start applying disconnections	0.0
nucleation_energy	nucleation energy	0.0
tau_vol	characteristic time	1.0
temp	temperature	0.0
box_size	characteristic size	0.0
interval	interval between generation events	required
epsilon	regularization epsilon	1E-20
disconnection.fixed.on	whether to manually specify disconnection nucleation points
fixed.sitex	array of x locations
fixed.sitey	array of y locations
fixed.phases	array of order parameter number
fixed.time	time to appear
verbose	verbosity	false

Model::Interface

Model::Interface::Crack

Model::Interface::Crack::Crack

src/Model/Interface/Crack/Crack.H

Model::Interface::Crack::Constant

src/Model/Interface/Crack/Constant.H

Parameter	Type	Values
G_c	Fracture energy
zeta	Lengthscale regularization
mobility	Mobility (speed)
threshold	Threshold
gtype	Type of g function to use {square, multiwell, 4c3, squarep, squarepexp, cubicm}
wtype	Type o w function to use {square, multiwell, multiwell2, 4c3}
exponent	Ductile exponent

Model::Interface::Crack::PFCZM

src/Model/Interface/Crack/PFCZM.H

Parameter	Type	Values
czm_order	Order 1, 1.5, or 2 (Wu 2024, JMPS)	1.0
G_c	Fracture energy in N/m	1.0e3
zeta	Lengthscale regularization in m	1.e-5
mixed_mode	Toggle to determine mixed mode	false
E	Young's modulus	2.e11
nu	Poisson's ratio $\nu$	0.3
failure_surface	type of failure surface degradation function. For now, we only have linear softening	wang2023 mohr mc columb
fracture_strength	Fracture strength	1.e6
chi	$\chi$ value	1.0
compressive_strength	Compressive strength	4.e8
cohesion	cohesion coefficient for MC FS type	1.0
friction	friction coefficient for MC FS type	0.5
E	Young's modulus	2.e11
fracture_strength	fracture strength beyond which softening starts [Pa]	1.e6
mobility	Mobility (speed)	1.0e-2
threshold	Threshold	0.0
gtype	degradation function. For now, we only have linear softening	wu_linear
wtype	geometric function. no choice except for the optimal one for now.	wu

Model::Interface::Crack::Sin

src/Model/Interface/Crack/Sin.H

Parameter	Type	Values
Gc0	Min Gc (fracture energy) value
Gc1	Max Gc (fracture energy)value
theta0	Angle offset
zeta	Regularization
mobility	Crack mobiilty
threshold	Threshold for kinetics
gtype	Type of g function to use {square, multiwell, 4c3, squarep, squarepexp, cubicm}
wtype	Type o w function to use {square, multiwell, multiwell2, 4c3}
exponent	Ductile exponent

Model::Interface::GB

Model::Interface::GB::GB

src/Model/Interface/GB/GB.H

Model::Interface::GB::AbsSin

src/Model/Interface/GB/AbsSin.H

Parameter	Type	Values
theta0	Angle offset (degrees)
sigma0	Minimum energy
sigma1	Energy multiplier

Model::Interface::GB::Read

src/Model/Interface/GB/Read.H

Parameter	Type	Values
filename	Filename containing GB data	file path

Model::Interface::GB::Sin

src/Model/Interface/GB/Sin.H

Parameter	Type	Values
theta0	Theta offset (degrees)
sigma0	Minimum energy
sigma1	Energy multiplier
n	Frequency number (integer)

Model::Interface::GB::SH

src/Model/Interface/GB/SH.H

Parameter	Type	Values
theta0	Theta offset (degrees)
phi0	Phi offset (radians)
sigma0	Minimum energy value
sigma1	Energy multiplier
regularization	Type of regularization to use: {wilhelm,k23}

Model::Propellant

Model::Propellant::Propellant

src/Model/Propellant/Propellant.H

This header defines the Model::Propellant::Propellant class, which introduces a static dispatch mechanism to replicate traditional dynamic polymorphism without incurring the performance cost of virtual table lookups.

The Propellant class acts as the static equivalent of a pure abstract interface for composite solid propellant models. Each function (e.g., get_K, get_cp, get_L) statically dispatches to the appropriate underlying implementation, encapsulating key thermophysical properties such as density, thermal conductivity, and specific heat. The set_pressure and get_* functions are resolved at compile-time for GPU compatibility and runtime performance.

This system enables polymorphic behavior without relying on runtime virtual functions, making it suitable for high-performance computing environments.

Model::Propellant::FullFeedback

src/Model/Propellant/FullFeedback.H

This SCP model implements the method described in the following paper

[MSM+24]

Maycon Meier, Emma Schmidt, Patrick Martinez, J Matt Quinlan, and Brandon Runnels. Diffuse interface method for solid composite propellant ignition and regression. Combustion and Flame, 259:113120, 2024.

This method imitates inheritance Propellant::Propellant using static polymorphism

Parameter	Type	Values
phi.zeta	AP/HTPB interface length	"10.0_um"
phi.zeta_0	Reference interface length for heat integration	"10.0_um"
phi.zeta_fit_a	Constant offset for $\zeta$ adjustment with pressure	"45.0_um"
phi.zeta_fit_b	Scaling factors for $\zeta$ adjustment with pressure	"-6.42_um"
a1	Surrogate heat flux model paramater - AP	required
a2	Surrogate heat flux model paramater - HTPB	required
a3	Surrogate heat flux model paramater - Total	required
b1	Surrogate heat flux model paramater - AP	required
b2	Surrogate heat flux model paramater - HTPB	required
b3	Surrogate heat flux model paramater - Total	required
c1	Surrogate heat flux model paramater - Total	required
pressure.dependency	Whether to use pressure to determined the reference Zeta	true
Pref	Reference pressure for pressure nondimensionalization	"1_MPa"
rho_ap	AP Density	required
rho_htpb	HTPB Density	required
k_ap	AP Thermal Conductivity	required
k_htpb	HTPB Thermal Conductivity	required
cp_ap	AP Specific Heat	required
cp_htpb	HTPB Specific Heat	required
m_ap	AP Pre-exponential factor for Arrhenius Law	required
m_htpb	HTPB Pre-exponential factor for Arrhenius Law	required
E_ap	COMBINED AP Activation Energy, divided by Rg, for Arrhenius Law (has units of temperature)	required
E_htpb	COMBINED HTPB Activation Energy, divided by Rg, for Arrhenius Law(has units of temperature)	required
mob_ap	Whether to include pressure to the arrhenius law [??]n	false
bound	HTPB Activation Energy for Arrhenius Law	"0.0"

Model::Propellant::Homogenize

src/Model/Propellant/Homogenize.H

Parameter	Type	Values
dispersion1	K; dispersion variables are use to create an inert region for the void grain case. An inert region is one that dissipates energy fast enough to remove regression and thermal strain effects.
dispersion2	rho; dispersion variables are use to create an inert region for the void grain case. An inert region is one that dissipates energy fast enough to remove regression and thermal strain effects.
dispersion3	cp; dispersion variables are use to create an inert region for the void grain case. An inert region is one that dissipates energy fast enough to remove regression and thermal strain effects.
rho_ap	AP Density	required
rho_htpb	HTPB Density	required
k_ap	AP Thermal Conductivity	required
k_htpb	HTPB Thermal Conductivity	required
cp_ap	AP Specific Heat	required
cp_htpb	HTPB Specific Heat	required
h1	Surgate heat flux model paramater - Homogenized	1.81
h2	Surgate heat flux model paramater - Homogenized	1.34
massfraction	AP/HTPB ratio for homogenized domain	0.8
mlocal_ap	AP mass flux reference value	0.0
m_ap	AP Pre-exponential factor for Arrhenius Law	required
m_htpb	HTPB Pre-exponential factor for Arrhenius Law	required
E_ap	AP Activation Energy for Arrhenius Law	required
E_htpb	HTPB Activation Energy for Arrhenius Law	required
mob_ap	Whether to include pressure to the arrhenius law [??]	false
bound	HTPB Activation Energy for Arrhenius Law	0.0

Model::Propellant::PowerLaw

src/Model/Propellant/PowerLaw.H

This SCP model implements the method described in the following paper

[KQR22]

Baburaj Kanagarajan, J Matt Quinlan, and Brandon Runnels. A diffuse interface method for solid-phase modeling of regression behavior in solid composite propellants. Combustion and Flame, 2022.

This method imitates inheritance Propellant::Propellant using static polymorphism

Parameter	Type	Values
gamma	Scaling factor for mobility	required
r_ap	AP power pressure law parameter (r*P^n)	required
r_htpb	HTPB power pressure law parameter (r*P^n)	required
r_comb	AP/HTPB power pressure law parameter (r*P^n)	required
n_ap	AP power pressure law parameter (r*P^n)	required
n_htpb	HTPB power pressure law parameter (r*P^n)	required
n_comb	AP/HTPB power pressure law parameter (r*P^n)	required
deltaw	jump in chemical potential	1.0

Model::Solid

Model::Solid::Solid

src/Model/Solid/Solid.H

Solid models are used with the Integrator::Mechanics integrator, which implements the Solver::Nonlocal::Newton elasticity solver. All solid models inherit from the Model::Solid base class, which requires all of the necessary components to be used in a mechanics solve. Model classes have basically two functions:

Provide energy (W), stress (DW), and modulus (DDW) based on a kinematic variable
Evolve internal variables in time.

Model::Solid::ExtClassOperators

src/Model/Solid/ExtClassOperators.H

Model::Solid::InClassOperators

src/Model/Solid/InClassOperators.H

Model::Solid::Affine

Model::Solid::Affine::Affine

src/Model/Solid/Affine/Affine.H

“Affine” generally means “linear with an offset”. Here we use “affine” to refer to models that are elastic with an eigenstrain, i.e.

\[\sigma = \mathbb{C}(\varepsilon - \varepsilon_0)\]

The quantity $\varepsilon_0$ is any kind of eigenstrain - examples include thermal strain, plastic strain, or viscous strain. This class can be used directly, where the eigenstrain is read in or set by the integrator. There are also classes (particularly visco/plastic models) that inherit from this type of model.

Model::Solid::Affine::Cubic

src/Model/Solid/Affine/Cubic.H

This class extends Model::Solid::Linear::Cubic by adding an eigenstrain $\mathbf{F}_0$.

Parameter	Type	Values
F0	Eigenstrain

Model::Solid::Affine::Hexagonal

src/Model/Solid/Affine/Hexagonal.H

This model implements an affine hexagonal material:

\[W_{aff}(\nabla\mathbf{u}) = W_{lin}(\nabla\mathbf{u} - \mathbf{F}_0)\]

where $W_{aff}$ is the present model, $\mathbf{F}_0$ is the eigenstrain, and $W_{lin}$ is the cubic model defined in Model::Solid::Linear::Hexagonal.

Parameter	Type	Values
F0	Eigenstrain matrix. Can be defined in 2D or 3D.

Model::Solid::Affine::Isotropic

src/Model/Solid/Affine/Isotropic.H

Parameter	Type	Values
F0	Eigendeformation gradient

Model::Solid::Affine::J2

src/Model/Solid/Affine/J2.H

This models an isotropic elastic-perfectly-plastic, non-time-dependent solid model.

The energy and derivatives are:

\begin{gather} W = \frac{1}{2}(\varepsilon - \varepsilon_p):\mathbb{C}(\varepsilon-\varepsilon_p) \\ DW = \mathbb{C}(\varepsilon-\varepsilon_p) \\ DDW = \mathbb{C} \end{gather}

where $\mathbb{C}$ is an isotropic Set::Matrix4 and $\varepsilon_p$ is is stored in the F0 eigenstrain.

The plastic strain is evolved according to the following:

Calculate the deviatoric stress $\sigma_v=\sigma - \frac{1}{3}tr(\sigma)\mathbf{I}$
Calculate $J_2=\sqrt{\frac{3}{2}\sigma_v:\sigma_v}$
If $J_2<\sigma_0$ then quit - no plasticity occurs
Calculate $\Delta\sigma = (1-\frac{\sigma_0}{J_2})$, which projects the stress back on the yield surface.
Convert to change in plastic strain, $\Delta\varepsilon=\mathbb{C}^{-1}\Delta\sigma$
Update plastic strain: $\varepsilon_p += \Delta\varepsilon$

Notes:

This does not implement any kind of hardening model. Rate hardening, isotropic hardening, and kinematic hardening have yet to be implemneted.

Parameter	Type	Values
sigma0	J2 Yield criterion	1.0
hardening	Hardening coefficient (negative value disables rate hardening)	-1.0
ratecoeff	Rate coefficient (negative value disables rate hardening)	-1.0

Model::Solid::Affine::J2Plastic

src/Model/Solid/Affine/J2Plastic.H

Parameter	Type	Values
yield	Yield strength
hardening	hardening parameter
theta	$\theta$

Model::Solid::Finite

Model::Solid::Finite::CrystalPlastic

src/Model/Solid/Finite/CrystalPlastic.H

A basic and relatively untested implementation of finite-deformation FCC crystal plasticity. Use with caution.

Inherits from Model::Solid::Finite::PseudoLinear::Cubic to provide elastic response.

Plastic flow modeled as:

\[\mathbf{F}^p\mathbf{F}^{p-1} = \sum \dot{\gamma}_n \mathbf{a}_n\otimes\mathbf{N}_n\]

where $\mathbf{F}=\mathbf{F}^e\mathbf{F}^p$ and $\gamma_n$ are slips on system $n$.

Power law rate hardening is used in the integration of slips:

\[\dot{\gamma}_n = \dot{\gamma}_0 \Big(\frac{\tau}{\tau_{crss}}\Big)^m \operatorname{sign}(\tau)\]

Parameter	Type	Values
tau_crss	Critical resolved shear stress $\tau_{crss}$
gammadot0	Rate hardening coefficient $\dot{\gamma}_0$	1.0
m_rate_inv	Inverse of the hardening exponent $\frac{1}{m}$	0.5
tstart	Time to activate plastic slip	0.0

Model::Solid::Finite::NeoHookean

src/Model/Solid/Finite/NeoHookean.H

Parameter	Type	Values

Model::Solid::Finite::NeoHookeanPredeformed

src/Model/Solid/Finite/NeoHookeanPredeformed.H

Parameter	Type	Values

Model::Solid::Finite::PseudoAffine

Model::Solid::Finite::PseudoAffine::Cubic

src/Model/Solid/Finite/PseudoAffine/Cubic.H

Parameter	Type	Values
F0	Large-strain eigendeformation (Identity = no deformation)
eps0	Small-strain eigendeformation (Zero = no deformation)

Model::Solid::Finite::PseudoLinear

Model::Solid::Finite::PseudoLinear::Cubic

src/Model/Solid/Finite/PseudoLinear/Cubic.H

Parameter	Type	Values
C11	Elastic constant	1.68
C12	Elastic constant	1.21
C44	Elastic constant	0.75
phi1	Bunge Euler angle $\phi_1$	0.0
Phi	Bunge Euler angle $\Phi$	0.0
phi2	Bunge Euler angle $\phi_2$	0.0

Model::Solid::Linear

Model::Solid::Linear::Cubic

src/Model/Solid/Linear/Cubic.H

This class implements basic cubic elasticity. For a discussion on cubic elasticity, please see this link.

Parameter	Type	Values
C11	Elastic constant	1.68
C12	Elastic constant	1.21
C44	Elastic constant	0.75
anglefmt	specify whether using radians or degrees	radians degrees
phi1	Bunge Euler angle $\phi_1$ about x axis	0.0
Phi	Bunge Euler angle $\Phi$ about z axis	0.0
phi2	Bunge Euler angle $\phi_2$ about x axis	0.0

Model::Solid::Linear::Hexagonal

src/Model/Solid/Linear/Hexagonal.H

This class implements elasticity for a linear material with hexagonal symmetry. The elastic modulus tensor $\mathbb{C}$ has major and minor symmetry but not cubic symmetry, so the symmetry class for this material is MajorMinor The five elastic constants in the unrotated system are $C_{11},C_{12},C_{13},C_{33},C_{44}$, and the resulting elastic modulus tensor is

\[\begin{split}\mathbb{C} &= \begin{bmatrix} C_{0000} & C_{0011} & C_{0022} & C_{0012} & C_{0020} & C_{0001} \\ C_{1100} & C_{1111} & C_{1122} & C_{1112} & C_{1120} & C_{1101} \\ C_{2200} & C_{2211} & C_{2222} & C_{2212} & C_{2220} & C_{2201} \\ C_{1200} & C_{1211} & C_{1222} & C_{1212} & C_{1220} & C_{1201} \\ C_{2000} & C_{2011} & C_{2022} & C_{2012} & C_{2020} & C_{2001} \\ C_{0100} & C_{0111} & C_{0122} & C_{0112} & C_{0120} & C_{0101} \end{bmatrix} \\ &= \begin{bmatrix} C_{11} & C_{12} & C_{12} & & & \\ C_{12} & C_{11} & C_{13} & & & \\ C_{12} & C_{13} & C_{33} & & & \\ & & & C_{44} & & \\ & & & & 0.5(C_{11}-C_{12}) & \\ & & & & & 0.5(C_{11}-C_{12}) \end{bmatrix}\end{split}\]

Rotations can be specified using Bunge euler angles to generate a rotation matrix $\mathbf{R}$. The rotated modulus tensor $\mathbb{C}^{rot}$ is then

\[\mathbb{C}^{rot}_{psqt} = \mathbb{C}_{ijkl}R_{pi}R_{qj}R_{sk}R_{tl}\]

Parameter	Type	Values
C11	Elastic constant	required
C12	Elastic constant	required
C13	Elastic constant	required
C33	Elastic constant	required
C44	Elastic constant	required
phi1	Bunge Euler angle $\phi_1$	0.0
Phi	Bunge Euler angle $\Phi$	0.0
phi2	Bunge Euler angle $\phi_2$	0.0

Model::Solid::Linear::Isotropic

src/Model/Solid/Linear/Isotropic.H

This model implements an isotropic linear elastic material. See this link for more information about the theory.

Free energy for a linear material is defined as

\[W(\nabla\mathbf{u}) = \frac{1}{2}\nabla\mathbf{u}\cdot\mathbb{C}\,\nabla\mathbf{u}\]

For an isotropic material, stress and strain are related through

\[\mathbb{C}_{ijkl} = \lambda \delta_{ij}\varepsilon_{kk} + 2\mu\varepsilon_{ij}\]

where $\lambda$ and $\mu$ are the Lame constant and shear modulus, respectively. Users can specify these either through (lame and shear) OR (lambda and mu) OR (E and nu).

Class methods:

Isotropic(): Basic constructor. Does nothing, and leaves all values initiated as NAN.
Isotropic(Solid<Set::Sym::Isotropic> base) Basic constructor. Does nothing gut allows for inheritance.
Isotropic(Set::Scalar a_mu, Set::Scalar a_lambda) BAD old-fashioned constructor. Do not use!
~Isotropic() Simple destructor. Don’t need to change it.
void Define(Set::Scalar a_mu, Set::Scalar a_lambda) BAD old-fashioned way of doing things. Use Parse instead.
Set::Scalar W(const Set::Matrix & gradu) const override Returns elastic free energy density
Set::Matrix DW(const Set::Matrix & gradu) const override Returns first derivative of free energy, the stress tensor
Set::Matrix4<...> DDW(const Set::Matrix & ) const override Returns second derivative of free energy, the modulus tensor
virtual void Print(std::ostream &out) const override Prints the modulus tensor object to output stream (usually the terminal)
static Isotropic Random() Static method that generates a random yet acceptable model.
static Isotropic Zero() Static method that generates a “zero” element (so that there is no effect under addition)
static void Parse(Isotropic & value, IO::ParmParse & pp) Parser where all the IO occurs

Parameter	Type	Values
planestress	Whether or not to use the `plane stress `_ approximation.	false

Model::Solid::Linear::Laplacian

src/Model/Solid/Linear/Laplacian.H

Parameter	Type	Values
alpha	Coefficient for the Laplacian	1.0

Model::Solid::Linear::Transverse

src/Model/Solid/Linear/Transverse.H

Transversely Isotropic Elasticity Model. This file implements a transversely isotropic elasticity model for the materials that exhibit isotropic behavior in a plane and a distinct response in the perpendicular direction. The stiffness tensor is defined using elastic constants (C11, C12, C13, C33, C44) and an orientation provided either by Bunge Euler angles (phi1, Phi, phi2) or a rotation matrix. Reference: http://solidmechanics.org/text/Chapter3_2/Chapter3_2.htm#Sect3_2_16

Parameter	Type	Values
C11	Elastic constant	1.68
C12	Elastic constant	1.21
C13	Elastic constant	0.75
C33	Elastic constant	1.68
C44	Elastic constant	1.68
phi1	Bunge Euler angle :math:\phi_1	small
Phi	Bunge Euler angle :math:\Phi	small
phi2	Bunge Euler angle :math:\phi_2	small

Numeric

Numeric::Function

src/Numeric/Function.H

Numeric::Stencil

src/Numeric/Stencil.H

Numeric::Interpolator

Numeric::Interpolator::Interpolator

src/Numeric/Interpolator/Interpolator.H

This namespace has evolved to contain some general Interpolator routines that are actually unrelated. The Numeric::Interpolator::Linear is an I/O utility. The Numeric::Interpolator::NodeBilinear is a low-level AMReX override that the average user (or even coder) will probably not need to touch.

Numeric::Interpolator::Linear

src/Numeric/Interpolator/Linear.H

This is a general-purpose routine for specifying time-interpolated quantities in an input file. Interpolators obey the following syntax:

(t1,t2,..,tn;v1,v2,...,vn)

where tn are times and vn are values at those times.

Note: do not include whitespace in an interpolator, this will mess with the parser.

Interpolators can usually be used in place of regular numbers, but only when supported by the calling parse function.

For instance, the BC::Operator::Elastic::TensionTest allows the user to specify fixed displacement; for instance, to specify a value of 0.1:

bc.tenstion_test.disp = 0.1

However, it may be desirable to change the value over time. In this case, one may specify an interpolator string instead:

bc.tenstion_test.disp = (1.0,1.5,2.0;0.0,0.1,0.0)

This will cause the displacement value to be zero for t<1.0; ramp to 0.1 as 1.0<t<2.0; ramp back to 0.0 as 2.0<t<3.0; and then remain at the constant value of 3.0 for t>3.0.

Parameter	Type	Values
str	Interpolator string used when Parsed from queryclass.

Numeric::Interpolator::NodeBilinear

src/Numeric/Interpolator/NodeBilinear.H

Provide an interpolator function that can work with templated fields.

Warning: This is a low-level class used to add templating functionality to unerlying AMReX classes. Edit at your own risk!

Numeric::Interpolator::Test

src/Numeric/Interpolator/Test.cpp src/Numeric/Interpolator/Test.H

Operator

Operator::Operator

src/Operator/Operator.cpp src/Operator/Operator.H

API definitions in src/Operator/Operator.H

Classes

Operator::Operator
Operator::Operator< Grid::Cell >

Methods
- Operator()
- ~Operator()
- Operator(const Operator &)=delete
- Operator(Operator &&)=delete
- operator=(const Operator &)=delete
- operator=(Operator &&)=delete
- define(amrex::Vector< amrex::Geometry > a_geom, const amrex::Vector< amrex::BoxArray > &a_grids, const amrex::Vector< amrex::DistributionMapping > &a_dmap, BC::BC< Set::Scalar > &a_bc, const amrex::LPInfo &a_info=amrex::LPInfo(), const amrex::Vector< amrex::FabFactory< amrex::FArrayBox > const * > &a_factory={})
- updateSolBC(int amrlev, const amrex::MultiFab &crse_bcdata) const
- updateCorBC(int amrlev, const amrex::MultiFab &crse_bcdata) const
- prepareForSolve() override
- Fapply(int amrlev, int mglev, amrex::MultiFab &out, const amrex::MultiFab &in) const override=0
- Fsmooth(int amrlev, int mglev, amrex::MultiFab &sol, const amrex::MultiFab &rsh, int redblack) const override=0
- FFlux(int amrlev, const MFIter &mfi, const Array< FArrayBox *, AMREX_SPACEDIM > &flux, const FArrayBox &sol, Location loc, const int face_only=0) const override=0
- RegisterNewFab(amrex::Vector< amrex::MultiFab > &input)
- RegisterNewFab(amrex::Vector< std::unique_ptr< amrex::MultiFab > > &input)
- GetFab(const int num, const int amrlev, const int mglev, const amrex::MFIter &mfi)
- isSingular(int) const final
- isBottomSingular() const final
- getAScalar() const final
- getBScalar() const final
- getACoeffs(int, int) const final
- getBCoeffs(int, int) const final
- makeNLinOp(int) const final
- averageDownCoeffs()
- averageDownCoeffsSameAmrLevel(amrex::Vector< amrex::MultiFab > &)
- GetFab(const int num, const int amrlev, const int mglev, const amrex::MFIter &mfi) const
Variables
- BC::BC<Set::Scalar>* Operator::Operator< Grid::Cell >::m_bc
- amrex::Vector<std::unique_ptr<amrex::MLMGBndry> > Operator::Operator< Grid::Cell >::m_bndry_sol
- amrex::Vector<std::unique_ptr<amrex::BndryRegister> > Operator::Operator< Grid::Cell >::m_crse_sol_br
- amrex::Vector<std::unique_ptr<amrex::MLMGBndry> > Operator::Operator< Grid::Cell >::m_bndry_cor
- amrex::Vector<std::unique_ptr<amrex::BndryRegister> > Operator::Operator< Grid::Cell >::m_crse_cor_br
- amrex::Vector<amrex::Vector<std::unique_ptr<BndryCondLoc> > > Operator::Operator< Grid::Cell >::m_bcondloc
- amrex::Vector<amrex::Vector<amrex::BndryRegister> > Operator::Operator< Grid::Cell >::m_undrrelxr
- amrex::Vector<amrex::Vector<std::array<amrex::MultiMask,2*AMREX_SPACEDIM> > > Operator::Operator< Grid::Cell >::m_maskvals
- int Operator::Operator< Grid::Cell >::m_num_a_fabs
- amrex::Vector<amrex::Vector<amrex::Vector<amrex::MultiFab> > > Operator::Operator< Grid::Cell >::m_a_coeffs
Operator::Operator< Grid::Cell >::BndryCondLoc

Methods
- BndryCondLoc(const amrex::BoxArray &ba, const amrex::DistributionMapping &dm)
- setLOBndryConds(const amrex::Geometry &geom, const amrex::Real *dx, const amrex::Array< BCType, AMREX_SPACEDIM > &lobc, const amrex::Array< BCType, AMREX_SPACEDIM > &hibc, int ratio, const amrex::RealVect &a_loc)
- bndryConds(const amrex::MFIter &mfi) const
- bndryLocs(const amrex::MFIter &mfi) const
Variables
- amrex::LayoutData<BCTuple> Operator::Operator< Grid::Cell >::BndryCondLoc::bcond
- amrex::LayoutData<RealTuple> Operator::Operator< Grid::Cell >::BndryCondLoc::bcloc
Operator::Operator< Grid::Node >

Methods
- Operator()
- Operator(const amrex::Vector< amrex::Geometry > &a_geom, const amrex::Vector< amrex::BoxArray > &a_grids, const Vector< DistributionMapping > &a_dmap, const LPInfo &a_info=LPInfo(), const Vector< FabFactory< FArrayBox > const * > &a_factory={})
- ~Operator()
- Operator(const Operator &)=delete
- Operator(Operator &&)=delete
- operator=(const Operator &)=delete
- operator=(Operator &&)=delete
- define(const Vector< Geometry > &a_geom, const Vector< BoxArray > &a_grids, const Vector< DistributionMapping > &a_dmap, const LPInfo &a_info=LPInfo(), const Vector< FabFactory< FArrayBox > const * > &a_factory={})
- Geom(int amr_lev, int mglev=0) const noexcept
- Reflux(int crse_amrlev, MultiFab &res, const MultiFab &crse_sol, const MultiFab &crse_rhs, MultiFab &fine_res, MultiFab &fine_sol, const MultiFab &fine_rhs)
- Apply(int amrlev, int mglev, MultiFab &out, const MultiFab &in) const
- SetOmega(Set::Scalar a_omega)
- SetAverageDownCoeffs(bool)
- SetNormalizeDDW(bool a_normalize_ddw)
- RegisterNewFab(amrex::Vector< amrex::MultiFab > &input)
- RegisterNewFab(amrex::Vector< std::unique_ptr< amrex::MultiFab > > &input)
- GetFab(const int num, const int amrlev, const int mglev, const amrex::MFIter &mfi) const
- SetHomogeneous(bool)
- getNGrow(int=0, int=0) const override final
- solutionResidual(int amrlev, MultiFab &resid, MultiFab &x, const MultiFab &b, const MultiFab *crse_bcdata=nullptr) override final
- correctionResidual(int amrlev, int mglev, MultiFab &resid, MultiFab &x, const MultiFab &b, BCMode bc_mode, const MultiFab *crse_bcdata=nullptr) override final
- Fapply(int amrlev, int mglev, MultiFab &out, const MultiFab &in) const override=0
- averageDownCoeffs()=0
- Diagonal(bool recompute=false)
- Diagonal(int amrlev, int mglev, amrex::MultiFab &diag)
- Fsmooth(int amrlev, int mglev, MultiFab &x, const MultiFab &b) const override
- normalize(int amrlev, int mglev, MultiFab &mf) const override
- reflux(int crse_amrlev, MultiFab &res, const MultiFab &crse_sol, const MultiFab &crse_rhs, MultiFab &fine_res, MultiFab &fine_sol, const MultiFab &fine_rhs) const override
- restriction(int amrlev, int cmglev, MultiFab &crse, MultiFab &fine) const final
- interpolation(int amrlev, int fmglev, MultiFab &fine, const MultiFab &crse) const override final
- averageDownSolutionRHS(int camrlev, MultiFab &crse_sol, MultiFab &crse_rhs, const MultiFab &fine_sol, const MultiFab &fine_rhs) final
- prepareForSolve() override
- isSingular(int amrlev) const final
- isBottomSingular() const final
- applyBC(int amrlev, int mglev, MultiFab &phi, BCMode bc_mode, amrex::MLLinOp::StateMode, bool skip_fillboundary=false) const final
- fixUpResidualMask(int amrlev, iMultiFab &resmsk) final
Variables
- bool Operator::Operator< Grid::Node >::m_is_bottom_singular
- bool Operator::Operator< Grid::Node >::m_masks_built
- int Operator::Operator< Grid::Node >::m_num_a_fabs
- bool Operator::Operator< Grid::Node >::m_diagonal_computed
- amrex::Vector<amrex::Vector<amrex::Vector<amrex::MultiFab> > > Operator::Operator< Grid::Node >::m_a_coeffs
- amrex::Vector<amrex::Vector<std::unique_ptr<amrex::MultiFab> > > Operator::Operator< Grid::Node >::m_diag
- Set::Scalar Operator::Operator< Grid::Node >::m_omega
- bool Operator::Operator< Grid::Node >::m_normalize_ddw

Operator::Diagonal

src/Operator/Diagonal.cpp src/Operator/Diagonal.H

Operator::Elastic

src/Operator/Elastic.cpp src/Operator/Elastic.H

Parameter	Type	Values
small	Regularization offset value used in near-singular elastic solves. It should be small - if it is too large, you will get better convergence but less correct values!

API definitions in src/Operator/Elastic.H

Classes

Operator::Elastic

Methods
- Elastic()
- Elastic(const Vector< Geometry > &a_geom, const Vector< BoxArray > &a_grids, const Vector< DistributionMapping > &a_dmap, const LPInfo &a_info)
- ~Elastic()
- Elastic(const Elastic &)=delete
- Elastic(Elastic &&)=delete
- operator=(const Elastic &)=delete
- operator=(Elastic &&)=delete
- define(const Vector< Geometry > &a_geom, const Vector< BoxArray > &a_grids, const Vector< DistributionMapping > &a_dmap, const LPInfo &a_info=LPInfo(), const Vector< FabFactory< FArrayBox > const * > &a_factory={})
- SetHomogeneous(bool a_homogeneous) override
- SetModel(Set::Matrix4< AMREX_SPACEDIM, SYM > &a_model)
- SetModel(int amrlev, const MultiTab &a_model)
- SetModel(const amrex::Vector< MultiTab > &a_model)
- SetModel(const Set::Field< Set::Matrix4< AMREX_SPACEDIM, SYM > > &a_model)
- SetPsi(int amrlev, const amrex::MultiFab &a_psi)
- SetPsi(int amrlev, const amrex::MultiFab &a_psi, const Set::Scalar &a_psi_small)
- SetBC(::BC::Operator::Elastic::Elastic *a_bc) - The different types of Boundary Condtiions are listed in the documentation.
- GetBC()
- Strain(int amrlev, amrex::MultiFab &epsfab, const amrex::MultiFab &ufab, bool voigt=false) const - Compute strain given the displacement field by.
- Stress(int amrlev, amrex::MultiFab &sigmafab, const amrex::MultiFab &ufab, bool voigt=false, bool a_homogeneous=false) - Compute stress given the displacement field by.
- Energy(int amrlev, amrex::MultiFab &energy, const amrex::MultiFab &u, bool a_homogeneous=false) - Compute energy density given the displacement field by.
- SetBC(const std::array< std::array< BC, AMREX_SPACEDIM >, AMREX_SPACEDIM > &a_bc_lo, const std::array< std::array< BC, AMREX_SPACEDIM >, AMREX_SPACEDIM > &a_bc_hi) - This function is depricated and should not be used.
- Error0x(int amrlev, int mglev, MultiFab &R0x, const MultiFab &x) const
- SetTesting(bool a_testing)
- SetUniform(bool a_uniform)
- SetAverageDownCoeffs(bool a_average_down_coeffs) override
- Diagonal(int amrlev, int mglev, amrex::MultiFab &diag) override
- Fapply(int amrlev, int mglev, MultiFab &out, const MultiFab &in) const override final
- FFlux(int amrlev, const MFIter &mfi, const std::array< FArrayBox *, AMREX_SPACEDIM > &flux, const FArrayBox &sol, const int face_only=0) const final
- getNComp() const override
- isCrossStencil() const
- prepareForSolve() override
- averageDownCoeffs() override
- averageDownCoeffsDifferentAmrLevels(int fine_amrlev)
- averageDownCoeffsSameAmrLevel(int amrlev) - Update coarse-level AMR coefficients with data from fine level.
- FillBoundaryCoeff(MultiTab &sigma, const Geometry &geom)
- FillBoundaryCoeff(MultiFab &psi, const Geometry &geom)
Variables
- std::array<std::array<BC,AMREX_SPACEDIM>, AMREX_SPACEDIM> Operator::Elastic< SYM >::m_bc_lo - Simple arrays storing boundary conditions for each component and each face.
- std::array<std::array<BC,AMREX_SPACEDIM>, AMREX_SPACEDIM> Operator::Elastic< SYM >::m_bc_hi
- amrex::Vector<Set::Field<Set::Matrix4<AMREX_SPACEDIM,SYM> > > Operator::Elastic< SYM >::m_ddw_mf - This is a multifab-type object containing objects of type Model::Solid::Elastic::Isotropic::Isotropic (or some other model type).
- amrex::Vector<Set::Field<Set::Scalar> > Operator::Elastic< SYM >::m_psi_mf
- Set::Scalar Operator::Elastic< SYM >::m_psi_small
- bool Operator::Elastic< SYM >::m_psi_set
- bool Operator::Elastic< SYM >::m_testing
- bool Operator::Elastic< SYM >::m_uniform
- bool Operator::Elastic< SYM >::m_homogeneous
- bool Operator::Elastic< SYM >::m_average_down_coeffs
- ::BC::Operator::Elastic::Elastic* Operator::Elastic< SYM >::m_bc
- bool Operator::Elastic< SYM >::m_model_set
- bool Operator::Elastic< SYM >::m_bc_set

Operator::Implicit

Operator::Implicit::Implicit

src/Operator/Implicit/Implicit.cpp src/Operator/Implicit/Implicit.H

Set

Set::Set

src/Set/Set.cpp src/Set/Set.H

The Set namespace defines the Alamo datatypes. This includes scalars (Set::Scalar), vectors (Set::Vector), and nD tensors (Set::Tensor). Scalars are an alias for AMReX Real. Vectors and tensors are an alias for the Tuxfamily Eigen vectors and matrices, and so you can use Eigen operations on them (like A.determinant(), etc.) See the Eigen documentation for more.

The Set namespace defines the Matrix4 datatype for fourth order tensors. These can have isotropic, major, minor, majorminor, etc., symmetries.

The Set namespace also defines the Field datatype, which is where most data is stored. It is templated so that Set::Field<Set::Scalar> is a field of scalars, Set::Field<Set::Vector> is a vector field, etc. One can also have, for instance, a field of models, like Set::Field<Model::Solid::Linear::Iostropic>.

API definitions in src/Set/Set.H

Classes

Set::Field

Methods
- Field()
- Field(int a_levs, const amrex::Vector< amrex::BoxArray > &a_grids, const amrex::Vector< amrex::DistributionMapping > &a_dmap, int a_ncomp, int a_nghost)
- Field(int size)
- Define(int a_levs, const amrex::Vector< amrex::BoxArray > &a_grids, const amrex::Vector< amrex::DistributionMapping > &a_dmap, int a_ncomp, int a_nghost)
- Define(int a_lev, const amrex::BoxArray &a_grid, const amrex::DistributionMapping &a_dmap, int a_ncomp, int a_nghost)
- Copy(int, amrex::MultiFab &, int, int) const
- CopyFrom(int, amrex::MultiFab &, int, int) const
- Add(int, amrex::MultiFab &, int, int) const
- AddFrom(int, amrex::MultiFab &, int, int) const
- NComp() const
- Name(int) const
- Patch(int lev, amrex::MFIter &mfi) const &
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- CopyFrom(int a_lev, amrex::MultiFab &a_src, int a_dstcomp, int a_nghost) const
- Add(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- AddFrom(int a_lev, amrex::MultiFab &a_src, int a_srccomp, int a_nghost) const
- NComp() const
- Name(int i) const
- Copy(int a_lev, amrex::MultiFab &a_dst, int a_dstcomp, int a_nghost) const
- NComp() const
- Name(int i) const
Variables
- int Set::Field< T >::finest_level
- std::string Set::Field< T >::name
- amrex::Array4<T> Set::Field< T >::empty
Set::Field< Set::Scalar >

Methods
- Field()
- Field(int size)
- Define(int a_levs, const amrex::Vector< amrex::BoxArray > &a_grids, const amrex::Vector< amrex::DistributionMapping > &a_dmap, int a_ncomp, int a_nghost)
- Define(int a_lev, const amrex::BoxArray &a_grid, const amrex::DistributionMapping &a_dmap, int a_ncomp, int a_nghost)
- Copy(int, amrex::MultiFab &, int, int) const
- NComp() const
- Patch(const int lev, const amrex::MFIter &mfi) const &
Variables
- int Set::Field< Set::Scalar >::finest_level
- amrex::Array4<Set::Scalar> Set::Field< Set::Scalar >::empty

The isotropic tensor is defined to be

\[C_{ijkl} = \mu(d_{il}d_{jk} + d_{ik}d_{jl}) + \lambda d_{ij} d_{kl}\]

The inverse (“compliance”) tensor is

\[S_{ijkl} = ((1+\nu)/2E)(d_{il}d_{jl} + d_{ik}d_{jl}) - (\nu/E)d_{ij}d_{kl}\]

Replacing E, nu with Lame constants gives:

\[S_{ijkl} = (1/(4 \mu))(d_{il}d_{jl} + d_{ik}d_{jl}) + (\lambda/(2*\mu*(3\lambda+2\mu))) * d_{ij} * d_{kl}\]

For reference: http://solidmechanics.org/text/Chapter3_2/Chapter3_2.htm: https://en.wikipedia.org/wiki/Lam%C3%A9_parameters

Set::Matrix4_Major

src/Set/Matrix4_Major.H

Set::Matrix4_Diagonal

src/Set/Matrix4_Diagonal.H

Set::Matrix4_Full

src/Set/Matrix4_Full.H

Solver

Solver::Local

Solver::Local::CG

src/Solver/Local/CG.H

Solver::Local::Riemann

Solver::Local::Riemann::Riemann

src/Solver/Local/Riemann/Riemann.H

Solver::Local::Riemann::HLLE

src/Solver/Local/Riemann/HLLE.H

Parameter	Type	Values
lowmach	toggle to apply a low mach correction approximation	false
cutoff	cutoff value if using the low mach approximation	0.1

Solver::Local::Riemann::HLLC

src/Solver/Local/Riemann/HLLC.H

HLLC flux calculation based on equations 10.67 - 10.73 of _Riemann solvers and numerical methods for fluid dynamics_ by E.F.Toro.

Solver::Local::Riemann::Roe

src/Solver/Local/Riemann/Roe.H

This implements the Riemann Roe solver.

Notation and algorithm follow the presentation in Section 5.3.3 of Computational Gasdynamics by Culbert B. Laney (page 88)

This solver uses an optional entropy fix: Option 1: chimeracfd method https://chimeracfd.com/programming/gryphon/fluxroe.html Option 2: Eq. 4.3.67 in Computational Fluid Dynamics for Engineers and Scientists by Sreenivas Jayanti

Parameter	Type	Values
verbose	enable to dump diagnostic data if the roe solver fails	1
entropy_fix	apply entropy fix if tru	false
lowmach	Apply the lowmach fix descripte in Rieper 2010 "A low-Mach number fix for Roe’s approximate Riemann solver"	false

Solver::Nonlocal

Solver::Nonlocal::Linear

src/Solver/Nonlocal/Linear.H

Parameter	Type	Values
max_iter	Max number of iterations to perform before erroring out
bottom_max_iter	Max number of iterations on the bottom solver
max_fmg_iter	Max number of F-cycle iterations to perform
fixed_iter	Number of fixed iterations to perform before exiting gracefully
verbose	Verbosity of the solver (1-5)
pre_smooth	Number of smoothing operations before bottom solve (2)
post_smooth	Number of smoothing operations after bottom solve (2)
final_smooth	Number of final smoothing operations when smoother is used as bottom solver (8)
bottom_smooth	Additional smoothing after bottom CG solver (0)
bottom_solver	The method that is used for the multigrid bottom solve (cg, bicgstab, smoother)
bottom_tol_rel	Relative tolerance on bottom solver
bottom_tol_abs	Absolute tolerance on bottom solver
tol_rel	Relative tolerance
tol_abs	Absolute tolerance
omega	Omega (used in gauss-seidel solver)
average_down_coeffs	Whether to average down coefficients or use the ones given. (Setting this to true is important for fracture.)
normalize_ddw	Whether to normalize DDW when calculating the diagonal. This is primarily used when DDW is near-singular - like when there is a "void" region or when doing phase field fracture.
dump_on_fail	If set to true, output diagnostic multifab information whenever the MLMG solver fails to converge. (Note: you must also set `amrex.signalhandling=0` and `amrex.throw_exception=1` for this to work.)
abort_on_fail	If set to false, MLMG will not die if convergence criterion is not reached. (Note: you must also set `amrex.signalhandling=0` and `amrex.throw_exception=1` for this to work.)

Solver::Nonlocal::Newton

src/Solver/Nonlocal/Newton.H

Parameter	Type	Values
nriters	Number of newton-raphson iterations.
nrtolerance	Tolerance to use for newton-raphson convergence

Test

Test::Model

Test::Model::Interface

Test::Model::Interface::GB

Test::Model::Interface::GB::GB

src/Test/Model/Interface/GB/GB.H

Test::Numeric

Test::Numeric::Stencil

src/Test/Numeric/Stencil.H

Test::Set

Test::Set::Matrix4

src/Test/Set/Matrix4.H

Unit

Unit::Unit

src/Unit/Unit.H

Unit::Test

src/Unit/Test.H

Util

Util::Util

src/Util/Util.cpp src/Util/Util.H

Parameter	Type	Values
plot_file	Name of directory containing all output data
system.length	Set the system length unit	"m"
system.time	Set the system time unit	"s"
prob_lo	Location of the lower+left+bottom corner
prob_hi	Location of the upper_right_top corner

Util::BMP

src/Util/BMP.H

Util::Color

src/Util/Color.H

Util::MPI

src/Util/MPI.H

Util::PNG

src/Util/PNG.H

Parameter	Type	Values
filename	BMP filename.	file path
fit	how to position the image	stretch fitheight fitwidth coord
coord.lo	Lower-left coordinates of image in domain
coord.hi	Upper-right coordinates of image in domain
min	Desired minimum value to scale pixels by	0.0
max	Desired maximum value to scale pixels by	255.0