GeometryTGeo.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_ITS_GEOMETRYTGEO_H_
#define ALICEO2_ITS_GEOMETRYTGEO_H_
 
#include <TGeoMatrix.h> // for TGeoHMatrix
#include <TObject.h>    // for TObject
#include <array>
#include <string>
#include <vector>
#include "DetectorsBase/GeometryManager.h"
#include "DetectorsCommonDataFormats/DetID.h"
#include "ITSMFTBase/GeometryTGeo.h"
#include "Rtypes.h" // for Int_t, Double_t, Bool_t, UInt_t, etc
 
#ifdef ENABLE_UPGRADES
#include "ITS3Base/SpecsV2.h"
#endif
 
class TGeoPNEntry;
 
namespace o2::its
{
 
class GeometryTGeo : public o2::itsmft::GeometryTGeo
{
 public:
  using Mat3D = o2::math_utils::Transform3D;
  using DetMatrixCache::getMatrixL2G;
  using DetMatrixCache::getMatrixT2GRot;
  using DetMatrixCache::getMatrixT2L;
  // this method is not advised for ITS: for barrel detectors whose tracking frame is just a rotation
  // it is cheaper to use T2GRot
  using DetMatrixCache::getMatrixT2G;
 
  static GeometryTGeo* Instance()
  {
    // get (create if needed) a unique instance of the object
#ifdef GPUCA_STANDALONE
    return nullptr; // TODO: DR: Obviously wrong, but to make it compile for now
#else
    if (!sInstance) {
      sInstance = std::make_unique<GeometryTGeo>(true, 0);
    }
    return sInstance.get();
#endif
  }
 
  static bool instanceExist()
  {
#ifdef GPUCA_STANDALONE
    return false;
#else
    return sInstance.get() != nullptr;
#endif
  }
 
  // Adopt the unique instance from external raw pointer (to be used only to read saved instance from file)
  // When adopting an object owned by the CCDB cache we should not delete it
  static void adopt(GeometryTGeo* raw, bool canDelete = false);
  // constructor
  // ATTENTION: this class is supposed to behave as a singleton, but to make it root-persistent
  // we must define public default constructor.
  // NEVER use it, it will throw exception if the class instance was already created
  // Use GeometryTGeo::Instance() instead
  GeometryTGeo(bool build = kFALSE, int loadTrans = 0);
 
  ~GeometryTGeo() override;
  void destroy()
  {
#ifndef GPUCA_STANDALONE
    sInstance.reset(); // TODO: DR: See above
#endif
  }
 
  GeometryTGeo(const GeometryTGeo& src) = delete;
  GeometryTGeo& operator=(const GeometryTGeo& geom) = delete;
 
  // implement filling of the matrix cache
  using o2::itsmft::GeometryTGeo::fillMatrixCache;
  void fillMatrixCache(int mask) override;
 
  // cache parameters of sensors tracking frames
  void fillTrackingFramesCache();
 
  void Build(int loadTrans = 0) override;
 
  int getNumberOfChipRowsPerModule(int lay) const { return mNumberOfChipRowsPerModule[lay]; }
  int getNumberOfChipColsPerModule(int lay) const
  {
#ifdef ENABLE_UPGRADES
    if (mIsLayerITS3[lay]) {
      return o2::its3::constants::pixelarray::nCols;
    }
#endif
    return mNumberOfChipRowsPerModule[lay] != 0 ? mNumberOfChipsPerModule[lay] / mNumberOfChipRowsPerModule[lay] : -1;
  }
 
