Geometry.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_EMCAL_GEOMETRY_H_
#define ALICEO2_EMCAL_GEOMETRY_H_
 
#include <array>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
 
#include <RStringView.h>
#include <RtypesCore.h>
#include <TGeoMatrix.h>
#include <TMath.h>
#include <TParticle.h>
#include <TVector3.h>
 
#include "DataFormatsEMCAL/Constants.h"
#include "EMCALBase/GeometryBase.h"
#include "MathUtils/Cartesian.h"
 
namespace o2
{
namespace emcal
{
class ShishKebabTrd1Module;
 
class Geometry
{
 public:
  Geometry() = default;
 
  explicit Geometry(const std::string_view name, const std::string_view mcname = "", const std::string_view mctitle = "");
 
  Geometry(const Geometry& geom);
 
  ~Geometry();
 
  Geometry& operator=(const Geometry& rvalue);
 
  static Geometry* GetInstance();
 
  static Geometry* GetInstance(const std::string_view name, const std::string_view mcname = "TGeant3",
                               const std::string_view mctitle = "");
 
  static Geometry* GetInstanceFromRunNumber(Int_t runNumber, const std::string_view = "",
                                            const std::string_view mcname = "TGeant3",
                                            const std::string_view mctitle = "");
 
  void DefineSamplingFraction(const std::string_view mcname = "", const std::string_view mctitle = "");
 
  // General
  //
 
  const std::string& GetName() const { return mGeoName; }
 
  static const std::string& GetDefaultGeometryName() { return DEFAULT_GEOMETRY; }
 
  static Bool_t IsInitialized() { return Geometry::sGeom != nullptr; }
 
  void CreateListOfTrd1Modules();
 
  const std::vector<ShishKebabTrd1Module>& GetShishKebabTrd1Modules() const { return mShishKebabTrd1Modules; }
 
  const ShishKebabTrd1Module& GetShishKebabModule(Int_t neta) const;
 
  Bool_t Impact(const TParticle* particle) const;
 
  void ImpactOnEmcal(const math_utils::Point3D<double>& vtx, Double_t theta, Double_t phi, Int_t& absId, math_utils::Point3D<double>& vimpact) const;
 
  Bool_t IsInEMCAL(const math_utils::Point3D<double>& pnt) const;
 
  Bool_t IsInDCAL(const math_utils::Point3D<double>& pnt) const;
 
  AcceptanceType_t IsInEMCALOrDCAL(const math_utils::Point3D<double>& pnt) const;
 
  // Return EMCAL geometrical parameters
  //
 
  const Char_t* GetNameOfEMCALEnvelope() const { return "XEN1"; }
  Float_t GetArm1PhiMin() const { return mArm1PhiMin; }
  Float_t GetArm1PhiMax() const { return mArm1PhiMax; }
  Float_t GetArm1EtaMin() const { return mArm1EtaMin; }
  Float_t GetArm1EtaMax() const { return mArm1EtaMax; }
  Float_t GetIPDistance() const { return mIPDistance; }
  Float_t GetEnvelop(Int_t index) const { return mEnvelop[index]; }
  Float_t GetShellThickness() const { return mShellThickness; }
  Float_t GetZLength() const { return mZLength; }
  Float_t GetDCALInnerEdge() const { return mDCALInnerEdge; }
  Float_t GetDCALPhiMin() const { return mDCALPhiMin; }
  Float_t GetDCALPhiMax() const { return mDCALPhiMax; }
  Float_t GetEMCALPhiMax() const { return mEMCALPhiMax; }
  Float_t GetDCALStandardPhiMax() const { return mDCALStandardPhiMax; }
  Int_t GetNECLayers() const { return mNECLayers; }
  Float_t GetDCALInnerExtandedEta() const { return mDCALInnerExtandedEta; }
 
  Int_t GetNZ() const { return mNZ; }
 
  Int_t GetNEta() const { return mNZ; }
 
  Int_t GetNPhi() const { return mNPhi; }
 
