MultiAppCoordTransform Class Reference

This class contains transformation information that only exists in a context in which there are multiple applications. More...

#include <MooseAppCoordTransform.h>

Public Member Functions
	MultiAppCoordTransform (const MooseAppCoordTransform &our_app_transform)
libMesh::Point	operator() (const libMesh::Point &point) const
	Transforms a point from our domain into the reference domain.
libMesh::Point	mapBack (const libMesh::Point &point) const
	Inverse transform from the reference space to our space.
void	setTranslationVector (const libMesh::Point &translation)
	Set how much our domain should be translated in order to match a reference frame.
void	setDestinationCoordTransform (const MooseAppCoordTransform &destination_coord_transform)
	Set the destination coordinate system and destination radial and symmetry axes as appropriate for RZ or RSPHERICAL simulations.
bool	isIdentity () const
bool	hasNonTranslationTransformation () const
bool	hasCoordinateSystemTypeChange () const
Moose::CoordinateSystemType	coordinateSystem () const
void	skipCoordinateCollapsing (bool skip_coordinate_collapsing)
	set whether coordinate collapsing operations should be skipped
bool	skipCoordinateCollapsing () const
	whether coordinate collapsing operations should be skipped
const MooseAppCoordTransform &	ourAppTransform () const

Private Attributes
const MooseAppCoordTransform &	_our_app_transform
	A reference to the MooseAppCoordTransform object that describes scaling, rotation, and coordinate system transformations from our domain to the reference domain, e.g.
const MooseAppCoordTransform *	_destination_app_transform
	A pointer to the MooseAppCoordTransform object that describes scaling, rotation, and coordinate system transformations from the destination domain to the reference domain, e.g.
libMesh::Point	_translation
	Describes a forward translation transformation from our domain to the reference frame domain.
bool	_skip_coordinate_collapsing
	whether coordinate collapsing operations should be skipped

Detailed Description

This class contains transformation information that only exists in a context in which there are multiple applications.

Such information includes translation and coordinate collapsing

Definition at line 245 of file MooseAppCoordTransform.h.

Constructor & Destructor Documentation

MultiAppCoordTransform()

MultiAppCoordTransform::MultiAppCoordTransform ( const MooseAppCoordTransform &  our_app_transform )

explicit

Definition at line 462 of file MooseAppCoordTransform.C.

  : _our_app_transform(our_app_transform),
    _destination_app_transform(nullptr),
    _skip_coordinate_collapsing(false)
{
}

Member Function Documentation

coordinateSystem()

Moose::CoordinateSystemType MultiAppCoordTransform::coordinateSystem ( ) const

inline

Returns

our coordinate system

Definition at line 316 of file MooseAppCoordTransform.h.

{ return _our_app_transform._coord_type; }

hasCoordinateSystemTypeChange()

bool MultiAppCoordTransform::hasCoordinateSystemTypeChange

(

)

const

Returns

whether there are any coordinate system type change because the mapping back from RZ to XYZ for example is non-unique and would error

Definition at line 624 of file MooseAppCoordTransform.C.

{
  if (_skip_coordinate_collapsing)
    return false;
 
  if ((_our_app_transform._coord_type == Moose::COORD_XYZ &&
       (_destination_app_transform->_coord_type == Moose::COORD_RZ ||
        _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL)) ||
      (_our_app_transform._coord_type == Moose::COORD_RZ &&
       _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL))
    return true;
 
  return false;
}

Referenced by hasNonTranslationTransformation(), and MultiAppTransfer::mapBackWithoutCollapsing().

hasNonTranslationTransformation()

bool MultiAppCoordTransform::hasNonTranslationTransformation

(

)

const

Returns

whether there are any transformations other than translation in the transform. We have this method because translation has always been supported natively by the multiapp transfer system through the 'positions' parameter

Definition at line 609 of file MooseAppCoordTransform.C.

{
  if (_our_app_transform.hasScalingOrRotationTransformation())
    return true;
 
  if (_skip_coordinate_collapsing)
    return false;
 
  if (hasCoordinateSystemTypeChange())
    return true;
 
  return false;
}

Referenced by isIdentity().

isIdentity()

bool MultiAppCoordTransform::isIdentity

(

)

const

Returns

whether the coordinate transformation object modifies an incoming point, e.g. whether the transformation is anything other than the identity matrix

Definition at line 640 of file MooseAppCoordTransform.C.

{
  if (hasNonTranslationTransformation())
    return false;
 
  for (const auto i : make_range(Moose::dim))
    if (!MooseUtils::absoluteFuzzyEqual(_translation(i), 0))
      return false;
 
  return true;
}

mapBack()

Point MultiAppCoordTransform::mapBack

(

const libMesh::Point &

point

)

const

Inverse transform from the reference space to our space.

