Ray.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
 
// Local includes
#include "RayTracingCommon.h"
 
// MOOSE includes
#include "MooseError.h"
#include "MooseTypes.h"
 
// libMesh Includes
#include "libmesh/parallel.h"
 
// Forward declarations
namespace libMesh
{
class Elem;
}
class RayTracingStudy;
// Friend access to Ray
class TraceRay;
class TestRayLots;
// Friend access to ChangeDirectionKey for accessing changeDirection()
class RayBoundaryConditionBase;
// Friend access to ChangeStartDirectionKey for accessing changeStartDirection()
class RayKernelBase;
class PeriodicRayBC;
// Friend access to NonResetCountersKey for accessing constructor/reset without counter reset
namespace MooseUtils
{
template <class T>
class SharedPool;
}
 
typedef unsigned long int RayID;
#ifdef SINGLE_PRECISION_RAY
typedef float RayData;
#else
typedef libMesh::Real RayData;
#endif
typedef unsigned int RayDataIndex;
 
class Ray
{
public:
  class ChangeDirectionKey
  {
    friend class RayBoundaryConditionBase;
    ChangeDirectionKey() {}
    ChangeDirectionKey(const ChangeDirectionKey &) {}
  };
 
  class ChangeStartDirectionKey
  {
    friend class RayKernelBase;
    ChangeStartDirectionKey() {}
    ChangeStartDirectionKey(const ChangeStartDirectionKey &) {}
  };
 
  class ChangePointElemSideKey
  {
    friend class PeriodicRayBC;
    ChangePointElemSideKey() {}
    ChangePointElemSideKey(const ChangePointElemSideKey &) {}
  };
 
  class ConstructRayKey
  {
    friend class RayTracingStudy;
    friend class MooseUtils::SharedPool<Ray>;
    friend class TestRayLots;
    ConstructRayKey() {}
    ConstructRayKey(const ConstructRayKey &) {}
  };
 
  Ray(RayTracingStudy * study,
      const RayID id,
      const std::size_t data_size,
      const std::size_t aux_data_size,
      const bool reset,
      const ConstructRayKey &);
 
  void reset(RayTracingStudy * study,
             const RayID id,
             const std::size_t data_size,
             const std::size_t aux_data_size,
             const bool reset,
             const ConstructRayKey &);
 
  Ray(const Ray * const other, const ConstructRayKey &);
 
  void reset(const Ray * const other, const ConstructRayKey &);
 
  Ray & operator=(const Ray &) = delete;
  Ray() = delete;
  Ray(const Ray & other) = delete;
 
  bool operator==(const Ray & other) const { return equalityHelper(other, true); }
  bool operator!=(const Ray & other) const { return equalityHelper(other, false); }
 
  static const RayDataIndex INVALID_RAY_DATA_INDEX = static_cast<RayDataIndex>(-1);
  static const RayID INVALID_RAY_ID = static_cast<RayID>(-1);
 
  RayID id() const { return _id; }
  bool invalidID() const { return _id == INVALID_RAY_ID; }
 
  const Point & currentPoint() const { return _current_point; }
  bool invalidCurrentPoint() const { return _current_point == RayTracingCommon::invalid_point; }
 
  void changeDirection(const Point & direction, const ChangeDirectionKey);
 
  void
  changeStartDirection(const Point & start, const Point & direction, const ChangeStartDirectionKey);
 
  void changePointElemSide(const Point & point,
                           const Elem & elem,
                           const unsigned int side,
                           const ChangePointElemSideKey);
 
  const Point & direction() const { return _direction; }
  bool invalidDirection() const { return _direction == RayTracingCommon::invalid_point; }
 
  std::vector<RayData> & data();
  const std::vector<RayData> & data() const;
  RayData & data(const std::size_t i);
  const RayData & data(const std::size_t i) const;
 
  std::vector<RayData> & auxData();
  const std::vector<RayData> & auxData() const;
  RayData & auxData(const std::size_t i);
  const RayData & auxData(const std::size_t i) const;
 
  void setStart(const Point & starting_point,
                const Elem * starting_elem = nullptr,
                const unsigned short starting_incoming_side = RayTracingCommon::invalid_side);
  void setStartingDirection(const Point & starting_direction);
  void setStartingEndPoint(const Point & starting_end_point);
  void setStartingMaxDistance(const Real starting_max_distance);
  void setStationary();
 
  void invalidateStartingElem();
  void invalidateStartingIncomingSide();
  void clearStartingInfo();
 
  void resetCounters();
 
  const Elem * currentElem() const { return _current_elem; }
 
  unsigned short currentIncomingSide() const { return _current_incoming_side; }
  bool invalidCurrentIncomingSide() const
  {
    return _current_incoming_side == RayTracingCommon::invalid_side;
  }
 
