V1Layer.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_UPGRADEV1LAYER_H_
#define ALICEO2_ITS_UPGRADEV1LAYER_H_
 
#include <TGeoManager.h>               // for gGeoManager
#include "Rtypes.h"                    // for Double_t, Int_t, Bool_t, etc
#include "ITSSimulation/V11Geometry.h" // for V11Geometry
 
class TGeoArb8;
 
class TGeoCombiTrans;
 
class TGeoVolume; // lines 15-15
 
namespace o2
{
namespace its
{
 
class V1Layer : public V11Geometry
{
 
 public:
  enum {
    kStave,
    kHalfStave,
    kModule,
    kChip,
    kNHLevels
  };
 
  enum Model {
    kIBModelDummy = 0,
    kIBModel0 = 1,
    kIBModel1 = 2,
    kIBModel21 = 3,
    kIBModel22 = 4,
    kIBModel3 = 5,
    kIBModel4 = 10,
    kOBModelDummy = 6,
    kOBModel0 = 7,
    kOBModel1 = 8,
    kOBModel2 = 9
  };
 
  // Default constructor
  V1Layer();
 
  // Constructor setting debugging level
  V1Layer(Int_t debug, const char* name = "ITS");
 
  // Constructor setting layer number and debugging level
  V1Layer(Int_t lay, Int_t debug, const char* name = "ITS");
 
  V1Layer(Int_t lay, Bool_t turbo, Int_t debug, const char* name = "ITS");
 
  V1Layer(const V1Layer& source);
 
  V1Layer& operator=(const V1Layer& source);
 
  ~V1Layer() override;
 
  Bool_t isTurbo() const
  {
    return mIsTurbo;
  };
 
  Double_t getStaveThick() const
  {
    return mStaveThickness;
  };
 
  Double_t getStaveTilt() const
  {
    return mStaveTilt;
  };
 
  Double_t getStaveWidth() const
  {
    return mStaveWidth;
  };
 
  Double_t getSensorThick() const
  {
    return mSensorThickness;
  };
 
  Double_t getNumberOfStaves() const
  {
    return mNumberOfStaves;
  };
 
  Double_t getNumberOfChips() const
  {
    return mNumberOfChips;
  };
 
  Double_t getRadius() const
  {
    return mLayerRadius;
  };
 
  Double_t getPhi0() const
  {
    return mPhi0;
  };
 
  Double_t getZLength() const
  {
    return mZLength;
  };
 
  Int_t getChipType() const
  {
    return mChipTypeID;
  }
 
  Int_t getNumberOfStavesPerParent() const
  {
    return mHierarchy[kStave];
  }
 
  Int_t getNumberOfHalfStavesPerParent() const
  {
    return mHierarchy[kHalfStave];
  }
 
  Int_t getNumberOfModulesPerParent() const
  {
    return mHierarchy[kModule];
  }
 
  Int_t getNumberOfChipsPerParent() const
  {
    return mHierarchy[kChip];
  }
 
  Model getStaveModel() const
  {
    return mStaveModel;
  }
 
  void setStaveThick(Double_t t)
  {
    mStaveThickness = t;
  };
 
  void setStaveTilt(Double_t t);
 
  void setStaveWidth(Double_t w);
 
  void setSensorThick(Double_t t)
  {
    mSensorThickness = t;
  };
 
  void setNumberOfStaves(Int_t n)
  {
    mHierarchy[kStave] = mNumberOfStaves = n;
  };
 
  void setNumberOfUnits(Int_t u);
 
  void setRadius(Double_t r)
  {
    mLayerRadius = r;
  };
 
  void setPhi0(Double_t phi)
  {
    mPhi0 = phi;
  }
 
  void setZLength(Double_t z)
  {
    mZLength = z;
  };
 
  void setChipType(Int_t tp)
  {
    mChipTypeID = tp;
  }
 
  void setBuildLevel(Int_t buildLevel)
  {
    mBuildLevel = buildLevel;
  }
 
  void setStaveModel(Model model)
  {
    mStaveModel = model;
  }
 
  virtual void createLayer(TGeoVolume* motherVolume);
 
 private:
  void createLayerTurbo(TGeoVolume* motherVolume);
 
  Double_t radiusOmTurboContainer();
 
  TGeoVolume* createStave(const TGeoManager* mgr = gGeoManager);
 
