ARICHGeometryPar.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Luka Santelj, Rok Pestotnik                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#ifndef ARICHGEOMETRYPAR_H
#define ARICHGEOMETRYPAR_H
 
#include <vector>
#include <string>
#include <map>
#include <unordered_set>
#include <framework/gearbox/GearDir.h>
#include "TVector3.h"
#include "TVector2.h"
#include <G4ThreeVector.hh>
 
#define MAX_N_ALAYERS 5
#define MAXPTS_QE 100
 
namespace Belle2 {
 
  class ARICHGeometryPar {
 
  public:
 
    ARICHGeometryPar();
 
    virtual ~ARICHGeometryPar();
 
 
    static ARICHGeometryPar* Instance();
    void Initialize(const GearDir& content);
    void Initialize(const GearDir& content, const GearDir& mirrorinfo);
 
    void clear(void);
 
    void Print(void) const;
 
    void read(const GearDir& content);
 
    void readModuleInfo(const GearDir& content);
 
    double QE(double e) const;
 
    double getColEffi() const;
 
    double getSensitiveSurfaceSize() const;
    int getNMCopies() const;
    int getCopyNo(TVector3 hit);
    TVector3 getOrigin(int copyno);
    G4ThreeVector getOriginG4(int copyNo);
    double getModAngle(int copyno);
    int getChannelID(TVector2 hit);
    TVector2 getChannelCenterLoc(int chID);
    double getChannelQE(int moduleID, int channelID);
    TVector2 getChipLocPos(int chipID);
    int getChipID(TVector2 locpos);
    TVector3 getChannelCenterGlob(int modID, int chanID);
    TVector3 getMirrorNormal(int mirID);
    TVector3 getMirrorPoint(int mirID);
    double getAerogelTransmissionLength(int ilayer);
    double getAerogelRefIndex(int ilayer);
    double getAerogelThickness(int ilayer);
    double getAerogelZPosition(int ilayer);
    int getNMirrors();
    double getMirrorsStartAngle();
    double getMirrorsZPosition();
    double getDetectorWindowThickness();
    double getDetectorWindowRefIndex();
    int getNumberOfAerogelRadiators();
    double getDetectorPadSize();
    double getDetectorZPosition();
    int getDetectorXPadNumber();
    double getQEScaling();
    double getWindowAbsorbtion();
    double getChipNegativeCrosstalk();
    int getNrTiles();
    int getNphiTiles(int nRing);
    double getTileGap();
    double getAeroTubeRin();
    double getAeroTubeRout();
    void setAeroTransLength(int ilayer, double trlen);
    void setAeroRefIndex(int ilayer, double n);
    void setAerogelThickness(int ilayer, double thick);
    void setAerogelZPosition(int ilayer, double zPos);
    void setWindowRefIndex(double refInd);
    bool isInit();
    bool isSimple();
    void initDetectorMask(int nmodules);
    void setActive(int module, int channel,  bool val);
    bool isActive(int module, int channel);
 
    int getMergerFromCooper(int cooperID, int finesse);
    int getBoardFromMerger(int mergerID, int slot);
    int getNBoardsOnMerger(int mergerID);
 
    int getAerogelTileID(TVector2 locpos);
 
    const std::unordered_set<unsigned int>& getCopperIDs() const
    {
      return m_copperIDs;
    }
 
  private:
 
    std::string m_version;       
    double m_padSize;            
    double m_chipGap;            
    double m_detInnerRadius;               
    double m_detOuterRadius;               
    double m_detZpos;                      
    double m_modXSize;                     
    double m_modZSize;                     
    double m_winThick;                     
    double m_winRefInd;                    
    double m_mirrorOuterRad;               
    double m_mirrorThickness;              
    double m_mirrorStartAng;               
    int m_nMirrors;                        
    double  m_mirrorZPos;                  
    int m_nPadX;                           
    int m_nRad;                            
    bool m_init;                          
    bool m_simple;                        
    double m_aeroTrLength[MAX_N_ALAYERS];  
    double m_aeroRefIndex[MAX_N_ALAYERS];  
    double m_aeroZPosition[MAX_N_ALAYERS]; 
    double m_aeroThickness[MAX_N_ALAYERS]; 
    int  m_nPads;                         
    std::vector<uint32_t> m_DetectorMask; 
    std::vector<uint8_t>  m_ChannelQE;    
    double m_ColEffi;                     
    double m_LambdaFirst;                 
    double m_LambdaStep;                  
    int m_NpointsQE;                      
    double m_qeScale;                     
    double m_windowAbsorbtion;            
    double m_chipNegativeCrosstalk;       
    double m_QE[MAXPTS_QE];               
    int m_tileNr;                         
    int m_tileNphi[5];                    
    double m_tileGap;                     
    double m_aeroRin;                     
    double m_aeroRout;                    
    void modulesPosition(const GearDir& content);
 
