Track.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Surfaces/Line.h"
#include "MantidKernel/Tolerance.h"
 
#include <boost/container/small_vector.hpp>
 
#include <iosfwd>
#include <list>
 
namespace Mantid {
//----------------------------------------------------------------------
// Forward Declaration
//----------------------------------------------------------------------
namespace Kernel {
class Logger;
}
 
namespace Geometry {
 
struct MANTID_GEOMETRY_DLL Link {
  inline Link(const Kernel::V3D &entry, const Kernel::V3D &exit, const double totalDistance, const IObject &obj,
              const ComponentID compID = nullptr)
      : entryPoint(entry), exitPoint(exit), distFromStart(totalDistance),
        distInsideObject(entryPoint.distance(exitPoint)), object(&obj), componentID(compID) {}
  inline bool operator<(const Link &other) const { return distFromStart < other.distFromStart; }
  inline bool operator<(const double &other) const { return distFromStart < other; }
 
  inline bool operator==(const Link &other) const {
    if (componentID != other.componentID) {
      return false;
    }
 
    if (object != other.object) {
      return false;
    }
 
    // Need a bit wider tolerance than Kernel::Tolerance for comparing exitPoint
    //  Although this is due to very slight numerical changes for some reason.
    // The entryPoint seems to be identical among duplicated Links, so the
    //  built-in V3D == operator is used in for that case.
    const double tolerance = 1.0e-5;
    bool isExitSame = !(std::abs(exitPoint[0] - other.exitPoint[0]) > tolerance ||
                        std::abs(exitPoint[1] - other.exitPoint[1]) > tolerance ||
                        std::abs(exitPoint[2] - other.exitPoint[2]) > tolerance);
    return isExitSame && (entryPoint == other.entryPoint);
  }
 
  Kernel::V3D entryPoint;  
  Kernel::V3D exitPoint;   
  double distFromStart;    
  double distInsideObject; 
  const IObject *object;   
  ComponentID componentID; 
};
 
// calculations should prefer throwing a std::domain_error rather than using
// INVALID
enum class TrackDirection { LEAVING = -1, INVALID = 0, ENTERING = 1 };
 
inline bool operator<(const TrackDirection left, const TrackDirection right) {
  return static_cast<int>(left) < static_cast<int>(right);
}
 
MANTID_GEOMETRY_DLL std::ostream &operator<<(std::ostream &os, const TrackDirection &direction);
 
struct IntersectionPoint {
  inline IntersectionPoint(const TrackDirection direction, const Kernel::V3D &end, const double distFromStartOfTrack,
                           const IObject &obj, const ComponentID compID = nullptr)
      : direction(direction), endPoint(end), distFromStart(distFromStartOfTrack), object(&obj), componentID(compID) {}
 
  inline bool operator<(const IntersectionPoint &other) const {
    const double diff = fabs(distFromStart - other.distFromStart);
    return (diff > Kernel::Tolerance) ? distFromStart < other.distFromStart : direction < other.direction;
  }
 
  inline bool operator==(const IntersectionPoint &other) const {
    if (direction != other.direction) {
      return false;
    }
 
    const double diff = fabs(distFromStart - other.distFromStart);
    if (diff > Kernel::Tolerance) {
      return false;
    }
 
    return endPoint == other.endPoint;
  }
 
  TrackDirection direction; 
  Kernel::V3D endPoint;     
  double distFromStart;     
  const IObject *object;    
  ComponentID componentID;  
};
 
class MANTID_GEOMETRY_DLL Track {
public:
  using LType = boost::container::small_vector<Link, 5>;
  using PType = boost::container::small_vector<IntersectionPoint, 5>;
 
public:
  Track();
  Track(const Kernel::V3D &startPt, const Kernel::V3D &unitVector);
  virtual ~Track() = default;
  void addPoint(const TrackDirection direction, const Kernel::V3D &endPoint, const IObject &obj,
                const ComponentID compID = nullptr);
  int addLink(const Kernel::V3D &firstPoint, const Kernel::V3D &secondPoint, const double distanceAlongTrack,
              const IObject &obj, const ComponentID compID = nullptr);
  void removeCojoins();
  void buildLink();
  void reset(const Kernel::V3D &startPoint, const Kernel::V3D &direction);
  void clearIntersectionResults();
  const Kernel::V3D &startPoint() const { return m_line.getOrigin(); }
  const Kernel::V3D &direction() const { return m_line.getDirect(); }
  double totalDistInsideObject() const;
  LType::iterator begin() { return m_links.begin(); }
  LType::iterator end() { return m_links.end(); }
  LType::const_iterator begin() const { return m_links.begin(); }
  LType::const_iterator end() const { return m_links.end(); }
  LType::const_iterator cbegin() const { return m_links.cbegin(); }
  LType::const_iterator cend() const { return m_links.cend(); }
  LType::reference front() { return m_links.front(); }
  LType::reference back() { return m_links.back(); }
  LType::const_reference front() const { return m_links.front(); }
  LType::const_reference back() const { return m_links.back(); }
  int count() const { return static_cast<int>(m_links.size()); }
  int surfPointsCount() const { return static_cast<int>(m_surfPoints.size()); }
  int nonComplete() const;
  virtual double calculateAttenuation(double lambda) const;
 
private:
  Line m_line;        
  LType m_links;      
  PType m_surfPoints; 
};
 
} // NAMESPACE Geometry
} // NAMESPACE Mantid