MooseAppCoordTransform Class Reference

#include <MooseAppCoordTransform.h>

Public Types
enum	Direction : unsigned int { X = 0 , Y , Z , INVALID }
	A class scope enumeration for conveniently denoting X, Y, and Z axis directions. More...
typedef std::tuple< short int, Real, short int, std::array< Real, 3 >, int, unsigned int, unsigned int, short int, short int, short int >	MinimalData
	A typedef for conveniency that describes the minimal data necessary to broadcast and build a MooseAppCoordTransform.

Public Member Functions
	MooseAppCoordTransform ()
	Default constructor.
	MooseAppCoordTransform (const MooseAppCoordTransform &other)
	MooseAppCoordTransform (MooseAppCoordTransform &&other)=default
	MooseAppCoordTransform (const MinimalData &minimal_data)
	Construct a coordinate transformation object from the minimal set of data required.
	MooseAppCoordTransform (const MooseMesh &mesh)
	Construct this object from the provided mesh and its input parameters.
	~MooseAppCoordTransform ()=default
MooseAppCoordTransform &	operator= (const MooseAppCoordTransform &other)
MooseAppCoordTransform &	operator= (MooseAppCoordTransform &&other)=default
MinimalData	minimalDataDescription () const
Moose::CoordinateSystemType	coordinateSystem () const
void	setTranslationVector (const libMesh::Point &translation)
	Set how much our domain should be translated in order to match a reference frame.
void	setUpDirection (Direction up_direction)
	Will setup a rotation transformation.
void	setRotation (Real alpha, Real beta, Real gamma)
	Setup an \emph extrinsic rotation defined in the following way:
void	setLengthUnit (const MooseUnits &length_unit)
	Set the scaling transformation.
const MooseUnits &	lengthUnit () const
void	setCoordinateSystem (Moose::CoordinateSystemType system_type, Direction rz_symmetry_axis=INVALID)
	Set our coordinate system.
void	setCoordinateSystem (const MooseMesh &mesh)
	Set our coordinate system based on the MooseMesh coordinate system data.
void	computeRS ()
	Compute the RS and (RS)^{-1} matrices.
void	transformMesh (MooseMesh &mesh, const libMesh::Point &translation)
	Transforms the entire mesh with the coordinate transform This can be done to output in position, or to avoid transforming on every data point.
bool	hasScalingOrRotationTransformation () const
	Returns true if the app has scaling and/or rotation transformation.

Static Public Member Functions
static InputParameters	validParams ()
	Describes the parameters this object can take to setup transformations.

Private Member Functions
Direction	processZAxis (Direction z_axis)
	If the coordinate system type is RZ, then we return the provided argument.

Private Attributes
std::unique_ptr< libMesh::RealTensorValue >	_scale
	Represents a forward scaling transformation from our units to reference frame units of meters.
std::unique_ptr< libMesh::RealTensorValue >	_rotate
	Represents a forward rotation transformation from our domain to the reference frame domain.
std::unique_ptr< libMesh::RealTensorValue >	_rs
	Represents the product of rotation and scaling transformations.
std::unique_ptr< libMesh::RealTensorValue >	_rs_inverse
	Represents the inverse of the product of rotation and scaling transformations.
Moose::CoordinateSystemType	_coord_type
	Our coordinate system.
Direction	_r_axis
	If we are RZ or RSPHERICAL, the Cartesian axis corresponding to the radial coordinate.
Direction	_z_axis
	If we are RZ, the Cartesian axis corresponding to the axial/axis-of-symmetry coordinate.
bool	_has_different_coord_sys
	Whether we have different coordinate systems within our single domain.
bool	_using_general_rz_coord_axes
	Whether general axisymmetric coordinate axes are being used.
MooseUnits	_length_unit
	How much distance one mesh length unit represents, e.g. 1 cm, 1 nm, 1 ft, 5 inches.
std::array< Real, 3 >	_euler_angles
	The Euler angles describing rotation.
bool	_mesh_transformed
	Whether the mesh has been translated and rotated.

Friends
class	MultiAppCoordTransform

Detailed Description

Definition at line 24 of file MooseAppCoordTransform.h.

Member Typedef Documentation

MinimalData

