MDetector/Scintillator.h

Go to the documentation of this file.

#ifndef _mdet_Scintillator_h
#define _mdet_Scintillator_h

#include <det/VManager.h>
#include <det/MPositionable.h>
//
#include <mdet/MDetectorComponent.h>
//
#include <utl/Point.h>
#include <utl/Plane.h>
#include <utl/Line.h>
#include <utl/Vector.h>
#include <utl/Segment.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/Validated.h>
//
#include <string>
#include <utility>

namespace det {
  struct ParentCreator;
  struct ComponentUpdater;
}

namespace mdet {

  class Module;
  class Scintillator:
     public MDetectorComponent<Scintillator>::Type,
     public det::MPositionable<Scintillator>
  {
  public:

    static const char* const kComponentName;

    static const char* const kComponentId;
    bool Contains(const utl::Point& point) const;
    bool IntersectedBy(const utl::Line& line) const;
    utl::Segment ComputeIntersectionWith(const utl::Line& line) const;
    utl::Segment ComputeUndergroundIntersectionOf(const utl::Line& line) const;
    double ComputeUndergroundGrammageFor(const utl::Line& l) const;
      double GetArea() const;
    template<class V>
    V& VisitShape(V& v) const {
      /*
       * When more shapes (if ever!) came up this code should be changed
       * accordingly to handle them. This could be done with virtual functions
       * , an ugly flag-based switch-case (that could be enough),
       * typelists (http://www.ddj.com/cpp/184403813) or anything else.
       * In any case, that decission would be kept here and won't spread in client
       * code: that would have to define the proper functions for the new shapes,
       * but I will only know about a unique Scintillator class-type.
       */
      // Up to now, just a box...
      v.Box(*this, GetWidth(), GetLength(), GetHeight());
      return v;
    }

    double ComputeDecayDelay() const;
    double GetDecayDelayMean() const;
    double GetDecayDelayStdDev() const;
    const Module& GetModule() const;
  private:
    utl::CoordinateSystemPtr GetReferenceCoordinateSystem() const;
    Scintillator(int sId, const det::VManager::IndexMap& parentMap, const Module& parent);
    ~Scintillator(){ }
    friend class det::MPositionable<Scintillator>;
    friend struct det::ParentCreator;
    template<class T>
    friend void boost::checked_delete(T*) BOOST_NOEXCEPT;
    friend struct det::ComponentUpdater;
    template<class Container>
    void IntersectionHelper(
      Container& v,
      const utl::Line& l, utl::Plane (Scintillator::* ComputePlane)() const ) const;
    bool InExtent(double ext, const utl::Vector& pLocal, const utl::Vector& normal) const;
    bool OnSide(const utl::Plane& sidePlane, const utl::Line& line) const;
    utl::Plane ComputeGroundPlane() const;
    utl::Plane ComputeTopPlane() const;
    utl::Plane ComputeBottomPlane() const;
    utl::Plane ComputeFrontPlane() const;
    utl::Plane ComputeBackPlane() const;
    utl::Plane ComputeRightPlane() const;
    utl::Plane ComputeLeftPlane() const;
    utl::Plane ComputePlaneHelper(double ext, double x, double y, double z) const;
    double GetLength() const;
    double GetWidth() const;
    double GetHeight() const;

    double GetLocalSoilDensity() const;
    double GetDecayTime() const;
        double GetEpsilon() const;
    bool IsCloseTo(double a, double b) const;
    bool Intersects(const utl::Plane& p, const utl::Line& l) const;

    mutable utl::Validated<double> fLength;

    mutable utl::Validated<double> fWidth;

    mutable utl::Validated<double> fHeight;

    mutable utl::Validated<double> fLocalSoilDensity;

    mutable utl::Validated<double> fDecayTime;

    mutable utl::Validated<double> fEpsilon;

    const Module& fModule;
  };

}

#endif // _mdet_Scintillator_h