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_FV0_GEOMETRY_H_
#define ALICEO2_FV0_GEOMETRY_H_
#include "DetectorsBase/GeometryManager.h"
#include "DetectorsCommonDataFormats/DetID.h"
#include <Rtypes.h>
#include <TGeoPhysicalNode.h>
#include <vector>
#include <array>
#include <TGeoMatrix.h>
#include <TGeoVolume.h>
#include <TVirtualMC.h>
 
class TGeoPNEntry;
 
namespace o2
{
namespace fv0
{
 
struct Point3Dsimple {
  float x;
  float y;
  float z;
  void SetCoordinates(float x, float y, float z)
  {
    this->x = x;
    this->y = y;
    this->z = z;
  };
};
 
class Geometry
{
 public:
  enum EGeoType {
    eUninitialized,
    eOnlySensitive,
    eRough,
    eFull
  };
 
  enum EGeoComponent {
    eScintillator,
    ePlastics,
    ePmts,
    eFibers,
    eScrews,
    eRods,
    eContainer
  };
 
  Geometry() : mGeometryType(eUninitialized), mLeftTransformation(nullptr), mRightTransformation(nullptr){};
 
  Geometry(const Geometry& geometry);
 
  static Geometry* instance(EGeoType initType = eUninitialized);
 
  ~Geometry();
 
  int getCurrentCellId(const TVirtualMC* fMC) const;
 
  const std::vector<std::string>& getSensitiveVolumeNames() const { return mSensitiveVolumeNames; };
 
  bool enableComponent(EGeoComponent component, bool enable = true);
 
  void buildGeometry() const;
 
 
  void getGlobalPosition(float& x, float& y, float& z);
  Point3Dsimple& getCellCenter(UInt_t cellId);
  Point3Dsimple& getReadoutCenter(UInt_t cellId);
  static constexpr int getNumberOfReadoutChannels() { return sNumberOfReadoutChannels; };
 
  bool isRing5(UInt_t cellId);
 
  static constexpr o2::detectors::DetID::ID getDetID() { return o2::detectors::DetID::FV0; }
  TGeoPNEntry* getPNEntry(int index) const
  {
    return o2::base::GeometryManager::getPNEntry(getDetID(), index);
  }
 
  static std::string getDetectorRightSymName()
  {
    return sDetectorRightName + "_0";
  }
 
  static std::string getDetectorLeftSymName()
  {
    return sDetectorLeftName + "_1";
  }
 
  static constexpr float getPmtDensity()
  {
    return sDensityPmt;
  }
 
 private:
  explicit Geometry(EGeoType initType);
 
  inline static const std::string sDetectorName = "FV0";
  inline static const std::string sDetectorRightName = sDetectorName + "RIGHT";
  inline static const std::string sDetectorLeftName = sDetectorName + "LEFT";
 
  // General geometry constants
  static constexpr float sEpsilon = 0.01;     
  static constexpr float sDzScintillator = 4; 
  static constexpr float sDzPlastic = 1;      
 
  static constexpr float sXGlobal = 0; 
  static constexpr float sYGlobal = 0; 
  // FT0 starts at z=328
  static constexpr float sZGlobal = 320 - sDzScintillator / 2; 
  static constexpr float sDxHalvesSeparation = 0;              
  static constexpr float sDyHalvesSeparation = 0;              
  static constexpr float sDzHalvesSeparation = 0;              
 
  static constexpr int sNumberOfCellSectors = 4;                                             
  static constexpr int sNumberOfCellRings = 5;                                               
  static constexpr int sNumberOfCells = sNumberOfCellRings * sNumberOfCellSectors * 2;       
  static constexpr int sNumberOfReadoutChannels = sNumberOfCells + sNumberOfCellSectors * 2; 
 