This will error if coordinate collapsing would occur in operator(). When doing inversion we invert the order of operations, e.g. we will perform

1. invert translation
2. invert rotation
3. invert scaling

Definition at line 538 of file MooseAppCoordTransform.C.

{
  Point ret(point);
 
  // Translation, rotation and scaling already applied, coordinate system conversion not supported
  if (_our_app_transform._mesh_transformed)
    return ret;
 
  // inverse translate
  ret -= _translation;
 
  // inverse rotate and then inverse scale
  if (_our_app_transform._rs_inverse)
    ret = (*_our_app_transform._rs_inverse) * ret;
 
  if (_skip_coordinate_collapsing)
    return ret;
 
  // Finally, coordinate system conversions
  if ((_our_app_transform._coord_type == Moose::COORD_XYZ &&
       (_destination_app_transform->_coord_type == Moose::COORD_RZ ||
        _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL)) ||
      (_our_app_transform._coord_type == Moose::COORD_RZ &&
       _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL))
    mooseError("Coordinate collapsing occurred in going to the reference space. There is no unique "
               "return mapping");
 
  return ret;
}

Referenced by MultiAppTransfer::mapBackWithoutCollapsing(), and MFEMMultiAppTransfer::mapPointToActiveSourceFrame().

operator()()

Point MultiAppCoordTransform::operator()

(

const libMesh::Point &

point

)

const

Transforms a point from our domain into the reference domain.

The sequence of transformations applied is:

1. Scaling
2. Rotation
3. Translation
4. Potential collapse of XYZ coordinates into RZ or RSPHERICAL coordinates depending on the destination coordinate system (if there is no destination coordinate system or the destination coordinate system is XYZ, then nothing happens in this stage)

   Parameters

   point

   A point in our domain

   Returns

   The corresponding position in the reference domain

Definition at line 470 of file MooseAppCoordTransform.C.

{
  mooseAssert(_destination_app_transform, "The destination application transform must be set");
 
  Point ret(point);
 
  // Translation, rotation and scaling already applied, coordinate system conversion not supported
  if (_our_app_transform._mesh_transformed)
    return ret;
 
  // Apply scaling and then rotation
  if (_our_app_transform._rs)
    ret = (*_our_app_transform._rs) * ret;
 
  // If this shows up in profiling we can make _translation a pointer
  ret += _translation;
 
  if (_skip_coordinate_collapsing)
    return ret;
 
  // Finally, coordinate system conversions
  if (_our_app_transform._coord_type == Moose::COORD_XYZ &&
      _destination_app_transform->_coord_type == Moose::COORD_RZ)
  {
    Real r_squared = 0;
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
      if (i != _destination_app_transform->_z_axis)
        r_squared += ret(i) * ret(i);
 
    const auto r = std::sqrt(r_squared);
    const auto z = ret(_destination_app_transform->_z_axis);
    ret = 0;
    ret(_destination_app_transform->_r_axis) = r;
    ret(_destination_app_transform->_z_axis) = z;
  }
  else if (_our_app_transform._coord_type == Moose::COORD_XYZ &&
           _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL)
  {
    Real r_squared = 0;
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
      r_squared += ret(i) * ret(i);
 
    const auto r = std::sqrt(r_squared);
    ret = 0;
    ret(_destination_app_transform->_r_axis) = r;
  }
  else if (_our_app_transform._coord_type == Moose::COORD_RZ &&
           _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL)
  {
    Real r_squared = 0;
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    {
      mooseAssert(
          i == _our_app_transform._r_axis || i == _our_app_transform._z_axis ||
              MooseUtils::absoluteFuzzyEqual(ret(i), 0),
          "Our point should be 0 if we are evaluating at an index that is neither our r or z-axis");
      r_squared += ret(i) * ret(i);
    }
 
    const auto r = std::sqrt(r_squared);
    ret = 0;
    ret(_destination_app_transform->_r_axis) = r;
  }
 
  return ret;
}

ourAppTransform()

const MooseAppCoordTransform & MultiAppCoordTransform::ourAppTransform ( ) const

inline

Returns

our moose-app coordinate transformation object

Definition at line 331 of file MooseAppCoordTransform.h.

{ return _our_app_transform; }

setDestinationCoordTransform()

void MultiAppCoordTransform::setDestinationCoordTransform

(

const MooseAppCoordTransform &

destination_coord_transform

)

Set the destination coordinate system and destination radial and symmetry axes as appropriate for RZ or RSPHERICAL simulations.

Depending on the coordinate system type of the provided coordinate transform we may perform additional transformations. For instance if the destination coordinate system is RZ and we are XYZ, we will translate our xyz points into RZ points, e.g. we will collapse from three dimensions into two. The transformation would be non-unique if we were to attempt to go from RZ to XYZ, e.g. a single RZ point could correspond to any point in a 2pi rotation around the symmetry axis