  // TGeoVolume* createChip(Double_t x, Double_t z, const TGeoManager *mgr=gGeoManager);
 
  TGeoVolume* createModuleInnerB(Double_t x, Double_t y, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createChipInnerB(Double_t x, Double_t y, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createModuleOuterB(const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveInnerB(Double_t x, Double_t y, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveStructInnerB(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelInnerBDummy(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager) const;
 
  TGeoVolume* createStaveModelInnerB0(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelInnerB1(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelInnerB21(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelInnerB22(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelInnerB3(Double_t x, Double_t z, const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveOuterB(const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelOuterBDummy(const TGeoManager* mgr = gGeoManager) const;
 
  TGeoVolume* createStaveModelOuterB0(const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createStaveModelOuterB1(const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createSpaceFrameOuterB(const TGeoManager* mgr = gGeoManager);
 
  TGeoVolume* createSpaceFrameOuterBDummy(const TGeoManager* mgr = gGeoManager) const;
 
  TGeoVolume* createSpaceFrameOuterB1(const TGeoManager* mgr = gGeoManager);
 
  TGeoArb8* createStaveSide(const char* name, Double_t dz, Double_t angle, Double_t xSign, Double_t L, Double_t H,
                            Double_t l);
 
  TGeoCombiTrans* createCombiTrans(const char* name, Double_t dy, Double_t dz, Double_t dphi,
                                   Bool_t planeSym = kFALSE);
 
  void addTranslationToCombiTrans(TGeoCombiTrans* ct, Double_t dx = 0, Double_t dy = 0, Double_t dz = 0) const;
 
  Int_t mLayerNumber;        
  Double_t mPhi0;            
  Double_t mLayerRadius;     
  Double_t mZLength;         
  Double_t mSensorThickness; 
  Double_t mStaveThickness;  
  Double_t mStaveWidth;      
  Double_t mStaveTilt;       
  Int_t mNumberOfStaves;     
  Int_t mNumberOfModules;    
  Int_t mNumberOfChips; 
  Int_t mHierarchy[kNHLevels]; 
 
  UInt_t mChipTypeID; 
  Bool_t mIsTurbo;    
  Int_t mBuildLevel;  
 
  Model mStaveModel; 
 
  // Parameters for the  geometry
 
  // General Parameters
  static const Int_t sNumberOmInnerLayers; 
 
  static const Double_t sDefaultSensorThick; 
  static const Double_t sDefaultStaveThick;  
 
  // Inner Barrel Parameters
  static const Int_t sIBChipsPerRow; 
  static const Int_t sIBNChipRows;   
 
  // Outer Barrel Parameters
  static const Int_t sOBChipsPerRow; 
  static const Int_t sOBNChipRows;   
 
  static const Double_t sOBHalfStaveWidth;    
  static const Double_t sOBModuleWidth;       
  static const Double_t sOBModuleGap;         
  static const Double_t sOBChipXGap;          
  static const Double_t sOBChipZGap;          
  static const Double_t sOBFlexCableAlThick;  
  static const Double_t sOBFlexCableKapThick; 
  static const Double_t sOBBusCableAlThick;   
  static const Double_t sOBBusCableKapThick;  
  static const Double_t sOBCarbonPlateThick;  
  static const Double_t sOBColdPlateThick;    
  static const Double_t sOBGlueThick;         
  static const Double_t sOBModuleZLength;     
  static const Double_t sOBHalfStaveYTrans;   
  static const Double_t sOBHalfStaveXOverlap; 
  static const Double_t sOBGraphiteFoilThick; 
  static const Double_t sOBCoolTubeInnerD;    
  static const Double_t sOBCoolTubeThick;     
  static const Double_t sOBCoolTubeXDist;     
 
  static const Double_t sOBSpaceFrameWidth;   
  static const Double_t sOBSpaceFrameTotHigh; 
  static const Double_t sOBSFrameBeamRadius;  
  static const Double_t sOBSpaceFrameLa;      
  static const Double_t sOBSpaceFrameHa;      
  static const Double_t sOBSpaceFrameLb;      
  static const Double_t sOBSpaceFrameHb;      
  static const Double_t sOBSpaceFrameL;       
  static const Double_t sOBSFBotBeamAngle;    
  static const Double_t sOBSFrameBeamSidePhi; 
 
  ClassDefOverride(V1Layer, 0); // ITS v1 geometry
};
} // namespace its
} // namespace o2
 
#endif