typedef std::tuple<short int, Real, short int, std::array<Real, 3>, int, unsigned int, unsigned int, short int, short int, short int> MooseAppCoordTransform::MinimalData

A typedef for conveniency that describes the minimal data necessary to broadcast and build a MooseAppCoordTransform.

The data is such: 0: whether a scaling matrix exists 1: a value describing the scaling 2: whether a rotation matrix exists 3: the Euler angles describing the rotation 4: the coordinate system type 5: the r-axis direction 6: the z-axis direction 7: whether there are multiple coordinate system types on the mesh 8: whether general axisymmetric coordinate axes are being used 9: whether the mesh has been transformed using the transform

Definition at line 62 of file MooseAppCoordTransform.h.

Member Enumeration Documentation

Direction

enum MooseAppCoordTransform::Direction : unsigned int

A class scope enumeration for conveniently denoting X, Y, and Z axis directions.

Enumerator
X
Y
Z
INVALID

Definition at line 30 of file MooseAppCoordTransform.h.

  {
    X = 0,
    Y,
    Z,
    INVALID
  };

Constructor & Destructor Documentation

MooseAppCoordTransform() [1/5]

MooseAppCoordTransform::MooseAppCoordTransform

(

)

Default constructor.

If no other methods are called to set rotation, translation, or scaling, then when operator() is called the result will be the passed-in point, e.g. no transformation will occur

Definition at line 303 of file MooseAppCoordTransform.C.

  : _coord_type(Moose::COORD_XYZ),
    _r_axis(INVALID),
    _z_axis(INVALID),
    _has_different_coord_sys(false),
    _using_general_rz_coord_axes(false),
    _length_unit(std::string("1*m")),
    _euler_angles(),
    _mesh_transformed(false)
{
}

MooseAppCoordTransform() [2/5]

MooseAppCoordTransform::MooseAppCoordTransform

(

const MooseAppCoordTransform &

other

)

Definition at line 315 of file MooseAppCoordTransform.C.

  : _coord_type(other._coord_type),
    _r_axis(other._r_axis),
    _z_axis(other._z_axis),
    _has_different_coord_sys(other._has_different_coord_sys),
    _using_general_rz_coord_axes(other._using_general_rz_coord_axes),
    _length_unit(other._length_unit),
    _euler_angles(other._euler_angles),
    _mesh_transformed(other._mesh_transformed)
{
  if (other._scale)
    _scale = std::make_unique<RealTensorValue>(*other._scale);
  if (other._rotate)
    _rotate = std::make_unique<RealTensorValue>(*other._rotate);
  computeRS();
}

MooseAppCoordTransform() [3/5]

MooseAppCoordTransform::MooseAppCoordTransform ( MooseAppCoordTransform &&  other )

default

MooseAppCoordTransform() [4/5]

MooseAppCoordTransform::MooseAppCoordTransform

(

const MinimalData &

minimal_data

)

Construct a coordinate transformation object from the minimal set of data required.

Definition at line 332 of file MooseAppCoordTransform.C.

  : _coord_type(static_cast<Moose::CoordinateSystemType>(std::get<4>(minimal_data))),
    _r_axis(static_cast<Direction>(std::get<5>(minimal_data))),
    _z_axis(static_cast<Direction>(std::get<6>(minimal_data))),
    _has_different_coord_sys(std::get<7>(minimal_data)),
    _using_general_rz_coord_axes(std::get<8>(minimal_data)),
    _length_unit(std::string("1*m")),
    _euler_angles(std::get<3>(minimal_data)),
    _mesh_transformed(std::get<9>(minimal_data))
{
  if (std::get<0>(minimal_data))
    setLengthUnit(MooseUnits(std::to_string(std::get<1>(minimal_data)) + "*m"));
  if (std::get<2>(minimal_data))
    _rotate = std::make_unique<RealTensorValue>(RealTensorValue::extrinsic_rotation_matrix(
        _euler_angles[0], _euler_angles[1], _euler_angles[2]));
  computeRS();
}

MooseAppCoordTransform() [5/5]

MooseAppCoordTransform::MooseAppCoordTransform

(

const MooseMesh &

mesh

)

Construct this object from the provided mesh and its input parameters.

See the validParams implementation for valid parameters