  bool endSet() const { return _end_set; }
  bool atEnd() const;
  Point endPoint() const;
 
  unsigned int processorCrossings() const { return _processor_crossings; }
 
  unsigned int intersections() const { return _intersections; }
 
  Real distance() const { return _distance; }
  Real maxDistance() const { return _max_distance; }
  bool maxDistanceSet() const { return _max_distance != std::numeric_limits<Real>::max(); }
 
  inline bool stationary() const;
 
  bool shouldContinue() const { return _should_continue; }
  void setShouldContinue(const bool should_continue) { _should_continue = should_continue; }
 
  bool trajectoryChanged() const { return _trajectory_changed; }
  unsigned int trajectoryChanges() const { return _trajectory_changes; }
 
  std::string getInfo() const;
 
  bool hasTraced() const
  {
    return (bool)_distance || (bool)_processor_crossings || (bool)_intersections;
  }
 
  const RayTracingStudy & study() const { return _study; }
 
private:
  void changeID(const RayID id) { _id = id; }
 
  void invalidateCurrentElem() { _current_elem = nullptr; }
 
  void setCurrentPoint(const Point & current_point) { _current_point = current_point; }
  void invalidateCurrentPoint() { _current_point = RayTracingCommon::invalid_point; }
 
  void setDirection(const Point & direction) { _direction = direction; }
  void invalidateDirection() { _direction = RayTracingCommon::invalid_point; }
 
  void setCurrentElem(const Elem * current_elem) { _current_elem = current_elem; }
 
  void setCurrentIncomingSide(const unsigned short current_incoming_side)
  {
    _current_incoming_side = current_incoming_side;
  }
  void invalidateCurrentIncomingSide() { _current_incoming_side = RayTracingCommon::invalid_side; }
 
  void setTrajectoryChanged(const bool trajectory_changed)
  {
    _trajectory_changed = trajectory_changed;
  }
 
  void addProcessorCrossing() { ++_processor_crossings; }
 
  void addIntersection() { ++_intersections; }
 
  void addTrajectoryChange() { ++_trajectory_changes; }
 
  void addDistance(const Real add_distance) { _distance += add_distance; }
  void changeMaxDistance(const Real max_distance) { _max_distance = max_distance; }
  void invalidateMaxDistance() { _max_distance = std::numeric_limits<Real>::max(); }
 
  void errorIfTracing(const std::string & reason) const;
  void errorWhenInitializing(const std::string & reason) const;
 
  void resetCountersInternal();
 
  bool equalityHelper(const Ray & other, const bool equal) const;
 
  void clearStartingInfoInternal();
 
  RayID _id;
 
  Point _current_point;
 
  Point _direction;
 
  const Elem * _current_elem;
 
  unsigned short _current_incoming_side;
 
  bool _trajectory_changed;
  bool _end_set;
  bool _should_continue;
 
  unsigned int _processor_crossings;
 
  unsigned int _intersections;
 
  unsigned int _trajectory_changes;
 
  Real _distance;
  Real _max_distance;
 
  mutable std::vector<RayData> _data;
 
  mutable std::vector<RayData> _aux_data;
 
  RayTracingStudy & _study;
 
  // TraceRay is the only object that should be executing Rays and therefore needs access
  friend class TraceRay;
  // Packing needs access to changing the internal counters during the trace
  friend class Parallel::Packing<std::shared_ptr<Ray>>;
  // Allows for testing of equality methods
  friend class TestRayLots;
  // Data helpers needs to be able to access the internal methods for a Ray for store/load
  friend void dataStore(std::ostream & stream, std::shared_ptr<Ray> & ray, void * context);
  friend void dataLoad(std::istream & stream, std::shared_ptr<Ray> & ray, void * context);
};
 
bool
Ray::stationary() const
{
  const bool stationary = _max_distance == 0;
  if (stationary)
    mooseAssert(_intersections == 0, "Should be zero");
  return stationary;
}
 
namespace libMesh
{
namespace Parallel
{
template <>
class Packing<std::shared_ptr<Ray>>
{
public:
  typedef Real buffer_type;
 
  static unsigned int packed_size(typename std::vector<Real>::const_iterator in);
  static unsigned int packable_size(const std::shared_ptr<Ray> & ray, const void *);
  static unsigned int size(const std::size_t data_size, const std::size_t aux_data_size);
 
  template <typename Iter, typename Context>
  static void pack(const std::shared_ptr<Ray> & object, Iter data_out, const Context * context);
 
  template <typename BufferIter, typename Context>
  static std::shared_ptr<Ray> unpack(BufferIter in, Context * context);
};
 
} // namespace Parallel
 
} // namespace libMesh
 
void dataStore(std::ostream & stream, std::shared_ptr<Ray> & ray, void * context);
void dataLoad(std::istream & stream, std::shared_ptr<Ray> & ray, void * context);