ECLGeometryPar.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <vector>
#include <map>
#include <G4ThreeVector.hh>
#include <TVector3.h>
 
typedef int EclIdentifier;
typedef double EclGeV;
typedef double EclCM;
typedef double EclRad;
 
class G4VTouchable;
namespace HepGeom {
  class Transform3D;
}
typedef HepGeom::Transform3D G4Transform3D;
 
namespace Belle2 {
  namespace ECL {
 
 
 
    class ECLGeometryPar {
 
    public:
 
      ECLGeometryPar();
 
      virtual ~ECLGeometryPar();
 
 
      static ECLGeometryPar* Instance();
 
      void clear();
 
      void Print() const;
 
      void read();
 
      void Mapping(int cid);
 
      int GetCellID(int ThetaId, int PhiId);
      int GetCellID() {return mPar_cellID;};
      int GetThetaID() {return mPar_thetaID;};
      int GetPhiID() {return mPar_phiID;};
      int ECLVolumeToCellID(const G4VTouchable*); 
      int TouchableToCellID(const G4VTouchable*); 
      int TouchableDiodeToCellID(const G4VTouchable*); 
      G4ThreeVector getCrystalPos(int cid)
      {
        if (cid != m_ini_cid) InitCrystal(cid);
        return m_current_crystal.pos;
      }
 
      G4ThreeVector getCrystalVec(int cid)
      {
        if (cid != m_ini_cid) InitCrystal(cid);
        return m_current_crystal.dir;
      }
 
      TVector3 GetCrystalPos(int cid)
      {
        if (cid != m_ini_cid) InitCrystal(cid);
        const G4ThreeVector& t = m_current_crystal.pos;
        return TVector3(t.x(), t.y(), t.z());
      }
 
      TVector3 GetCrystalVec(int cid)
      {
        if (cid != m_ini_cid) InitCrystal(cid);
        const G4ThreeVector& t = m_current_crystal.dir;
        return TVector3(t.x(), t.y(), t.z());
      }
 
      double time2sensor(int cid, const G4ThreeVector& hit_pos);
    private:
      G4Transform3D* m_ECLForwardGlobalT = nullptr;
      G4Transform3D* m_ECLBackwardGlobalT = nullptr;
      G4Transform3D* m_ECLBarrelGlobalT = nullptr;
      void InitCrystal(int cid);
      struct CrystalGeom_t {
        G4ThreeVector pos, dir;
      };
      std::vector<CrystalGeom_t> m_crystals;
      CrystalGeom_t m_current_crystal;
      int mPar_cellID;
      int mPar_thetaID;
      int mPar_phiID;
      int m_ini_cid;
      static ECLGeometryPar* m_B4ECLGeometryParDB;
    };
 
 
    class EclNbr {
      // friend classses and functions
 
    public:
      typedef EclIdentifier Identifier ;
 
      EclNbr();
      EclNbr(const EclNbr& aNbr);
      EclNbr(
        const std::vector< Identifier >&           aNbrs     ,
        const std::vector< Identifier >::size_type aNearSize
      ) ;
 
      virtual ~EclNbr();
 
      // member functions
 
      // const member functions
      const std::vector< Identifier >&                nbrs()      const ;
      const std::vector< Identifier >::const_iterator nearBegin() const ;
      const std::vector< Identifier >::const_iterator nearEnd()   const ;
      const std::vector< Identifier >::const_iterator nextBegin() const ;
      const std::vector< Identifier >::const_iterator nextEnd()   const ;
      std::vector< Identifier >::size_type      nearSize()  const ;
      std::vector< Identifier >::size_type      nextSize()  const ;
 
      EclNbr& operator=(const EclNbr& aNbr);
      EclNbr getNbr(const Identifier  aCellId);
      void printNbr();
      void Mapping(int cid);
      int GetCellID(int ThetaId, int PhiId);
      int GetCellID() {return mNbr_cellID;};
      int GetThetaID() {return mNbr_thetaID;};
      int GetPhiID() {return mNbr_phiID;};
    protected:
      // protected member functions
 