Definition at line 257 of file MooseAppCoordTransform.C.

  : _coord_type(Moose::COORD_XYZ),
    _r_axis(INVALID),
    _z_axis(INVALID),
    _has_different_coord_sys(false),
    _using_general_rz_coord_axes(false),
    _length_unit(std::string("1*m")),
    _euler_angles(),
    _mesh_transformed(false)
{
  //
  // Coordinate system transformation
  //
  setCoordinateSystem(mesh);
 
  const auto & params = mesh.parameters();
 
  //
  // Rotation
  //
  const bool has_alpha = params.isParamValid("alpha_rotation");
  const bool has_beta = params.isParamValid("beta_rotation");
  const bool has_gamma = params.isParamValid("gamma_rotation");
  const auto & up_direction = params.get<MooseEnum>("up_direction");
 
  if (has_alpha || has_beta || has_gamma)
  {
    if (up_direction.isValid())
      mooseError("Cannot simultaneously set rotation angles as well as an up direction");
 
    const auto alpha = (has_alpha ? params.get<Real>("alpha_rotation") : Real(0));
    const auto beta = (has_beta ? params.get<Real>("beta_rotation") : Real(0));
    const auto gamma = (has_gamma ? params.get<Real>("gamma_rotation") : Real(0));
 
    setRotation(alpha, beta, gamma);
  }
  else if (up_direction.isValid())
    setUpDirection(Direction(static_cast<unsigned int>(int(up_direction))));
 
  //
  // Scaling
  //
  if (params.isParamValid("length_unit"))
    setLengthUnit(MooseUnits(params.get<std::string>("length_unit")));
}

~MooseAppCoordTransform()

MooseAppCoordTransform::~MooseAppCoordTransform ( )

default

Member Function Documentation

computeRS()

void MooseAppCoordTransform::computeRS

(

)

Compute the RS and (RS)^{-1} matrices.

Definition at line 393 of file MooseAppCoordTransform.C.

{
  if (_scale || _rotate)
  {
    _rs = std::make_unique<RealTensorValue>(RealTensorValue(1, 0, 0, 0, 1, 0, 0, 0, 1));
 
    if (_scale)
      *_rs = *_scale * *_rs;
    if (_rotate)
      *_rs = *_rotate * *_rs;
 
    _rs_inverse = std::make_unique<RealTensorValue>(_rs->inverse());
  }
  else
  {
    _rs.reset();
    _rs_inverse.reset();
  }
}

Referenced by MooseAppCoordTransform(), MooseAppCoordTransform(), operator=(), setLengthUnit(), setRotation(), and setUpDirection().

coordinateSystem()

Moose::CoordinateSystemType MooseAppCoordTransform::coordinateSystem ( ) const

inline

Returns

our coordinate system

Definition at line 107 of file MooseAppCoordTransform.h.

{ return _coord_type; }

hasScalingOrRotationTransformation()

bool MooseAppCoordTransform::hasScalingOrRotationTransformation

(

)

const

Returns true if the app has scaling and/or rotation transformation.

Definition at line 441 of file MooseAppCoordTransform.C.

{
  if (_rs)
    for (const auto i : make_range(Moose::dim))
      for (const auto j : make_range(Moose::dim))
      {
        const auto matrix_elem = (*_rs)(i, j);
        if (i == j)
        {
          if (!MooseUtils::absoluteFuzzyEqual(matrix_elem, 1))
            return true;
        }
        else if (!MooseUtils::absoluteFuzzyEqual(matrix_elem, 0))
          return true;
      }
 
  return false;
}

Referenced by FEProblemBase::checkProblemIntegrity(), MultiAppCoordTransform::hasNonTranslationTransformation(), MultiAppCoordTransform::setDestinationCoordTransform(), and transformMesh().

lengthUnit()

const MooseUnits & MooseAppCoordTransform::lengthUnit ( ) const

inline

Returns

How much distance one mesh length unit represents, e.g. 1 cm, 1 nm, 1 ft, 5 inches

Definition at line 158 of file MooseAppCoordTransform.h.

{ return _length_unit; }

minimalDataDescription()

MooseAppCoordTransform::MinimalData MooseAppCoordTransform::minimalDataDescription

(

)

const

Returns

the minimal data necessary to describe this coordinate transformation object. This data can be broadcast and used to construct identical coordinate transformation objects on other processes

Definition at line 351 of file MooseAppCoordTransform.C.

