Geometry.hh

Go to the documentation of this file.

#ifndef GEOMETRY_HH
#define GEOMETRY_HH

#include "LArUtilBase.hh"
#include <TMath.h>
#include <TVector3.h>
#include <set>

namespace larutil {
  class Geometry : public LArUtilBase{
    
  private:

    Geometry(bool default_load=true);

    virtual ~Geometry(){};

    static Geometry* _me;
    
  public:

    static const Geometry* GetME(bool default_load=true)
    {
      if(!_me) _me = new Geometry(default_load);
      return _me;
    }

    //--- LArSoft Implementation ---//

    UInt_t     Nchannels() const
    { return fChannelToWireMap.size(); }

    UInt_t NOpChannels() const
    { return fOpChannelVtx.size(); }

    UInt_t Nviews() const
    { return fWirePitch.size(); }

    UInt_t Nplanes() const
    { return fPlanePitch.size(); }

    UInt_t Nwires(UInt_t p) const;
    
    //larlight::GEO::WireID ChannelToWire(UInt_t const channel) const; 

    larlight::GEO::SigType_t SignalType(const UInt_t channel)  const; 

    larlight::GEO::SigType_t PlaneToSignalType(const UChar_t plane)  const; 

    larlight::GEO::View_t View(const UInt_t channel)  const; 

    larlight::GEO::View_t PlaneToView(const UChar_t plane) const;

    std::set<larlight::GEO::View_t>  const Views() const; 

    UInt_t   PlaneWireToChannel(const UInt_t plane,
                const UInt_t wire) const;
    
    UChar_t  ChannelToPlane(const UInt_t ch) const;

    UInt_t   ChannelToWire(const UInt_t ch)const;
    
    UInt_t   NearestChannel(const Double_t worldLoc[3],
                const UInt_t   PlaneNo) const;

    UInt_t   NearestChannel(const std::vector<Double_t> &worldLoc,
                const UInt_t PlaneNo) const;

    UInt_t   NearestChannel(const TVector3& worldLoc,
                const UInt_t    PlaneNo) const;

    UInt_t NearestWire(const Double_t worldLoc[3],
               const UInt_t   PlaneNo) const;

    UInt_t NearestWire(const std::vector<Double_t> &worldLoc,
               const UInt_t  PlaneNo) const;

    UInt_t NearestWire(const TVector3& worldLoc,
               const UInt_t PlaneNo) const;

    Double_t   DetHalfWidth() const
    { return fDetHalfWidth; }

    Double_t   DetHalfHeight() const
    { return fDetHalfHeight; }

    Double_t   DetLength() const
    { return fDetLength; }

    Double_t   CryostatHalfWidth() const
    { return fCryoHalfWidth; }

    Double_t   CryostatHalfHeight() const
    { return fCryoHalfHeight; }

    Double_t   CryostatLength() const
    { return fCryoLength; }

    //void     CryostatBoundaries(Double_t* boundaries) const;

  private:

    Double_t fDetLength;
    Double_t fDetHalfWidth;
    Double_t fDetHalfHeight;

    Double_t fCryoLength;
    Double_t fCryoHalfWidth;
    Double_t fCryoHalfHeight;

  public:

    Double_t   PlanePitch(const UChar_t p1 = 0,const UChar_t p2 = 1) const;

    Double_t   WirePitch(const UInt_t  w1=0,
             const UInt_t  w2=1,
             const UChar_t plane = 0) const;

    Double_t   WirePitch(const larlight::GEO::View_t view) const;

    Double_t   WireAngleToVertical(larlight::GEO::View_t view) const;

    /*
    void  WorldBox(Double_t* xlo,
           Double_t* xhi,
           Double_t* ylo,
           Double_t* yhi,
           Double_t* zlo,
           Double_t* zhi)  const; 
    */

    bool ValueInRange(const Double_t value, Double_t min, Double_t max) const
    {  if(min>max) std::swap(min,max); return ( (min <= value) && (value <= max) ); }

    void WireEndPoints(const UChar_t plane,
                       const UInt_t wire,
                       Double_t *xyzStart,
                       Double_t *xyzEnd) const;

    bool ChannelsIntersect(const UInt_t c1, const UInt_t c2, Double_t &y, Double_t &z) const;
    
    void IntersectionPoint(const UInt_t  wire1,  const UInt_t  wire2,
               const UChar_t plane1, const UChar_t plane2,
               Double_t start_w1[3], Double_t end_w1[3],
               Double_t start_w2[3], Double_t end_w2[3],
               Double_t &y, Double_t &z) const;

    void IntersectionPoint(const UInt_t  wire1,  const UInt_t  wire2,
               const UChar_t plane1, const UChar_t plane2,
               Double_t &y, Double_t &z) const;

    
    //std::string OpDetGeoName(UInt_t c=0) const;

    UInt_t  GetClosestOpChannel(const Double_t * xyz) const;

    UInt_t  GetClosestOpChannel(const Double_t * xyz, Double_t &dist) const;

    void GetOpChannelPosition(const UInt_t i, Double_t *xyz) const;

    const std::vector<Double_t>& PlaneOriginVtx(UChar_t plane);

    void PlaneOriginVtx(UChar_t plane, Double_t *vtx) const;

    virtual bool LoadData(bool force_reload=false);

  protected:
    
    virtual bool ReadTree();

    virtual void ClearData();

  private:

    // Vectors with length = # channels
    std::vector<UChar_t>                fChannelToPlaneMap;
    std::vector<UShort_t>               fChannelToWireMap;
    std::vector<std::vector<UShort_t> > fPlaneWireToChannelMap;

    // Vectors with length = # planes
    std::vector<larlight::GEO::SigType_t> fSignalType;
    std::vector<larlight::GEO::View_t>    fViewType;
    std::vector<Double_t> fPlanePitch;
    //std::vector<std::vector<Double_t> > fFirstWireStartVtx;
    //std::vector<std::vector<Double_t> > fFirstWireEndVtx;

    std::vector<std::vector<std::vector<Double_t > > > fWireStartVtx;
    std::vector<std::vector<std::vector<Double_t > > > fWireEndVtx;

    std::vector<std::vector<Double_t> > fPlaneOriginVtx;

    // Vectors with length = view
    std::vector<Double_t> fWirePitch;
    std::vector<Double_t> fWireAngle;

    std::vector<std::vector<Float_t> > fOpChannelVtx;

    //--- Variables to be computd based on TTree data ---//
    std::vector<Double_t> fOrthVectorsY;
    std::vector<Double_t> fOrthVectorsZ;
    std::vector<Double_t> fFirstWireProj;
  };
}

#endif
 // end of doxygen group 

---