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;
};