{
  const Real scale_factor = _scale ? (*_scale)(0, 0) : 1;
  return {static_cast<short int>(bool(_scale)),
          scale_factor,
          static_cast<short int>(bool(_rotate)),
          _euler_angles,
          static_cast<int>(_coord_type),
          static_cast<unsigned int>(_r_axis),
          static_cast<unsigned int>(_z_axis),
          static_cast<short int>(_has_different_coord_sys),
          static_cast<short int>(_using_general_rz_coord_axes),
          static_cast<short int>(_mesh_transformed)};
}

operator=() [1/2]

MooseAppCoordTransform & MooseAppCoordTransform::operator=

(

const MooseAppCoordTransform &

other

)

Definition at line 367 of file MooseAppCoordTransform.C.

{
  _coord_type = other._coord_type;
  _r_axis = other._r_axis;
  _z_axis = other._z_axis;
  _has_different_coord_sys = other._has_different_coord_sys;
  _using_general_rz_coord_axes = other._using_general_rz_coord_axes;
  _length_unit = other._length_unit;
  _euler_angles = other._euler_angles;
  _mesh_transformed = other._mesh_transformed;
 
  if (other._scale)
    _scale = std::make_unique<RealTensorValue>(*other._scale);
  else
    _scale.reset();
  if (other._rotate)
    _rotate = std::make_unique<RealTensorValue>(*other._rotate);
  else
    _rotate.reset();
 
  computeRS();
 
  return *this;
}

operator=() [2/2]

MooseAppCoordTransform & MooseAppCoordTransform::operator= ( MooseAppCoordTransform &&  other )

default

processZAxis()

MooseAppCoordTransform::Direction MooseAppCoordTransform::processZAxis ( Direction  z_axis )

private

If the coordinate system type is RZ, then we return the provided argument.

Otherwise we return INVALID

Definition at line 18 of file MooseAppCoordTransform.C.

{
  return _coord_type == Moose::COORD_RZ ? z_axis : INVALID;
}

Referenced by setUpDirection().

setCoordinateSystem() [1/2]

void MooseAppCoordTransform::setCoordinateSystem

(

const MooseMesh &

mesh

)

Set our coordinate system based on the MooseMesh coordinate system data.

Definition at line 160 of file MooseAppCoordTransform.C.

{
  const auto & params = mesh.parameters();
 
  // If we have multiple different coordinate system types in our problem, we
  // take note of it because that can cause issues if there is a non-Cartesian
  // destination coordinate system
  const auto & coord_sys = mesh.getCoordSystem();
  std::unordered_set<Moose::CoordinateSystemType> coord_types;
  auto map_it = coord_sys.begin();
  // It's possible that the mesh is not in a complete state
  if (map_it == coord_sys.end())
    setCoordinateSystem(Moose::COORD_XYZ);
  else
    setCoordinateSystem(
        map_it->second,
        Direction(static_cast<unsigned int>(int(params.get<MooseEnum>("rz_coord_axis")))));
  for (; map_it != coord_sys.end(); ++map_it)
    coord_types.insert(map_it->second);
 
  _has_different_coord_sys = coord_types.size() > 1;
 
  if (mesh.usingGeneralAxisymmetricCoordAxes())
    _using_general_rz_coord_axes = true;
}

setCoordinateSystem() [2/2]

void MooseAppCoordTransform::setCoordinateSystem	(	Moose::CoordinateSystemType	system_type,
		Direction	rz_symmetry_axis = INVALID
	)

Set our coordinate system.

Parameters

system_type	the coordinate system type
rz_symmetry_axis	the axial coordinate, e.g. the axis of symmetry

Definition at line 141 of file MooseAppCoordTransform.C.

{
  _coord_type = coord_type;
 
  if (_coord_type == Moose::COORD_RZ)
  {
    if (rz_symmetry_axis == INVALID)
      mooseError("For RZ coordinate systems, the 'rz_symmetry_axis' parameter must be provided to "
                 "'MooseAppCoordTransform::setCoordinateSystem'");
 
    _z_axis = rz_symmetry_axis;
    _r_axis = _z_axis == X ? Y : X;
  }
  else if (_coord_type == Moose::COORD_RSPHERICAL)
    _r_axis = X;
}