  int getNumberOfChipsPerModule(int lay) const { return mNumberOfChipsPerModule[lay]; }
  int getNumberOfChipsPerHalfStave(int lay) const { return mNumberOfChipsPerHalfStave[lay]; }
  int getNumberOfChipsPerStave(int lay) const { return mNumberOfChipsPerStave[lay]; }
  int getNumberOfChipsPerHalfBarrel(int lay) const { return mNumberOfChipsPerHalfBarrel[lay]; }
  int getNumberOfChipsPerLayer(int lay) const { return mNumberOfChipsPerLayer[lay]; }
  int getNumberOfModules(int lay) const { return mNumberOfModules[lay]; }
  int getNumberOfHalfStaves(int lay) const { return mNumberOfHalfStaves[lay]; }
  int getNumberOfStaves(int lay) const { return mNumberOfStaves[lay]; }
  int getNumberOfHalfBarrels() const { return mNumberOfHalfBarrels; }
  int getNumberOfLayers() const { return mNumberOfLayers; }
  int getChipIndex(int lay, int detInLay) const { return getFirstChipIndex(lay) + detInLay; }
  int getChipIndex(int lay, int hba, int sta, int detInSta) const;
 
  int getChipIndex(int lay, int hba, int sta, int subSta, int detInSubSta) const;
 
  int getChipIndex(int lay, int hba, int sta, int subSta, int md, int detInMod) const;
 
  bool getChipId(int index, int& lay, int& sta, int& ssta, int& mod, int& chip) const;
 
  bool getChipId(int index, int& lay, int& hba, int& sta, int& ssta, int& mod, int& chip) const;
 
  int getLayer(int index) const;
 
  int getHalfBarrel(int index) const;
 
  int getStave(int index) const;
 
  int getHalfStave(int index) const;
 
  int getModule(int index) const;
 
  int getChipIdInLayer(int index) const;
 
  int getChipIdInStave(int index) const;
 
  int getChipIdInHalfStave(int index) const;
 
  int getChipIdInModule(int index) const;
 
  int getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
  int getFirstChipIndex(int lay) const { return (lay == 0) ? 0 : mLastChipIndex[lay - 1] + 1; }
  const char* getSymbolicName(int index) const
  {
    return o2::base::GeometryManager::getSymbolicName(getDetID(), index);
  }
 
  const char* getSymbolicName(int lay, int hba, int sta, int det) const
  {
    return getSymbolicName(getChipIndex(lay, hba, sta, det));
  }
 
  TGeoHMatrix* getMatrix(int index) const { return o2::base::GeometryManager::getMatrix(getDetID(), index); }
  TGeoHMatrix* getMatrix(int lay, int hba, int sta, int sens) const { return getMatrix(getChipIndex(lay, hba, sta, sens)); }
  bool getOriginalMatrix(int index, TGeoHMatrix& m) const
  {
    return o2::base::GeometryManager::getOriginalMatrix(getDetID(), index, m);
  }
 
  bool getOriginalMatrix(int lay, int hba, int sta, int det, TGeoHMatrix& m) const
  {
    return getOriginalMatrix(getChipIndex(lay, hba, sta, det), m);
  }
 
  const Mat3D& getMatrixT2L(int lay, int hba, int sta, int det) const { return getMatrixT2L(getChipIndex(lay, hba, sta, det)); }
  const Mat3D& getMatrixSensor(int index) const { return getMatrixL2G(index); }
  const Mat3D& getMatrixSensor(int lay, int hba, int sta, int det) const
  {
    // get positioning matrix of the sensor, alias to getMatrixL2G
    return getMatrixSensor(getChipIndex(lay, hba, sta, det));
  }
 
  const Rot2D& getMatrixT2GRot(int lay, int hba, int sta, int sens)
  {
    return getMatrixT2GRot(getChipIndex(lay, hba, sta, sens));
  }
 
  bool isTrackingFrameCached() const { return !mCacheRefX.empty(); }
  void getSensorXAlphaRefPlane(int index, float& x, float& alpha) const
  {
    x = getSensorRefX(index);
    alpha = getSensorRefAlpha(index);
  }
 
  float getSensorRefX(int isn) const { return mCacheRefX[isn]; }
  float getSensorRefAlpha(int isn) const { return mCacheRefAlpha[isn]; }
  // Attention: these are transformations wrt sensitive volume!
  void localToGlobal(int index, const double* loc, double* glob);
 
  void localToGlobal(int lay, int sta, int det, const double* loc, double* glob);
 
