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