Referenced by MooseAppCoordTransform(), and setCoordinateSystem().

setLengthUnit()

void MooseAppCoordTransform::setLengthUnit

(

const MooseUnits &

length_unit

)

Set the scaling transformation.

Parameters

length_unit

How much distance one mesh length unit represents, e.g. 1 cm, 1 nm, 1 ft, 5 inches. We will save off the value provided to this in the _length_unit data member as well as set the scaling transform

Definition at line 131 of file MooseAppCoordTransform.C.

{
  _length_unit = length_unit;
  const auto scale = Real(_length_unit / MooseUnits("m"));
  _scale =
      std::make_unique<RealTensorValue>(RealTensorValue(scale, 0, 0, 0, scale, 0, 0, 0, scale));
  computeRS();
}

Referenced by MooseAppCoordTransform(), and MooseAppCoordTransform().

setRotation()

void MooseAppCoordTransform::setRotation	(	Real	alpha,
		Real	beta,
		Real	gamma
	)

Setup an \emph extrinsic rotation defined in the following way:

1. rotate by alpha degrees about the z-axis
2. rotate by beta degrees about the x-axis
3. rotate by gamma degrees about the z-axis Definitions of the resulting matrix are found in the last row of the Proper Euler angles column of https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix. These rotation angles should describe how points in our domain should be rotated in order to arrive back in the reference frame. For instance, in 2D your mesh may appear 90 degrees rotated (around the z-axis) with respect to the reference frame. In such a case, the angle set you should provide to this function is {-90, 0, 0}, e.g. provide forward transformation angles that will map points from your domain to the reference domain

If our coordinate system is RZ, then only certain values of alpha, beta, and gamma will be accepted such that the radial and axial coordinates are rotated onto Cartesian axes and the resulting radial coordinate is non-negative

Definition at line 89 of file MooseAppCoordTransform.C.

{
  const bool must_rotate_axes =
      _coord_type == Moose::COORD_RZ || _coord_type == Moose::COORD_RSPHERICAL;
  bool axes_rotated = false;
  if (must_rotate_axes)
  {
    const auto angles = std::make_tuple(alpha, beta, gamma);
    if (angles == std::make_tuple(0, 90, 0))
    {
      if (_r_axis == X)
      {
        mooseAssert((_coord_type == Moose::COORD_RZ && _z_axis == Y) ||
                        (_coord_type == Moose::COORD_RSPHERICAL && _z_axis == INVALID),
                    "'_z_axis' is not an expected value");
        _r_axis = X;
        _z_axis = _coord_type == Moose::COORD_RZ ? Z : INVALID;
      }
      else if (_r_axis == Y)
      {
        mooseAssert((_coord_type == Moose::COORD_RZ && _z_axis == X) ||
                        (_coord_type == Moose::COORD_RSPHERICAL && _z_axis == INVALID),
                    "'_z_axis' is not an expected value");
        _r_axis = Z;
        _z_axis = _coord_type == Moose::COORD_RZ ? X : INVALID;
      }
      axes_rotated = true;
    }
  }
 
  _euler_angles = {{alpha, beta, gamma}};
  _rotate = std::make_unique<RealTensorValue>(
      RealTensorValue::extrinsic_rotation_matrix(alpha, beta, gamma));
  computeRS();
 
  if (must_rotate_axes && !axes_rotated)
    mooseError("Unsupported manual angle prescription in 'MooseAppCoordTransform::setRotation'. "
               "For non-Cartesian coordinate systems, the only currently supported rotation is "
               "(alpha, beta, gamma) = (0, 90, 0)");
}

Referenced by MooseAppCoordTransform().

setTranslationVector()

void MooseAppCoordTransform::setTranslationVector

(

const libMesh::Point &

translation

)

Set how much our domain should be translated in order to match a reference frame.

In practice we choose the parent application to be the reference frame with respect to translation, e.g. the parent application origin is the reference frame origin, and we set the translation vectors of child applications to the multiapp positions parameter. Similarly to the setRotation with angles API, this represents a forward transformation from our domain to the reference domain

setUpDirection()

void MooseAppCoordTransform::setUpDirection

(

Direction

up_direction

)

Will setup a rotation transformation.

The rotation transformation will be a single 90-degree rotation defined such that a point on the axis specified by up_direction is rotated onto the Y-axis, which is our canonical/reference-frame up-direction