  void globalToLocal(int index, const double* glob, double* loc);
 
  void globalToLocal(int lay, int sta, int det, const double* glob, double* loc);
 
  void localToGlobalVector(int index, const double* loc, double* glob);
 
  void globalToLocalVector(int index, const double* glob, double* loc);
 
  void Print(Option_t* opt = "") const;
 
  static const char* getITSVolPattern() { return sVolumeName.c_str(); }
  static const char* getITSLayerPattern() { return sLayerName.c_str(); }
  static const char* getITSHalfBarrelPattern() { return sHalfBarrelName.c_str(); }
  static const char* getITSWrapVolPattern() { return sWrapperVolumeName.c_str(); }
  static const char* getITSStavePattern() { return sStaveName.c_str(); }
  static const char* getITSHalfStavePattern() { return sHalfStaveName.c_str(); }
  static const char* getITSModulePattern() { return sModuleName.c_str(); }
  static const char* getITSChipPattern() { return sChipName.c_str(); }
  static const char* getITSSensorPattern() { return sSensorName.c_str(); }
  static void setITSVolPattern(const char* nm) { sVolumeName = nm; }
  static void setITSLayerPattern(const char* nm) { sLayerName = nm; }
  static void setITSHalfBarrelPattern(const char* nm) { sHalfBarrelName = nm; }
  static void setITSWrapVolPattern(const char* nm) { sWrapperVolumeName = nm; }
  static void setITSStavePattern(const char* nm) { sStaveName = nm; }
  static void setITSHalfStavePattern(const char* nm) { sHalfStaveName = nm; }
  static void setITSModulePattern(const char* nm) { sModuleName = nm; }
  static void setITSChipPattern(const char* nm) { sChipName = nm; }
  static void setITSSensorPattern(const char* nm) { sSensorName = nm; }
 
  static const char* getITS3LayerPattern() { return sLayerNameITS3.c_str(); }
  static const char* getITS3HalfBarrelPattern() { return sHalfBarrelNameITS3.c_str(); }
  static const char* getITS3StavePattern() { return sStaveNameITS3.c_str(); }
  static const char* getITS3HalfStavePattern() { return sHalfStaveNameITS3.c_str(); }
  static const char* getITS3ModulePattern() { return sModuleNameITS3.c_str(); }
  static const char* getITS3ChipPattern() { return sChipNameITS3.c_str(); }
  static const char* getITS3SensorPattern() { return sSensorNameITS3.c_str(); }
 
  static const char* getITS3LayerPatternRaw() { return sLayerNameITS3.c_str(); };
  static const char* getITS3LayerPattern(int layer) { return Form("%s%d", getITS3LayerPatternRaw(), layer); };
  static const char* getITS3CarbonFormPatternRaw() { return sHalfBarrelNameITS3.c_str(); };
  static const char* getITS3CarbonFormPattern(int layer) { return Form("%s%d", getITS3CarbonFormPatternRaw(), layer); };
  static const char* getITS3ChipPatternRaw() { return sStaveNameITS3.c_str(); };
  static const char* getITS3ChipPattern(int layer) { return Form("%s%d", getITS3ChipPatternRaw(), layer); };
  static const char* getITS3SegmentPatternRaw() { return sHalfStaveNameITS3.c_str(); };
  static const char* getITS3SegmentPattern(int layer) { return Form("%s%d", getITS3SegmentPatternRaw(), layer); };
  static const char* getITS3RSUPatternRaw() { return sModuleNameITS3.c_str(); };
  static const char* getITS3RSUPattern(int layer) { return Form("%s%d", getITS3RSUPatternRaw(), layer); };
  static const char* getITS3TilePatternRaw() { return sChipNameITS3.c_str(); };
  static const char* getITS3TilePattern(int layer) { return Form("%s%d", getITS3TilePatternRaw(), layer); };
  static const char* getITS3PixelArrayPatternRaw() { return sSensorNameITS3.c_str(); };
  static const char* getITS3PixelArrayPattern(int layer) { return Form("%s%d", getITS3PixelArrayPatternRaw(), layer); };
 