  Float_t GetECPbRadThick() const { return mECPbRadThickness; }
  Float_t GetECScintThick() const { return mECScintThick; }
  Float_t GetSampling() const { return mSampling; }
  Int_t GetNumberOfSuperModules() const { return mNumberOfSuperModules; }
  Float_t GetPhiGapForSuperModules() const { return mPhiGapForSM; }
  Float_t GetPhiModuleSize() const { return mPhiModuleSize; }
  Float_t GetEtaModuleSize() const { return mEtaModuleSize; }
  Float_t GetFrontSteelStrip() const { return mFrontSteelStrip; }
  Float_t GetLateralSteelStrip() const { return mLateralSteelStrip; }
  Float_t GetPassiveScintThick() const { return mPassiveScintThick; }
  Float_t GetPhiTileSize() const { return mPhiTileSize; }
  Float_t GetEtaTileSize() const { return mEtaTileSize; }
  Float_t GetPhiSuperModule() const { return mPhiSuperModule; }
  Int_t GetNPhiSuperModule() const { return mNPhiSuperModule; }
  Int_t GetNPHIdiv() const { return mNPHIdiv; }
  Int_t GetNETAdiv() const { return mNETAdiv; }
  Int_t GetNCells() const { return mNCells; }
  Float_t GetLongModuleSize() const { return mLongModuleSize; }
  Float_t GetTrd1Angle() const { return mTrd1Angle; }
  Float_t Get2Trd1Dx2() const { return m2Trd1Dx2; }
  Float_t GetTrd1AlFrontThick() const { return mTrd1AlFrontThick; }
  Float_t GetTrd1BondPaperThick() const { return mTrd1BondPaperThick; }
  // --
  Int_t GetNCellsInSupMod() const { return mNCellsInSupMod; }
  Int_t GetNCellsInModule() const { return mNCellsInModule; }
  Int_t GetKey110DEG() const { return mKey110DEG; }
  Int_t GetnSupModInDCAL() const { return mnSupModInDCAL; }
  Int_t GetILOSS() const { return mILOSS; }
  Int_t GetIHADR() const { return mIHADR; }
  // --
  Float_t GetDeltaEta() const { return (mArm1EtaMax - mArm1EtaMin) / ((Float_t)mNZ); }
  Float_t GetDeltaPhi() const { return (mArm1PhiMax - mArm1PhiMin) / ((Float_t)mNPhi); }
  Int_t GetNTowers() const { return mNPhi * mNZ; }
  //
  Double_t GetPhiCenterOfSM(Int_t nsupmod) const;
  Double_t GetPhiCenterOfSMSec(Int_t nsupmod) const;
  Float_t GetSuperModulesPar(Int_t ipar) const { return mParSM[ipar]; }
  //
  EMCALSMType GetSMType(Int_t nSupMod) const
  {
    if (nSupMod >= mNumberOfSuperModules) {
      throw SupermoduleIndexException(nSupMod, mNumberOfSuperModules);
    }
    return mEMCSMSystem[nSupMod];
  }
 
  Bool_t IsDCALSM(Int_t nSupMod) const;
 
  Bool_t IsDCALExtSM(Int_t nSupMod) const;
 
  // Methods needed for SM in extension, where center of SM != center of the SM-section.
  // Used in AliEMCALv0 to calculate position.
  std::tuple<double, double> GetPhiBoundariesOfSM(Int_t nSupMod) const;
  std::tuple<double, double> GetPhiBoundariesOfSMGap(Int_t nPhiSec) const;
 
  // Obsolete?
  Float_t GetSteelFrontThickness() const { return mSteelFrontThick; }
 
  // Geometry data member setters
  //
  void SetNZ(Int_t nz) { mNZ = nz; }
  void SetNPhi(Int_t nphi) { mNPhi = nphi; }
  //
  void SetSampling(Float_t samp) { mSampling = samp; }
 
  // Global geometry methods
  //
 
  void GetGlobal(const Double_t* loc, Double_t* glob, int ind) const;
 
  void GetGlobal(const TVector3& vloc, TVector3& vglob, int ind) const;
 
  void GetGlobal(Int_t absId, Double_t glob[3]) const;
 
  void GetGlobal(Int_t absId, TVector3& vglob) const;
 
  // May 31, 2006; ALICE numbering scheme:
  // see ALICE-INT-2003-038: ALICE Coordinate System and Software Numbering Convention
  // All indexes are stared from zero now.
  //
  // abs id <-> indexes; Shish-kebab case, only TRD1 now.
  // EMCAL -> Super Module -> module -> tower(or cell) - logic tree of EMCAL
  //
  //**  Usual name of variable - Dec 18,2006 **
  //  nSupMod - index of super module (SM)
  //  nModule - index of module in SM
  //  nIphi   - phi index of tower(cell) in module
  //  nIeta   - eta index of tower(cell) in module
  //
  //  Inside SM
  //  iphim   - phi index of module in SM
  //  ietam   - eta index of module in SM
  //
  //  iphi    - phi index of tower(cell) in SM
  //  ieta    - eta index of tower(cell) in SM
  //
  // for a given tower index absId returns eta and phi of gravity center of tower.
 
  std::tuple<double, double> EtaPhiFromIndex(Int_t absId) const;
 
  int GetAbsCellIdFromEtaPhi(Double_t eta, Double_t phi) const;
 
  std::tuple<int, int> GlobalRowColFromIndex(int cellID) const;
 
  int GlobalCol(int cellID) const;
 
  int GlobalRow(int cellID) const;
 
  int GetCellAbsIDFromGlobalRowCol(int row, int col) const;
 