Parameters

up_direction

What direction corresponds to "up" (e.g. the opposite direction of gravity) in our moose mesh

Definition at line 24 of file MooseAppCoordTransform.C.

{
  Real alpha = 0, beta = 0, gamma = 0;
 
  const bool must_rotate_axes =
      _coord_type == Moose::COORD_RZ || _coord_type == Moose::COORD_RSPHERICAL;
  // Don't error immediately for unit testing purposes
  bool negative_radii = false;
 
  if (up_direction == X)
  {
    alpha = 90, beta = 0, gamma = 0;
    if (must_rotate_axes)
    {
      if (_r_axis == X)
      {
        _r_axis = Y;
        _z_axis = processZAxis(X);
      }
      else if (_r_axis == Y)
      {
        negative_radii = true;
        _r_axis = X;
        _z_axis = processZAxis(Y);
      }
      else
        mooseError("Bad r-axis value");
    }
  }
  else if (up_direction == Y)
    alpha = 0, beta = 0, gamma = 0;
  else if (up_direction == Z)
  {
    alpha = 0, beta = -90, gamma = 0;
    if (must_rotate_axes)
    {
      if (_r_axis == X)
      {
        _r_axis = X;
        _z_axis = processZAxis(Z);
      }
      else if (_r_axis == Y)
      {
        negative_radii = true;
        _r_axis = Z;
        _z_axis = processZAxis(X);
      }
      else
        mooseError("Bad r-axis value");
    }
  }
  else
    mooseError("Bad up direction value");
 
  _euler_angles = {{alpha, beta, gamma}};
 
  _rotate = std::make_unique<RealTensorValue>(
      RealTensorValue::extrinsic_rotation_matrix(alpha, beta, gamma));
  computeRS();
 
  if (negative_radii)
    mooseError("Rotation yields negative radial values");
}

Referenced by MooseAppCoordTransform().

transformMesh()

void MooseAppCoordTransform::transformMesh	(	MooseMesh &	mesh,
		const libMesh::Point &	translation
	)

Transforms the entire mesh with the coordinate transform This can be done to output in position, or to avoid transforming on every data point.

Parameters

mesh	the mesh to modify, usually the child app mesh
translation	the translation to apply to the mesh, often the app position

Definition at line 414 of file MooseAppCoordTransform.C.

{
  // Transforming a RZ or R-spherical mesh doesnt always make sense, disallow it
  if (_coord_type != Moose::COORD_XYZ)
    mooseError("Running MultiApps 'in position' is only supported for XYZ coordinate systems");
 
  if (_using_general_rz_coord_axes && hasScalingOrRotationTransformation())
    mooseError("Scaling and rotation are currently not supported for general axisymmetric "
               "coordinate systems.");
 
  if (_mesh_transformed)
    mooseError("App mesh is being transformed twice");
 
  // Apply all the transformation to the mesh
  if (_scale)
    MeshTools::Modification::scale(mesh, (*_scale)(0, 0), (*_scale)(1, 1), (*_scale)(2, 2));
  if (_rotate)
    MeshTools::Modification::rotate(mesh, _euler_angles[0], _euler_angles[1], _euler_angles[2]);
  if (translation != Point(0, 0, 0))
    MeshTools::Modification::translate(mesh, translation(0), translation(1), translation(2));
 
  // Translation, scaling and rotation need not be applied anymore when performing coordinate
  // transforms
  _mesh_transformed = true;
}

validParams()

InputParameters MooseAppCoordTransform::validParams ( )

static

Describes the parameters this object can take to setup transformations.

These include parameters related to coordinate system type, rotation, and scaling

One entry of coord system per block, the size of _blocks and _coord_sys has to match, except:

1. _blocks.size() == 0, then there needs to be just one entry in _coord_sys, which will be set for the whole domain
2. _blocks.size() > 0 and no coordinate system was specified, then the whole domain will be XYZ.
3. _blocks.size() > 0 and one coordinate system was specified, then the whole domain will be that system.

Definition at line 187 of file MooseAppCoordTransform.C.