    void modulesPositionSimple(const GearDir& content);
 
    void chipLocPosition();
 
    void padPositions();
 
    void mirrorPositions(const GearDir& content);
 
    void readMirrorAlignment(const GearDir& content);
 
    void mirrorPositionSimple(const GearDir& content);
 
    void frontEndMapping(const GearDir& content);
 
    static ARICHGeometryPar* p_B4ARICHGeometryParDB; 
    // vectors holding information on HAPDs and chips and pads positions.
 
    std::vector<int>
    m_ncol;         
    std::vector<double> m_fDFi;     
    std::vector<double> m_fDR;      
    int m_nrow;                     
    std::vector<double> m_fR;       
    std::vector<double> m_fFi;      
    std::vector<double> m_fFiMod;      
    std::vector<TVector2> m_chipLocPos;   
    std::map<int, TVector2> m_padLocPositions; 
    std::vector<TVector2> m_padWorldPositions; 
    std::vector<TVector3> m_mirrornorm;       
    std::vector<TVector3> m_mirrorpoint;      
    std::map<std::pair<unsigned, int>, unsigned> m_copper2merger; 
    std::map<int, std::vector<unsigned>> m_merger2feb; 
    std::unordered_set<unsigned int> m_copperIDs; 
    std::unordered_set<unsigned int> m_mergerIDs; 
    std::unordered_set<unsigned int> m_boardIDs; 
  };
 
  //-----------------------------------------------------------------------------
 
  inline double ARICHGeometryPar::getColEffi() const
  {
    return m_ColEffi;
  }
 
  inline double ARICHGeometryPar::getSensitiveSurfaceSize() const
  {
    return m_nPadX * m_padSize + m_chipGap;
  }
 
  inline int ARICHGeometryPar::getNMCopies() const
  {
    return m_fR.size();
  }
 
  inline TVector2 ARICHGeometryPar::getChipLocPos(int chipID)
  {
    return m_chipLocPos.at(chipID);
  }
 
  inline bool ARICHGeometryPar::isInit()
  {
    return m_init;
  }
 
  inline bool ARICHGeometryPar::isSimple()
  {
    return m_simple;
  }
 
 
  inline double ARICHGeometryPar::getAerogelTransmissionLength(int layer)
  {
    return m_aeroTrLength[layer];
  }
 
  inline double ARICHGeometryPar::getAerogelRefIndex(int layer)
  {
    return m_aeroRefIndex[layer];
  }
 
  inline double ARICHGeometryPar::getAerogelThickness(int layer)
  {
    return m_aeroThickness[layer];
  }
 
  inline double ARICHGeometryPar::getAerogelZPosition(int layer)
  {
    return m_aeroZPosition[layer];
  }
 
  inline int ARICHGeometryPar::getNMirrors()
  {
    return m_nMirrors;
  }
 
  inline double ARICHGeometryPar::getDetectorWindowThickness()
  {
    return m_winThick;
  }
 
  inline double ARICHGeometryPar::getDetectorWindowRefIndex()
  {
    return m_winRefInd;
  }
 
  inline int ARICHGeometryPar::getNumberOfAerogelRadiators()
  {
    return m_nRad;
  }
 
  inline double ARICHGeometryPar::getDetectorPadSize()
  {
    return m_padSize;
  }
 
  inline int ARICHGeometryPar::getDetectorXPadNumber()
  {
    return m_nPadX;
  }
 
  inline double ARICHGeometryPar::getMirrorsStartAngle()
  {
    return m_mirrorStartAng;
  }
 
  inline double ARICHGeometryPar::getMirrorsZPosition()
  {
    return m_mirrorZPos;
  }
 
  inline double ARICHGeometryPar::getDetectorZPosition()
  {
    return m_detZpos;
  }
 
  inline double ARICHGeometryPar::getQEScaling()
  {
    return m_qeScale;
  }
 
  inline double ARICHGeometryPar::getWindowAbsorbtion()
  {
    return m_windowAbsorbtion;
  }
 
  inline double ARICHGeometryPar::getChipNegativeCrosstalk()
  {
    return m_chipNegativeCrosstalk;
  }
 
  inline int ARICHGeometryPar::getNrTiles()
  {
    return m_tileNr;
  }
 
  inline int ARICHGeometryPar::getNphiTiles(int nRing)
  {
    if (nRing > 4) return 0;
    return m_tileNphi[nRing];
  }
 
  inline double ARICHGeometryPar::getTileGap()
  {
    return m_tileGap;
  }
 
  inline double ARICHGeometryPar::getAeroTubeRin()
  {
    return m_aeroRin;
  }
 
  inline double ARICHGeometryPar::getAeroTubeRout()
  {
    return m_aeroRout;
  }
 
 
 
} // end of namespace Belle2
 
#endif