MooseAppCoordTransform.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseTypes.h"
#include "Units.h"
#include "libmesh/point.h"
#include "libmesh/tensor_value.h"
#include <memory>
#include <string>
#include <array>
#include <tuple>
 
class InputParameters;
class MooseMesh;
 
class MooseAppCoordTransform
{
public:
  enum Direction : unsigned int
  {
    X = 0,
    Y,
    Z,
    INVALID
  };
 
  typedef std::tuple<short int,
                     Real,
                     short int,
                     std::array<Real, 3>,
                     int,
                     unsigned int,
                     unsigned int,
                     short int,
                     short int,
                     short int>
      MinimalData;
 
  MooseAppCoordTransform();
 
  MooseAppCoordTransform(const MooseAppCoordTransform & other); // we have unique pointers
  MooseAppCoordTransform(MooseAppCoordTransform && other) = default;
 
  MooseAppCoordTransform(const MinimalData & minimal_data);
 
  MooseAppCoordTransform(const MooseMesh & mesh);
 
  ~MooseAppCoordTransform() = default;
 
  MooseAppCoordTransform &
  operator=(const MooseAppCoordTransform & other); // we have unique pointers
  MooseAppCoordTransform & operator=(MooseAppCoordTransform && other) = default;
 
  static InputParameters validParams();
 
  MinimalData minimalDataDescription() const;
 
  Moose::CoordinateSystemType coordinateSystem() const { return _coord_type; }
 
  void setTranslationVector(const libMesh::Point & translation);
 
  void setUpDirection(Direction up_direction);
 
  void setRotation(Real alpha, Real beta, Real gamma);
 
  void setLengthUnit(const MooseUnits & length_unit);
 
  const MooseUnits & lengthUnit() const { return _length_unit; }
 
  void setCoordinateSystem(Moose::CoordinateSystemType system_type,
                           Direction rz_symmetry_axis = INVALID);
 
  void setCoordinateSystem(const MooseMesh & mesh);
 
  void computeRS();
 
  void transformMesh(MooseMesh & mesh, const libMesh::Point & translation);
 
  bool hasScalingOrRotationTransformation() const;
 
private:
  Direction processZAxis(Direction z_axis);
 
  std::unique_ptr<libMesh::RealTensorValue> _scale;
 
  std::unique_ptr<libMesh::RealTensorValue> _rotate;
 
  std::unique_ptr<libMesh::RealTensorValue> _rs;
 
  std::unique_ptr<libMesh::RealTensorValue> _rs_inverse;
 
  Moose::CoordinateSystemType _coord_type;
  Direction _r_axis;
  Direction _z_axis;
 
  bool _has_different_coord_sys;
 
  bool _using_general_rz_coord_axes;
 
  MooseUnits _length_unit;
 
  std::array<Real, 3> _euler_angles;
 
  bool _mesh_transformed;
 
  friend class MultiAppCoordTransform;
};
 
class MultiAppCoordTransform
{
public:
  explicit MultiAppCoordTransform(const MooseAppCoordTransform & our_app_transform);
 
  libMesh::Point operator()(const libMesh::Point & point) const;
 
  libMesh::Point mapBack(const libMesh::Point & point) const;
 
  void setTranslationVector(const libMesh::Point & translation);
 
  void setDestinationCoordTransform(const MooseAppCoordTransform & destination_coord_transform);
 
  bool isIdentity() const;
 
  bool hasNonTranslationTransformation() const;
 
  bool hasCoordinateSystemTypeChange() const;
 
  Moose::CoordinateSystemType coordinateSystem() const { return _our_app_transform._coord_type; }
 
  void skipCoordinateCollapsing(bool skip_coordinate_collapsing);
 
  bool skipCoordinateCollapsing() const { return _skip_coordinate_collapsing; }
 
  const MooseAppCoordTransform & ourAppTransform() const { return _our_app_transform; }
 
private:
  const MooseAppCoordTransform & _our_app_transform;
 
  const MooseAppCoordTransform * _destination_app_transform;
 
  libMesh::Point _translation;
 
  bool _skip_coordinate_collapsing;
};