{
  auto params = emptyInputParameters();
  params.addDeprecatedParam<std::vector<SubdomainName>>(
      "block",
      "Block IDs for the coordinate systems.",
      "Please use the 'coord_block' parameter instead.");
  params.addParam<std::vector<SubdomainName>>(
      "coord_block",
      "Block IDs for the coordinate systems. If this parameter is specified, then it must "
      "encompass all the subdomains on the mesh.");
  MultiMooseEnum coord_types("XYZ RZ RSPHERICAL", "XYZ");
  MooseEnum rz_coord_axis("X=0 Y=1", "Y");
  params.addParam<MultiMooseEnum>(
      "coord_type", coord_types, "Type of the coordinate system per block param");
  params.addParam<MooseEnum>(
      "rz_coord_axis", rz_coord_axis, "The rotation axis (X | Y) for axisymmetric coordinates");
  params.addParam<std::vector<SubdomainName>>(
      "rz_coord_blocks", "Blocks using general axisymmetric coordinate systems");
  params.addParam<std::vector<Point>>("rz_coord_origins",
                                      "Axis origin points for each block in 'rz_coord_blocks'");
  params.addParam<std::vector<RealVectorValue>>(
      "rz_coord_directions", "Axis directions for each block in 'rz_coord_blocks'");
  params.addParam<std::string>(
      "length_unit",
      "How much distance one mesh length unit represents, e.g. 1 cm, 1 nm, 1 ft, 5inches");
  params.addRangeCheckedParam<Real>(
      "alpha_rotation",
      "-180<alpha_rotation<=180",
      "The number of degrees that the domain should be alpha-rotated using the Euler "
      "angle ZXZ convention from https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix in "
      "order to align with a canonical physical space of your choosing.");
  params.addRangeCheckedParam<Real>(
      "beta_rotation",
      "-180<beta_rotation<=180",
      "The number of degrees that the domain should be beta-rotated using the Euler "
      "angle ZXZ convention from https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix in "
      "order to align with a canonical physical space of your choosing.");
  params.addRangeCheckedParam<Real>(
      "gamma_rotation",
      "-180<gamma_rotation<=180",
      "The number of degrees that the domain should be gamma-rotated using the Euler "
      "angle ZXZ convention from https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix in "
      "order to align with a canonical physical space of your choosing.");
  MooseEnum up_direction("X=0 Y=1 Z=2");
  params.addParam<MooseEnum>(
      "up_direction",
      up_direction,
      "Specify what axis corresponds to the up direction in physical space (the opposite of the "
      "gravity vector if you will). If this parameter is provided, we will perform a single 90 "
      "degree rotation of the domain--if the provided axis is 'x' or 'z', we will not rotate if "
      "the axis is 'y'--such that a point which was on the provided axis will now lie on the "
      "y-axis, e.g. the y-axis is our canonical up direction. If you want finer grained control "
      "than this, please use the 'alpha_rotation', 'beta_rotation', and 'gamma_rotation' "
      "parameters.");
  params.addParamNamesToGroup(
      "block coord_type coord_block rz_coord_axis rz_coord_blocks rz_coord_origins "
      "rz_coord_directions",
      "Coordinate system");
  params.addParamNamesToGroup(
      "length_unit alpha_rotation beta_rotation gamma_rotation up_direction",
      "Transformations relative to parent application frame of reference");
  return params;
}

Referenced by FEProblemBase::checkProblemIntegrity(), and MooseMesh::validParams().

Friends And Related Symbol Documentation

MultiAppCoordTransform

friend class MultiAppCoordTransform

friend

Definition at line 238 of file MooseAppCoordTransform.h.

Member Data Documentation

_coord_type

Moose::CoordinateSystemType MooseAppCoordTransform::_coord_type

private

Our coordinate system.

Definition at line 212 of file MooseAppCoordTransform.h.

Referenced by coordinateSystem(), MultiAppCoordTransform::coordinateSystem(), MultiAppCoordTransform::hasCoordinateSystemTypeChange(), MultiAppCoordTransform::mapBack(), minimalDataDescription(), MultiAppCoordTransform::operator()(), operator=(), processZAxis(), setCoordinateSystem(), MultiAppCoordTransform::setDestinationCoordTransform(), setRotation(), setUpDirection(), and transformMesh().

_euler_angles

std::array<Real, 3> MooseAppCoordTransform::_euler_angles

private

The Euler angles describing rotation.