      // protected const member functions
 
    private:
      // Constructors and destructor
 
      // private member functions
 
      // private const member functions
 
      int mNbr_cellID;           
      int mNbr_thetaID;          
      int mNbr_phiID;            
      std::vector< Identifier >&           m_nbrs     ; 
      std::vector< Identifier >::size_type m_nearSize ;
      // static data members
 
    };
 
    class TEclEnergyHit {
      // friend classes and functions
 
    public:
      // constants, enums and typedefs
 
      typedef EclIdentifier Identifier;
 
 
      TEclEnergyHit() : fId(0), fEnergy(0), fCellId(0)
      {
      }
      TEclEnergyHit(const TEclEnergyHit& ahit)
        : fId(ahit.Id()), fEnergy(ahit.Energy()), fCellId(ahit.CellId())
      {
      }
      TEclEnergyHit(
        const Identifier hid, const EclGeV energy, const Identifier cid)
        : fId(hid), fEnergy(energy), fCellId(cid)
      {
      }
      virtual ~TEclEnergyHit() { }
 
      TEclEnergyHit& operator=(const TEclEnergyHit& hit)
      {
        if (this != &hit) {
          fId = hit.fId;
          fEnergy = hit.fEnergy;
          fCellId = hit.fCellId;
        }
        return *this;
      }
 
      // member functions
      Identifier Id(void) const
      {
        return fId;
      }
      Identifier Id(Identifier id)
      {
        return fId = id;
      }
      Identifier CellId(void) const
      {
        return fCellId;
      }
      Identifier CellId(int cId)
      {
        return fCellId = cId;
      }
 
 
 
      EclGeV Energy(void) const
      {
        return fEnergy;
      }
      EclGeV Energy(EclGeV energy)
      {
        return fEnergy = energy;
      }
 
      // const member functions
 
      // static member functions
 
      bool operator<(const TEclEnergyHit& rhs) const
      {
        return
          fId < rhs.Id();
      }
      bool operator>(const TEclEnergyHit& rhs) const
      {
        return
          fId > rhs.Id();
      }
      bool operator==(const TEclEnergyHit& rhs) const
      {
        return
          (fId == rhs.Id())
          && (fEnergy == rhs.Energy())
          && (fCellId == rhs.CellId())
          ;
      }
      bool operator!=(const TEclEnergyHit& rhs) const
      {
        return
          (fId != rhs.Id())
          || (fEnergy != rhs.Energy())
          || (fCellId != rhs.CellId())
          ;
      }
 
      struct less_Energy {
        bool operator()(const TEclEnergyHit& lhs, const TEclEnergyHit& rhs)
        const
        {
          return
            lhs.Energy() < rhs.Energy();
        }
      };
      struct less_CellId {
        bool operator()(const TEclEnergyHit& lhs, const TEclEnergyHit& rhs)
        const
        {
          return
            lhs.CellId() < rhs.CellId();
        }
      };
      struct greater_Energy {
        bool operator()(const TEclEnergyHit& lhs, const TEclEnergyHit& rhs)
        const
        {
          return
            lhs.Energy() > rhs.Energy();
        }
      };
      struct greater_CellId {
        bool operator()(const TEclEnergyHit& lhs, const TEclEnergyHit& rhs)
        const
        {
          return
            lhs.CellId() > rhs.CellId();
        }
      };
 
 
    protected:
      // protected member functions
 
      // protected const member functions
 
    private:
      // Constructors and destructor
 
 
      // private member functions
 
      // private const member functions
      // private const member functions
 
      Identifier fId; 
      EclGeV fEnergy; 
      int fCellId;    
      // static data members
 
    };
 
    typedef std::map <TEclEnergyHit::Identifier, TEclEnergyHit,
            std::less<TEclEnergyHit::Identifier> > EclEnergyHitMap;
 
  } // end of namespace ECL
} // end of namespace Belle2