  static constexpr int sCellToRing[sNumberOfCells] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
  static constexpr int sCellToSector[sNumberOfCells] = {0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
 
  static constexpr float sCellRingRadii[sNumberOfCellRings + 1]{4.01, 7.3, 12.9, 21.25, 38.7, 72.115};
  static constexpr char sCellTypes[sNumberOfCellSectors]{'a', 'b', 'b', 'a'}; 
  static constexpr float sDrSeparationScint = 0.03 + 0.04;
 
  static constexpr float sXShiftInnerRadiusScintillator = -0.15;
  static constexpr float sDxHoleExtensionScintillator = 0.2;
  static constexpr float sDrHoleSmallScintillator = 0.265; 
  static constexpr float sDrHoleLargeScintillator = 0.415; 
 
  // Container constants
  static constexpr float sDzContainer = 30;                  
  static constexpr float sDrContainerHole = 4.05;            
  static constexpr float sXShiftContainerHole = -0.15;       
  static constexpr float sDrMaxContainerBack = 83.1;         
  static constexpr float sDzContainerBack = 1;               
  static constexpr float sDrMinContainerFront = 45.7;        
  static constexpr float sDrMaxContainerFront = 83.1;        
  static constexpr float sDzContainerFront = 1;              
  static constexpr float sDxContainerStand = 40;             
  static constexpr float sDyContainerStand = 3;              
  static constexpr float sDrMinContainerCone = 24.3;         
  static constexpr float sDzContainerCone = 16.2;            
  static constexpr float sThicknessContainerCone = 0.6;      
  static constexpr float sXYThicknessContainerCone = 0.975;  
  static constexpr float sDrMinContainerOuterShield = 82.5;  
  static constexpr float sDrMaxContainerOuterShield = 82.65; 
  static constexpr float sDrMinContainerInnerShield = 4;     
  static constexpr float sDrMaxContainerInnerShield = 4.05;  
  static constexpr float sDxContainerCover = 0.15;           
  static constexpr float sDxContainerStandBottom = 38.5;     
  static constexpr float sDyContainerStandBottom = 2;        
 
  // PMT constants
  static constexpr int sNumberOfPMTs = 24;                                        
  static constexpr int sNumberOfPMTsPerSector = 6;                                
  static constexpr float sDrPmt = 3.75;                                           
  static constexpr float sDzPmt = 12.199;                                         
  static constexpr float sMPmt = 376.77;                                          
  static constexpr float sDensityPmt = sMPmt / (M_PI * sDrPmt * sDrPmt * sDzPmt); 
 
  // Fiber constants
  static constexpr int sNumberOfPMTFiberVolumes = 5; 
  static constexpr int sPMTFiberCellOrder[sNumberOfPMTsPerSector] = {2, 5, 4, 3, 5, 1};
 
  // Local position constants
 
  static constexpr float sXScintillator = sDxContainerCover;
  static constexpr float sZScintillator = 0;
  static constexpr float sZPlastic = sZScintillator + sDzScintillator / 2 + sDzPlastic / 2;
  static constexpr float sZContainerBack = sZScintillator - sDzScintillator / 2 - sDzContainerBack / 2;
  static constexpr float sZContainerFront = sZContainerBack - sDzContainerBack / 2 + sDzContainer - sDzContainerFront / 2;
  static constexpr float sZContainerMid = (sZContainerBack + sZContainerFront) / 2;
  static constexpr float sZFiber = (sZPlastic + sZContainerFront) / 2;
  static constexpr float sZCone = sZContainerFront + sDzContainerFront / 2 - sDzContainerCone / 2;
  static constexpr float sXShiftScrews = sXScintillator;
  static constexpr float sXPmt[sNumberOfPMTs] = {8.023, 16.612, 24.987, 33.042, 40.671, 47.778, 59.646, 64.73, 68.982, 72.348, 74.783, 76.257, 76.330, 74.931, 72.569, 69.273, 65.088, 60.065, 48.3, 41.238, 33.645, 25.62, 17.265, 8.688};
  static constexpr float sYPmt[sNumberOfPMTs] = {76.33, 74.931, 72.569, 69.273, 65.088, 60.065, 48.3, 41.238, 33.645, 25.62, 17.265, 8.688, -8.023, -16.612, -24.987, -33.042, -40.671, -47.778, -59.646, -64.73, -68.982, -72.348, -74.783, -76.257};
  static constexpr float sZPmt = sZContainerBack + sDzContainerBack / 2 + sDzPmt / 2;
 
  // Screw and rod dimensions
 
  static constexpr int sNumberOfScrewTypes = 6;
  static constexpr float sDrMinScrewTypes[sNumberOfScrewTypes]{0.25, 0.25, 0.4, 0.4, 0.4, 0.4};
  static constexpr float sDrMaxScrewTypes[sNumberOfScrewTypes]{0, 0.5, 0.6, 0.6, 0.6, 0};
  static constexpr float sDzMaxScrewTypes[sNumberOfScrewTypes]{6.02, 13.09, 13.1, 23.1, 28.3, 5};
  static constexpr float sDzMinScrewTypes[sNumberOfScrewTypes]{0, 6.78, 6.58, 15.98, 21.48, 0};
  static constexpr float sZShiftScrew = 0;
 
  static constexpr int sNumberOfRodTypes = 4;
  static constexpr float sDxMinRodTypes[sNumberOfRodTypes]{0.366, 0.344, 0.344, 0.344};
  static constexpr float sDxMaxRodTypes[sNumberOfRodTypes]{0.536, 0.566, 0.566, 0.716};
  static constexpr float sDyMinRodTypes[sNumberOfRodTypes]{0.5, 0.8, 0.8, 0.8};
  static constexpr float sDyMaxRodTypes[sNumberOfRodTypes]{0.9, 1.2, 1.2, 1.2};
  static constexpr float sDzMaxRodTypes[sNumberOfRodTypes]{12.5, 12.5, 22.5, 27.7};
  static constexpr float sDzMinRodTypes[sNumberOfRodTypes]{7.45, 7.45, 17.45, 22.65};
  static constexpr float sZShiftRod = -0.05;
 
  // Strings for volume names, etc.
  inline static const std::string sScintillatorName = "SCINT";
  inline static const std::string sPlasticName = "PLAST";
  inline static const std::string sSectorName = "SECTOR";
  inline static const std::string sCellName = "CELL";
  inline static const std::string sScintillatorSectorName = sScintillatorName + sSectorName;
  inline static const std::string sScintillatorCellName = sScintillatorName + sCellName;
  inline static const std::string sPlasticSectorName = sPlasticName + sSectorName;
  inline static const std::string sPlasticCellName = sPlasticName + sCellName;
  inline static const std::string sPmtName = "PMT";
  inline static const std::string sFiberName = "FIBER";
  inline static const std::string sScrewName = "SCREW";
  inline static const std::string sScrewHolesCSName = "FV0SCREWHOLES";
  inline static const std::string sRodName = "ROD";
  inline static const std::string sRodHolesCSName = "FV0RODHOLES";
  inline static const std::string sContainerName = "CONTAINER";
 
  void initializeGeometry();
 
  void initializeMaps();
 
  void initializeVectors();
 
  void initializeTransformations();
 
  void initializeCellRingRadii();
 
  void initializeSectorTransformations();
 
  void initializeFiberVolumeRadii();
 
  void initializeFiberMedium();
 
  void initializeScrewAndRodRadii();
 
  void initializeScrewTypeMedium();
 
  void initializeRodTypeMedium();
 
  void addScrewProperties(int screwTypeID, int iRing, float phi);
 
  void addRodProperties(int rodTypeID, int iRing);
 
  void initializeScrewAndRodPositionsAndDimensions();
 
  void initializeSensVols();
 
  void initializeNonSensVols();
 
  void initializeScrewHoles();
 
  void initializeRodHoles();
 
  void initializeCells(const std::string& cellType, const float zThickness, const TGeoMedium* medium, bool isSensitive);
 
  void initializeScintCells();
 
  void initializePlasticCells();
 
  void initializePmts();
 
  void initializeFibers();
 
  void initializeScrews();
 
  void initializeRods();
 
  void initializeMetalContainer();
 
  void assembleSensVols(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleNonSensVols(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleScintSectors(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assemblePlasticSectors(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assemblePmts(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleFibers(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleScrews(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleRods(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  void assembleMetalContainer(TGeoVolume* vFV0Right, TGeoVolume* vFV0Left) const;
 
  TGeoVolumeAssembly* buildSectorAssembly(const std::string& cellName) const;
 
  TGeoVolumeAssembly* buildSector(const std::string& cellType, int iSector) const;
 
  TGeoShape* createScrewShape(const std::string& shapeName, int screwTypeID, float xEpsilon = 0, float yEpsilon = 0,
                              float zEpsilon = 0) const;
 
  TGeoShape* createRodShape(const std::string& shapeName, int rodTypeID, float xEpsilon = 0, float yEpsilon = 0,
                            float zEpsilon = 0) const;
 
  TGeoTranslation* createAndRegisterTrans(const std::string& name, double dx = 0, double dy = 0, double dz = 0) const;
 
  TGeoRotation* createAndRegisterRot(const std::string& name, double phi = 0, double theta = 0, double psi = 0) const;
 
  const std::string createVolumeName(const std::string& volumeType, int number = -1) const;
 
  void initializeCellCenters();    
  void initializeReadoutCenters(); 
 
  std::vector<std::string> mSensitiveVolumeNames; 
 
  std::vector<float> mRAvgRing;
  std::vector<float> mRMinScintillator; 
  std::vector<float> mRMaxScintillator; 
  std::vector<float> mRMinFiber;        
  std::vector<float> mRMaxFiber;        
 
  std::vector<TGeoMedium*> mMediumFiberRings;
  std::vector<TGeoMedium*> mMediumFiberPMTs;
 
  std::vector<float> mRScrewAndRod; 
 
  std::vector<float> mDrMinScrews; 
  std::vector<float> mDrMaxScrews; 
  std::vector<float> mDzMaxScrews; 
  std::vector<float> mDzMinScrews; 
 
  std::vector<float> mRScrews;    
  std::vector<int> mScrewTypeIDs; 
 
  std::vector<float> mDxMinRods; 
  std::vector<float> mDxMaxRods; 
  std::vector<float> mDyMinRods; 
  std::vector<float> mDyMaxRods; 
  std::vector<float> mDzMaxRods; 
  std::vector<float> mDzMinRods; 
  std::vector<int> mRodTypeIDs;  
 
  std::vector<TGeoMatrix*> mSectorTrans;      
  std::vector<std::vector<float>> mScrewPos;  
  std::vector<std::vector<float>> mRodPos;    
  std::vector<TGeoMedium*> mMediumScrewTypes; 
  std::vector<TGeoMedium*> mMediumRodTypes;   
 
  const int mGeometryType;                          
  std::map<EGeoComponent, bool> mEnabledComponents; 
  TGeoMatrix* mLeftTransformation;                  
  TGeoMatrix* mRightTransformation;                 
 
  std::array<Point3Dsimple, sNumberOfCells> mCellCenter;              
  std::array<Point3Dsimple, sNumberOfReadoutChannels> mReadoutCenter; 
 
  static Geometry* sInstance; 
 
  ClassDefNV(Geometry, 1);
};
} // namespace fv0
} // namespace o2
#endif