Definition at line 232 of file MooseAppCoordTransform.h.

Referenced by minimalDataDescription(), MooseAppCoordTransform(), operator=(), setRotation(), setUpDirection(), and transformMesh().

_has_different_coord_sys

bool MooseAppCoordTransform::_has_different_coord_sys

private

Whether we have different coordinate systems within our single domain.

If we do, this will be problematic if we need to collapse from our space into an RZ or RSPHERICAL space because we are only ever provided with a point argument and not a subdomain ID argument. Consequently we will not know in what coordinate system our point lies and will not know how to perform the dimension collapse, and so we will error

Definition at line 223 of file MooseAppCoordTransform.h.

Referenced by minimalDataDescription(), operator=(), setCoordinateSystem(), and MultiAppCoordTransform::setDestinationCoordTransform().

_length_unit

MooseUnits MooseAppCoordTransform::_length_unit

private

How much distance one mesh length unit represents, e.g. 1 cm, 1 nm, 1 ft, 5 inches.

Definition at line 229 of file MooseAppCoordTransform.h.

Referenced by lengthUnit(), operator=(), and setLengthUnit().

_mesh_transformed

bool MooseAppCoordTransform::_mesh_transformed

private

Whether the mesh has been translated and rotated.

In this case, applying the transform every time is no longer necessary

Definition at line 236 of file MooseAppCoordTransform.h.

Referenced by MultiAppCoordTransform::mapBack(), minimalDataDescription(), MultiAppCoordTransform::operator()(), operator=(), and transformMesh().

_r_axis

Direction MooseAppCoordTransform::_r_axis

private

If we are RZ or RSPHERICAL, the Cartesian axis corresponding to the radial coordinate.

Definition at line 214 of file MooseAppCoordTransform.h.

Referenced by minimalDataDescription(), MultiAppCoordTransform::operator()(), operator=(), setCoordinateSystem(), setRotation(), and setUpDirection().

_rotate

std::unique_ptr<libMesh::RealTensorValue> MooseAppCoordTransform::_rotate

private

Represents a forward rotation transformation from our domain to the reference frame domain.

Definition at line 203 of file MooseAppCoordTransform.h.

Referenced by computeRS(), minimalDataDescription(), MooseAppCoordTransform(), MooseAppCoordTransform(), operator=(), setRotation(), setUpDirection(), and transformMesh().

_rs

std::unique_ptr<libMesh::RealTensorValue> MooseAppCoordTransform::_rs

private

Represents the product of rotation and scaling transformations.

Definition at line 206 of file MooseAppCoordTransform.h.

Referenced by computeRS(), hasScalingOrRotationTransformation(), and MultiAppCoordTransform::operator()().

_rs_inverse

std::unique_ptr<libMesh::RealTensorValue> MooseAppCoordTransform::_rs_inverse

private

Represents the inverse of the product of rotation and scaling transformations.

Definition at line 209 of file MooseAppCoordTransform.h.

Referenced by computeRS(), and MultiAppCoordTransform::mapBack().

_scale

std::unique_ptr<libMesh::RealTensorValue> MooseAppCoordTransform::_scale

private

Represents a forward scaling transformation from our units to reference frame units of meters.

This matrix will be diagonal

Definition at line 200 of file MooseAppCoordTransform.h.

Referenced by computeRS(), minimalDataDescription(), MooseAppCoordTransform(), operator=(), setLengthUnit(), and transformMesh().

_using_general_rz_coord_axes

bool MooseAppCoordTransform::_using_general_rz_coord_axes

private

Whether general axisymmetric coordinate axes are being used.

Definition at line 226 of file MooseAppCoordTransform.h.

Referenced by minimalDataDescription(), operator=(), setCoordinateSystem(), MultiAppCoordTransform::setDestinationCoordTransform(), and transformMesh().

_z_axis

Direction MooseAppCoordTransform::_z_axis

private

If we are RZ, the Cartesian axis corresponding to the axial/axis-of-symmetry coordinate.

Definition at line 216 of file MooseAppCoordTransform.h.

Referenced by minimalDataDescription(), MultiAppCoordTransform::operator()(), operator=(), setCoordinateSystem(), setRotation(), and setUpDirection().

---

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

• include/utils/MooseAppCoordTransform.h
• src/utils/MooseAppCoordTransform.C