  std::tuple<int, int, int> GetPositionInSupermoduleFromGlobalRowCol(int row, int col) const;
 
  std::tuple<int, int, int, int> GetCellIndexFromGlobalRowCol(int row, int col) const;
 
  int SuperModuleNumberFromEtaPhi(Double_t eta, Double_t phi) const;
 
  int GetAbsCellId(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
 
  Bool_t CheckAbsCellId(Int_t absId) const;
 
  std::tuple<int, int, int, int> GetCellIndex(Int_t absId) const;
 
  std::tuple<int, int> GetModulePhiEtaIndexInSModule(int supermoduleID, int moduleID) const;
 
  std::tuple<int, int> GetCellPhiEtaIndexInSModule(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
 
  std::tuple<int, int> ShiftOnlineToOfflineCellIndexes(Int_t supermoduleID, Int_t iphi, Int_t ieta) const;
 
  std::tuple<int, int> ShiftOfflineToOnlineCellIndexes(Int_t supermoduleID, Int_t iphi, Int_t ieta) const;
 
  Int_t GetSuperModuleNumber(Int_t absId) const;
  Int_t GetNumberOfModuleInPhiDirection(Int_t nSupMod) const
  {
    if (GetSMType(nSupMod) == EMCAL_HALF) {
      return mNPhi / 2;
    } else if (GetSMType(nSupMod) == EMCAL_THIRD) {
      return mNPhi / 3;
    } else if (GetSMType(nSupMod) == DCAL_EXT) {
      return mNPhi / 3;
    } else {
      return mNPhi;
    }
  }
 
  std::tuple<int, int, int> GetModuleIndexesFromCellIndexesInSModule(int supermoduleID, int phiInSupermodule, int etaInSupermodule) const;
 
  Int_t GetAbsCellIdFromCellIndexes(Int_t nSupMod, Int_t iphi, Int_t ieta) const;
 
  math_utils::Point3D<double> RelPosCellInSModule(Int_t absId, Double_t distEf) const;
 
  math_utils::Point3D<double> RelPosCellInSModule(Int_t absId) const;
 
  std::tuple<int, int, int> getOnlineID(int towerID);
 
  std::tuple<bool, int, int> areAbsIDsFromSameTCard(int absId1, int absId2) const;
 
  std::tuple<int, int> getLinkAssignment(int ddlID) const { return std::make_tuple(mCRORCID[ddlID], mCRORCLink[ddlID]); };
 
  std::vector<EMCALSMType> GetEMCSystem() const { return mEMCSMSystem; } // EMC System, SM type list
  // Local Coordinates of SM
  std::vector<Double_t> GetCentersOfCellsEtaDir() const
  {
    return mCentersOfCellsEtaDir;
  } // size fNEta*fNETAdiv (for TRD1 only) (eta or z in SM, in cm)
  std::vector<Double_t> GetCentersOfCellsXDir() const
  {
    return mCentersOfCellsXDir;
  } // size fNEta*fNETAdiv (for TRD1 only) (       x in SM, in cm)
  std::vector<Double_t> GetCentersOfCellsPhiDir() const
  {
    return mCentersOfCellsPhiDir;
  } // size fNPhi*fNPHIdiv (for TRD1 only) (phi or y in SM, in cm)
  //
  std::vector<Double_t> GetEtaCentersOfCells() const
  {
    return mEtaCentersOfCells;
  } // [fNEta*fNETAdiv*fNPhi*fNPHIdiv], positive direction (eta>0); eta depend from phi position;
  std::vector<Double_t> GetPhiCentersOfCells() const
  {
    return mPhiCentersOfCells;
  } // [fNPhi*fNPHIdiv] from center of SM (-10. < phi < +10.)
 
  // useful utilities
  //
  Float_t AngleFromEta(Float_t eta) const
  { // returns theta in radians for a given pseudorapidity
    return 2.0 * TMath::ATan(TMath::Exp(-eta));
  }
  Float_t ZFromEtaR(Float_t r, Float_t eta) const
  { // returns z in for a given
    // pseudorapidity and r=sqrt(x*x+y*y).
    return r / TMath::Tan(AngleFromEta(eta));
  }
 
  void SetMisalMatrix(const TGeoHMatrix* m, Int_t smod) const;
 
  void SetMisalMatrixFromCcdb(const char* path = "Users/m/mhemmer/EMCAL/Config/GeometryAligned", int timestamp = 10000) const;
 
  void RecalculateTowerPosition(Float_t drow, Float_t dcol, const Int_t sm, const Float_t depth,
                                const Float_t misaligTransShifts[15], const Float_t misaligRotShifts[15],
                                Float_t global[3]) const;
 
  const TGeoHMatrix* GetMatrixForSuperModule(Int_t smod) const;
 
  const TGeoHMatrix* GetMatrixForSuperModuleFromGeoManager(Int_t smod) const;
 
  const TGeoHMatrix* GetMatrixForSuperModuleFromArray(Int_t smod) const;
 
 protected:
  void Init();
 
  void DefineEMC(std::string_view mcname, std::string_view mctitle);
 
  std::tuple<int, int, int, int> CalculateCellIndex(Int_t absId) const;
 
  std::string mGeoName;                     
  Int_t mKey110DEG;                         
  Int_t mnSupModInDCAL;                     
  Int_t mNCellsInSupMod;                    
  Int_t mNETAdiv;                           
  Int_t mNPHIdiv;                           
  Int_t mNCellsInModule;                    
  std::vector<Double_t> mPhiBoundariesOfSM; 
  std::vector<Double_t> mPhiCentersOfSM;    
  std::vector<Double_t> mPhiCentersOfSMSec; 
 
  // Local Coordinates of SM
  std::vector<Double_t> mPhiCentersOfCells;    
  std::vector<Double_t> mCentersOfCellsEtaDir; 
  std::vector<Double_t> mCentersOfCellsPhiDir; 
  std::vector<Double_t>
    mEtaCentersOfCells;                                     
  Int_t mNCells;                                            
  Int_t mNPhi;                                              
  std::vector<Double_t> mCentersOfCellsXDir;                
  Float_t mEnvelop[3];                                      
  Float_t mArm1EtaMin;                                      
  Float_t mArm1EtaMax;                                      
  Float_t mArm1PhiMin;                                      
  Float_t mArm1PhiMax;                                      
  Float_t mEtaMaxOfTRD1;                                    
  Float_t mDCALPhiMin;                                      
  Float_t mDCALPhiMax;                                      
  Float_t mEMCALPhiMax;                                     
  Float_t mDCALStandardPhiMax;                              
  Float_t mDCALInnerExtandedEta;                            
  Float_t mDCALInnerEdge;                                   
  std::vector<ShishKebabTrd1Module> mShishKebabTrd1Modules; 
  Float_t mParSM[3];                                        
  Float_t mPhiModuleSize;                                   
  Float_t mEtaModuleSize;                                   
  Float_t mPhiTileSize;                                     
  Float_t mEtaTileSize;                                     
  Int_t mNZ;                                                
  Float_t mIPDistance;                                      
  Float_t mLongModuleSize;                                  
 
  // Geometry Parameters
  Float_t mShellThickness; 
  Float_t mZLength;        
  Float_t mSampling;       
 
  // Members from the EMCGeometry class
  Float_t mECPbRadThickness; 
  Float_t mECScintThick;     
  Int_t mNECLayers;          
 
  // Shish-kebab option - 23-aug-04 by PAI; COMPACT, TWIST, TRD1 and TRD2
  Int_t mNumberOfSuperModules; 
 
  std::vector<EMCALSMType> mEMCSMSystem; 
 
  Float_t mFrontSteelStrip;   
  Float_t mLateralSteelStrip; 
  Float_t mPassiveScintThick; 
 
  Float_t mPhiSuperModule; 
  Int_t mNPhiSuperModule;  
 
  // TRD1 options - 30-sep-04
  Float_t mTrd1Angle;   
  Float_t m2Trd1Dx2;    
  Float_t mPhiGapForSM; 
 
  // Oct 26,2010
  Float_t mTrd1AlFrontThick;   
  Float_t mTrd1BondPaperThick; 
 
  Int_t mILOSS; 
  Int_t mIHADR; 
 
  Float_t mSteelFrontThick; 
 
  std::array<int, 46> mCRORCID = {110, 110, 112, 112, 110, 110, 112, 112, 110, 110, 112, 112, 111, 111, 113, 113, 111, 111, 113, 113, 111, 111, 113, 113, 114, 114, 116, 116, 114, 114, 116, 116, 115, 115, 117, 117, 115, 115, 117, 117, -1, -1, -1, -1, 111, 117}; // CRORC ID w.r.t SM
  std::array<int, 46> mCRORCLink = {0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 0, 1, 0, 1, 2, 3, 2, 3, 4, -1, 4, 5, 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, -1, -1, -1, -1, -1, 5, 3};                                                                                 // CRORC limk w.r.t FEE ID
 
  mutable const TGeoHMatrix* SMODULEMATRIX[EMCAL_MODULES];      
  std::vector<std::tuple<int, int, int, int>> mCellIndexLookup; 
 
 private:
  static Geometry* sGeom; 
};
 
inline Bool_t Geometry::CheckAbsCellId(Int_t absId) const
{
  if (absId < 0 || absId >= mNCells) {
    return kFALSE;
  } else {
    return kTRUE;
  }
}
} // namespace emcal
} // namespace o2
#endif