  static const char* composeSymNameITS(bool isITS3 = false);
  static const char* composeSymNameLayer(int lr, bool isITS3 = false);
 
  static const char* composeSymNameHalfBarrel(int lr, int hba, bool isITS3 = false);
 
  static const char* composeSymNameStave(int lr, int hba, int sta, bool isITS3 = false);
 
  static const char* composeSymNameHalfStave(int lr, int hba, int sta, int ssta, bool isITS3 = false);
 
  static const char* composeSymNameModule(int lr, int hba, int sta, int ssta, int mod, bool isITS3 = false);
 
  static const char* composeSymNameChip(int lr, int hba, int sta, int ssta, int mod, int chip, bool isITS3 = false);
 
  // create matrix for transformation from tracking frame to local one for ITS3
  const Mat3D getT2LMatrixITS3(int isn, float alpha);
 
  TString getMatrixPath(int index) const;
 
  TGeoHMatrix* extractMatrixSensor(int index) const;
 
  // create matrix for transformation from sensor local frame to global one
  TGeoHMatrix& createT2LMatrix(int isn);
 
  // get sensor tracking frame alpha and x
  void extractSensorXAlpha(int isn, float& x, float& alp);
 
 protected:
  bool getLayer(int index, int& lay, int& index2) const;
 
  int extractNumberOfChipsPerModule(int lay, int& nrow) const;
 
  int extractNumberOfHalfBarrels() const;
 
  int extractNumberOfStaves(int lay) const;
 
  int extractNumberOfHalfStaves(int lay) const;
 
  int extractNumberOfModules(int lay) const;
 
  int extractLayerChipType(int lay) const;
 
  int extractNumberOfLayers();
 
  int extractVolumeCopy(const char* name, const char* prefix) const;
 
  TGeoPNEntry* getPNEntry(int index) const
  {
    return o2::base::GeometryManager::getPNEntry(getDetID(), index);
  }
 
 protected:
  static constexpr int MAXLAYERS = 15; 
 
  Int_t mNumberOfLayers;                        
  Int_t mNumberOfHalfBarrels;                   
  std::vector<int> mNumberOfStaves;             
  std::vector<int> mNumberOfHalfStaves;         
  std::vector<int> mNumberOfModules;            
  std::vector<int> mNumberOfChipsPerModule;     
  std::vector<int> mNumberOfChipRowsPerModule;  
  std::vector<int> mNumberOfChipsPerHalfStave;  
  std::vector<int> mNumberOfChipsPerStave;      
  std::vector<int> mNumberOfChipsPerHalfBarrel; 
  std::vector<int> mNumberOfChipsPerLayer;      
  std::vector<int> mLastChipIndex;              
  std::array<bool, MAXLAYERS> mIsLayerITS3;     
  std::array<char, MAXLAYERS> mLayerToWrapper;  
 
  std::vector<float> mCacheRefX;     
  std::vector<float> mCacheRefAlpha; 
 
  static std::string sVolumeName;        
  static std::string sLayerName;         
  static std::string sHalfBarrelName;    
  static std::string sStaveName;         
  static std::string sHalfStaveName;     
  static std::string sModuleName;        
  static std::string sChipName;          
  static std::string sSensorName;        
  static std::string sWrapperVolumeName; 
 
  static const std::string sLayerNameITS3;      
  static const std::string sHalfBarrelNameITS3; 
  static const std::string sStaveNameITS3;      
  static const std::string sHalfStaveNameITS3;  
  static const std::string sModuleNameITS3;     
  static const std::string sChipNameITS3;       
  static const std::string sSensorNameITS3;     
 
 private:
#ifndef GPUCA_STANDALONE
  static std::unique_ptr<o2::its::GeometryTGeo> sInstance; 
#endif
 
  ClassDefOverride(GeometryTGeo, 2); // ITS geometry based on TGeo
};
} // namespace o2::its
 
#endif