Definition at line 569 of file MooseAppCoordTransform.C.

{
  _destination_app_transform = &destination_app_transform;
 
  if (_our_app_transform._using_general_rz_coord_axes &&
      _our_app_transform.hasScalingOrRotationTransformation())
    mooseError("Scaling and rotation are currently not supported for general axisymmetric "
               "coordinate systems.");
 
  // Don't error check mismatching coordinate system types if we've been asked to skip coordinate
  // collapsing since in that case the mismatch doesn't matter
  if (_skip_coordinate_collapsing)
    return;
 
  if (_destination_app_transform->_has_different_coord_sys &&
      (_our_app_transform._has_different_coord_sys ||
       _our_app_transform._coord_type != Moose::COORD_RSPHERICAL))
    mooseError(
        "The destination coordinate system has different coordinate systems and we have coordinate "
        "system(s) that could require coordinate collapsing when transforming from our coordinate "
        "system to the destination coordinate system. Because our transform method only takes a "
        "point argument, and not subdomain arguments, the transform is ambiguous");
 
  if ((_destination_app_transform->_coord_type == Moose::COORD_RZ ||
       _destination_app_transform->_coord_type == Moose::COORD_RSPHERICAL) &&
      _our_app_transform._has_different_coord_sys)
    mooseError("When the destination coordinate system is RZ or RSPHERICAL, we have to perform "
               "coordinate collapsing based on *our* coordinate system. However, we have multiple "
               "coordinate systems, and since when evaluating transformations, we are only "
               "called with a Point argument, we do not know what subdomain we are on and "
               "consequently we do not know what coordinate collapse to apply.");
 
  if (_our_app_transform._using_general_rz_coord_axes ||
      _destination_app_transform->_using_general_rz_coord_axes)
    mooseError("If either this app or the destination app uses general axisymmetric axes, "
               "coordinate collapsing must be skipped.");
}

setTranslationVector()

void MultiAppCoordTransform::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

Definition at line 659 of file MooseAppCoordTransform.C.

{
  _translation = translation;
}

skipCoordinateCollapsing() [1/2]

bool MultiAppCoordTransform::skipCoordinateCollapsing ( ) const

inline

whether coordinate collapsing operations should be skipped

Definition at line 326 of file MooseAppCoordTransform.h.

{ return _skip_coordinate_collapsing; }

skipCoordinateCollapsing() [2/2]

void MultiAppCoordTransform::skipCoordinateCollapsing

(

bool

skip_coordinate_collapsing

)

set whether coordinate collapsing operations should be skipped

Definition at line 653 of file MooseAppCoordTransform.C.

{
  _skip_coordinate_collapsing = skip_coordinate_collapsing;
}

Referenced by MultiApp::getBoundingBox(), and MultiAppTransfer::mapBackWithoutCollapsing().

Member Data Documentation

_destination_app_transform

const MooseAppCoordTransform* MultiAppCoordTransform::_destination_app_transform

private

A pointer to the MooseAppCoordTransform object that describes scaling, rotation, and coordinate system transformations from the destination domain to the reference domain, e.g.

transformations that occur irrespective of the existence of other applications This attribute is currently mostly providing only the coordinate system for conversions and sanity checking. The actual transformation of destination app points in transfers is done by the MultiAppCoordTransform for the other direction

Definition at line 345 of file MooseAppCoordTransform.h.

Referenced by hasCoordinateSystemTypeChange(), mapBack(), operator()(), and setDestinationCoordTransform().

_our_app_transform

const MooseAppCoordTransform& MultiAppCoordTransform::_our_app_transform

private

A reference to the MooseAppCoordTransform object that describes scaling, rotation, and coordinate system transformations from our domain to the reference domain, e.g.

transformations that occur irrespective of the existence of other applications

Definition at line 337 of file MooseAppCoordTransform.h.

Referenced by coordinateSystem(), hasCoordinateSystemTypeChange(), hasNonTranslationTransformation(), mapBack(), operator()(), ourAppTransform(), and setDestinationCoordTransform().

_skip_coordinate_collapsing

bool MultiAppCoordTransform::_skip_coordinate_collapsing

private

whether coordinate collapsing operations should be skipped

Definition at line 351 of file MooseAppCoordTransform.h.

Referenced by hasCoordinateSystemTypeChange(), hasNonTranslationTransformation(), mapBack(), operator()(), setDestinationCoordTransform(), skipCoordinateCollapsing(), and skipCoordinateCollapsing().

_translation

libMesh::Point MultiAppCoordTransform::_translation

private

Describes a forward translation transformation from our domain to the reference frame domain.

Definition at line 348 of file MooseAppCoordTransform.h.

Referenced by isIdentity(), mapBack(), operator()(), and setTranslationVector().

---

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

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