DiscreteLineSegmentInterface.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 "InputParameters.h"
#include "libmesh/vector_value.h"
#include "libmesh/tensor_value.h"
 
class MooseObject;
 
class DiscreteLineSegmentInterface
{
public:
  DiscreteLineSegmentInterface(const MooseObject * moose_object);
 
  virtual Point getPosition() const { return getStartPoint(); }
  Point getStartPoint() const { return _position; }
  Point getEndPoint() const { return _end_point; }
  virtual RealVectorValue getDirection() const { return _dir; }
  virtual Real getRotation() const { return _rotation; }
 
  virtual Real getNumElems() const { return _n_elem; }
  virtual Real getLength() const { return _length; }
 
  Real getMinimumElemSize() const { return _dx_min; }
 
  /*
   * Computes the axial coordinate for a given point in 3-D space.
   *
   * @param[in] p   Point in 3-D space
   */
  Real computeAxialCoordinate(const Point & p) const;
 
  /*
   * Computes the radial coordinate from the line axis for a given point in 3-D space.
   *
   * @param[in] p   Point in 3-D space
   */
  Real computeRadialCoordinate(const Point & p) const;
 
  /*
   * Gets the axial section index for a given point in 3-D space.
   *
   * @param[in] p   Point in 3-D space
   */
  unsigned int getAxialSectionIndex(const Point & p) const;
 
  /*
   * Gets the axial element index for a given element center point in 3-D space.
   *
   * @param[in] p_center   Element center point in 3-D space
   */
  unsigned int getAxialElementIndex(const Point & p_center) const;
 
  Point computeRealPointFromReferencePoint(const Point & p) const;
 
  Point computeReferencePointFromRealPoint(const Point & p) const;
 
  MooseEnum getAlignmentAxis() const;
 
  std::vector<Real> getElementBoundaryCoordinates() const;
 
protected:
  const Point & _position;
  const RealVectorValue & _dir_unnormalized;
  const RealVectorValue _dir;
  const Real & _rotation;
 
  std::vector<Real> _lengths;
  Real _length;
 
  const Point _end_point;
 
  std::vector<unsigned int> _n_elems;
  unsigned int _n_elem;
 
  const unsigned int _n_sections;
  std::vector<Real> _section_end;
 
  std::vector<Real> _x_centers;
 
  const RealTensorValue _R;
  const RealTensorValue _Rx;
 
  const RealTensorValue _R_inv;
  const RealTensorValue _Rx_inv;
 
  const std::string _moose_object_name_dlsi;
 
private:
  static RealVectorValue initializeDirectionVector(const RealVectorValue & dir_unnormalized);
 
public:
  static InputParameters validParams();
 
  static RealTensorValue computeDirectionTransformationTensor(const RealVectorValue & dir);
 
  static RealTensorValue computeXRotationTransformationTensor(const Real & rotation);
 
  static Point computeRealPointFromReferencePoint(const Point & p,
                                                  const RealVectorValue & position,
                                                  const RealTensorValue & R,
                                                  const RealTensorValue & Rx);
 
  static Point computeReferencePointFromRealPoint(const Point & p,
                                                  const RealVectorValue & position,
                                                  const RealTensorValue & R_inv,
                                                  const RealTensorValue & Rx_inv);
 
  static MooseEnum getAlignmentAxis(const RealVectorValue & dir);
 
  static std::vector<Real> getElementBoundaryCoordinates(const RealVectorValue & position,
                                                         const RealVectorValue & orientation,
                                                         const Real & rotation,
                                                         const std::vector<Real> & lengths,
                                                         const std::vector<unsigned int> & n_elems);
 
  Real _dx_min;
};