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_MFT_GEOMETRYTGEO_H_
#define ALICEO2_MFT_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 "MathUtils/Utils.h"
#include "Rtypes.h" // for Int_t, Double_t, Bool_t, UInt_t, etc
 
class TGeoPNEntry;
 
namespace o2
{
namespace mft
{
class GeometryTGeo : public o2::itsmft::GeometryTGeo
{
 public:
  typedef o2::math_utils::Transform3D Mat3D;
  using DetMatrixCache::getMatrixL2G;
  using DetMatrixCache::getMatrixT2G;
  using DetMatrixCache::getMatrixT2L;
 
  static GeometryTGeo* Instance()
  {
    // get (create if needed) a unique instance of the object
    if (!sInstance) {
      sInstance = std::unique_ptr<GeometryTGeo>(new GeometryTGeo(true, 0));
    }
    return sInstance.get();
  }
 
  static bool instanceExist() { return sInstance.get() != nullptr; }
 
  // 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_t build = kFALSE, Int_t loadTrans = 0
               /*o2::base::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, // default transformations to load
                                           o2::math_utils::TransformType::T2G,
                                           o2::math_utils::TransformType::L2G)*/
  );
 
  ~GeometryTGeo() override;
 
  GeometryTGeo(const GeometryTGeo& src) = delete;
  GeometryTGeo& operator=(const GeometryTGeo& geom) = delete;
 
  void destroy() { sInstance.reset(); }
 
  // implement filling of the matrix cache
  using o2::itsmft::GeometryTGeo::fillMatrixCache;
  void fillMatrixCache(Int_t mask) override;
  void updateL2GMatrixCache(std::vector<int> chipIDs = {});
 
  void Build(int loadTrans = 0) override;
 
  static const Char_t* getMFTVolPattern() { return sVolumeName.c_str(); }
  static const Char_t* getMFTHalfPattern() { return sHalfName.c_str(); }
  static const Char_t* getMFTDiskPattern() { return sDiskName.c_str(); }
  static const Char_t* getMFTLadderPattern() { return sLadderName.c_str(); }
  static const Char_t* getMFTChipPattern() { return sChipName.c_str(); }
  static const Char_t* getMFTSensorPattern() { return sSensorName.c_str(); }
  Int_t getSensorIndex(Int_t half, Int_t disk, Int_t ladder, Int_t sensor) const;
 
  Int_t getLayer(Int_t index) const;
 
  Bool_t getSensorID(Int_t index, Int_t& half, Int_t& disk, Int_t& ladder, Int_t& sensor) const;
 
  Int_t getNumberOfSensorsPerLadder(Int_t half, Int_t disk, Int_t ladder) const
  {
    return extractNumberOfSensorsPerLadder(half, disk, ladder);
  }
  Int_t getNumberOfLaddersPerDisk(Int_t half, Int_t disk, Int_t sensors) const
  {
    return extractNumberOfLadders(half, disk, sensors);
  }
  Int_t getNumberOfDisksPerHalf(Int_t half) const
  {
    return extractNumberOfDisks(half);
  }
  Int_t getNumberOfHalfs()
  {
    return extractNumberOfHalves();
  }
 
  Int_t getMinSensorsPerLadder()
  {
    return MinSensorsPerLadder;
  }
 
  Int_t getMaxSensorsPerLadder()
  {
    return MaxSensorsPerLadder;
  }
 
  Int_t getLadderID(Int_t disk, Int_t ladder) const
  {
    return mLadderIndex2Id[disk][ladder];
  }
 
  static const char* composeSymNameMFT() { return o2::detectors::DetID(o2::detectors::DetID::MFT).getName(); }
 
  static const char* composeSymNameHalf(int hf);
 
  static const char* composeSymNameDisk(int hf, int dk);
 
  static const char* composeSymNameLadder(int hf, int dk, int lr);
 
  static const char* composeSymNameChip(int hf, int dk, int lr, int chip);
 
 protected:
  Int_t extractNumberOfHalves();
 
  Int_t extractNumberOfDisks(Int_t half) const;
 
  Int_t extractNumberOfLadders(Int_t half, Int_t disk, Int_t nsensors) const;
 
  Int_t extractNumberOfLadders(Int_t half, Int_t disk, Int_t nsensors, Int_t& nL);
 
  Int_t extractNumberOfSensorsPerLadder(Int_t half, Int_t disk, Int_t ladder) const;
 
  Int_t extractVolumeCopy(const Char_t* name, const Char_t* prefix) const;
 
  TGeoHMatrix* extractMatrixSensor(Int_t index) const;
 
  // Create matrix for transformation from sensor local frame to global one
  TGeoHMatrix& createT2LMatrix(Int_t isn);
 
  void extractSensorXAlpha(int index, float& x, float& alp);
 
  Int_t getHalf(Int_t index) const;
 
  Int_t getDisk(Int_t index) const;
 
  Int_t getLadder(Int_t index) const;
 
  Int_t getFirstSensorIndex(Int_t disk) const { return (disk == 0) ? 0 : mLastSensorIndex[disk - 1] + 1; }
 
 protected:
  static constexpr Int_t MinSensorsPerLadder = 2;
  static constexpr Int_t MaxSensorsPerLadder = 5;
 
  Int_t mTotalNumberOfSensors;                      
  Int_t mNumberOfHalves;                            
  std::vector<Int_t> mNumberOfDisks;                
  std::vector<std::vector<Int_t>> mNumberOfLadders; 
  std::vector<Int_t> mNumberOfLaddersPerDisk;       
 
  std::vector<std::vector<Int_t>> mLadderIndex2Id; 
  std::vector<std::vector<Int_t>> mLadderId2Index; 
 
  std::vector<Int_t> mLastSensorIndex;        
  std::vector<Int_t> mSensorIndexToLayer;     
  std::vector<Int_t> mNumberOfSensorsPerDisk; 
  std::vector<Float_t> mLayerMedianZ;         
 
  static std::string sVolumeName; 
  static std::string sHalfName;   
  static std::string sDiskName;   
  static std::string sLadderName; 
  static std::string sChipName;   
  static std::string sSensorName; 
 
 private:
  static std::unique_ptr<o2::mft::GeometryTGeo> sInstance; 
 
  ClassDefOverride(GeometryTGeo, 1); // MFT geometry based on TGeo
};
} // namespace mft
} // namespace o2
 
#endif