GeometryBase.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 O2_TRD_GEOMETRYBASE_H
#define O2_TRD_GEOMETRYBASE_H
 
#include "GPUCommonDef.h"
#include "DataFormatsTRD/Constants.h"
#include "TRDBase/PadPlane.h"
 
namespace o2
{
namespace trd
{
class GeometryBase
{
 public:
  ~GeometryBase() = default;
 
  GPUd() int isVersion() { return 1; }
  GPUd() bool isHole(int la, int st, int se) const { return (((se == 13) || (se == 14) || (se == 15)) && (st == 2)); }
  GPUd() bool isOnBoundary(int det, float y, float z, float eps = 0.5) const;
 
  GPUd() void setSMstatus(int sm, bool status)
  {
    if (status) {
      mSMStatus |= 0x3ffff & (0x1 << sm);
    } else {
      mSMStatus &= ~(0x3ffff & (0x1 << sm));
    }
  }
  GPUd() bool getSMstatus(int sm) const { return (mSMStatus & (0x1 << sm)) != 0; }
  GPUd() static int getDetectorSec(int det) { return (det % (constants::NLAYER * constants::NSTACK)); }
  GPUd() static int getDetectorSec(int layer, int stack) { return (layer + stack * constants::NLAYER); }
  GPUd() static int getDetector(int layer, int stack, int sector) { return (layer + stack * constants::NLAYER + sector * constants::NLAYER * constants::NSTACK); }
  GPUd() static int getLayer(int det) { return (det % constants::NLAYER); }
  GPUd() static int getStack(int det) { return ((det % (constants::NLAYER * constants::NSTACK)) / constants::NLAYER); }
  GPUd() int getStack(float z, int layer) const;
 
  GPUd() const PadPlane* getPadPlane(int layer, int stack) const { return &mPadPlanes[getDetectorSec(layer, stack)]; }
  GPUd() const PadPlane* getPadPlane(int det) const { return &mPadPlanes[getDetectorSec(det)]; }
 
  GPUd() int getRowMax(int layer, int stack, int /*sector*/) const { return getPadPlane(layer, stack)->getNrows(); }
  GPUd() int getColMax(int layer) const { return getPadPlane(layer, 0)->getNcols(); }
  GPUd() float getRow0(int layer, int stack, int /*sector*/) const { return getPadPlane(layer, stack)->getRow0(); }
  GPUd() float getCol0(int layer) const { return getPadPlane(layer, 0)->getCol0(); }
 
  GPUd() float getRowPos(int layer, int stack, int row) { return mPadPlanes[getDetectorSec(layer, stack)].getRowPos(row); }
  GPUd() float getRowSize(int layer, int stack, int row) { return mPadPlanes[getDetectorSec(layer, stack)].getRowSize(row); }
  GPUd() float getRow0(int layer, int stack) { return mPadPlanes[getDetectorSec(layer, stack)].getRow0(); }
  GPUd() float getRowEnd(int layer, int stack) { return mPadPlanes[getDetectorSec(layer, stack)].getRowEnd(); }
 
  static constexpr GPUd() int getSector(int det) { return (det / (constants::NLAYER * constants::NSTACK)); }
  static constexpr GPUd() float getTime0(int layer) { return TIME0[layer]; }
  static constexpr GPUd() float getXtrdBeg() { return XTRDBEG; }
  static constexpr GPUd() float getXtrdEnd() { return XTRDEND; }
  static constexpr GPUd() float getChamberWidth(int layer) { return CWIDTH[layer]; }
  static constexpr GPUd() float getChamberLength(int layer, int stack) { return CLENGTH[layer][stack]; }
  static constexpr GPUd() float getAlpha() { return 2.0 * 3.14159265358979324 / constants::NSECTOR; }
  static constexpr GPUd() float cheight() { return CH; }
  static constexpr GPUd() float cheightSV() { return CHSV; }
  static constexpr GPUd() float cspace() { return VSPACE; }
  static constexpr GPUd() float craHght() { return CRAH; }
  static constexpr GPUd() float cdrHght() { return CDRH; }
  static constexpr GPUd() float camHght() { return CAMH; }
  static constexpr GPUd() float croHght() { return CROH; }
  static constexpr GPUd() float csvHght() { return CSVH; }
  static constexpr GPUd() float croWid() { return CROW; }
  static constexpr GPUd() float anodePos() { return ANODEPOS; }
  static constexpr GPUd() float myThick() { return RMYTHICK; }
  static constexpr GPUd() float drThick() { return DRTHICK; }
  static constexpr GPUd() float amThick() { return AMTHICK; }
  static constexpr GPUd() float drZpos() { return DRZPOS; }
  static constexpr GPUd() float rpadW() { return RPADW; }
  static constexpr GPUd() float cpadW() { return CPADW; }
  static constexpr GPUd() float cwidcha() { return (SWIDTH2 - SWIDTH1) / SHEIGHT * (CH + VSPACE); }
  static constexpr GPUd() int MCMmax() { return MCMMAX; }
  static constexpr GPUd() int MCMrow() { return MCMROW; }
  static constexpr GPUd() int ROBmaxC0() { return ROBMAXC0; }
  static constexpr GPUd() int ROBmaxC1() { return ROBMAXC1; }
  static constexpr GPUd() int ADCmax() { return ADCMAX; }
  static constexpr GPUd() int TBmax() { return TBMAX; }
  static constexpr GPUd() int padmax() { return PADMAX; }
  static constexpr GPUd() int colmax() { return COLMAX; }
  static constexpr GPUd() int rowmaxC0() { return ROWMAXC0; }
  static constexpr GPUd() int rowmaxC1() { return ROWMAXC1; }
 
 protected:
  GeometryBase() = default;
 
  static constexpr float TLENGTH = 751.0; 
 
  // Parameter of the super module mother volumes
  static constexpr float SHEIGHT = 77.9;    
  static constexpr float SWIDTH1 = 94.881;  
  static constexpr float SWIDTH2 = 122.353; 
  static constexpr float SLENGTH = 702.0;   
 
  // Length of the additional space in front of the supermodule used for services
  static constexpr float FLENGTH = (TLENGTH - SLENGTH) / 2.0;
 
  static constexpr float SMPLTT = 0.2; 
 
  static constexpr float VSPACE = 1.784; 
  static constexpr float HSPACE = 2.0;   
  static constexpr float VROCSM = 1.2;   
 
  static constexpr float CRAH = 4.8;                     
  static constexpr float CDRH = 3.0;                     
  static constexpr float CAMH = 0.7;                     
  static constexpr float CROH = 2.316;                   
  static constexpr float CROW = 0.9;                     
  static constexpr float CSVH = VSPACE - 0.742;          
  static constexpr float CH = CRAH + CDRH + CAMH + CROH; 
  static constexpr float CHSV = CH + CSVH;               
 
  // Distance of anode wire plane relative to middle of alignable volume
  static constexpr float ANODEPOS = CRAH + CDRH + CAMH / 2.0 - CHSV / 2.0;
 
  static constexpr float CALT = 0.4;    
  static constexpr float CCLST = 0.21;  
  static constexpr float CCLFT = 1.0;   
  static constexpr float CGLT = 0.25;   
  static constexpr float CCUTA = 1.0;   
  static constexpr float CCUTB = 0.8;   
  static constexpr float CAUT = 1.5;    
  static constexpr float CALW = 2.5;    
  static constexpr float CALH = 0.4;    
  static constexpr float CALWMOD = 0.4; 
  static constexpr float CALHMOD = 2.5; 
  static constexpr float CWSW = 1.2;    
  static constexpr float CWSH = 0.3;    
 
  static constexpr float CPADW = 0.0; 
  static constexpr float RPADW = 1.0; 
 
  //
  // Thickness of the the material layers
  //
  static constexpr float DRTHICK = CDRH;              
  static constexpr float AMTHICK = CAMH;              
  static constexpr float XETHICK = DRTHICK + AMTHICK; 
  static constexpr float WRTHICK = 0.00011;           
 
  static constexpr float RMYTHICK = 0.0015;                                        
  static constexpr float RCBTHICK = 0.0055;                                        
  static constexpr float RGLTHICK = 0.0065;                                        
  static constexpr float RRHTHICK = 0.8;                                           
  static constexpr float RFBTHICK = CRAH - 2.0 * (RMYTHICK + RCBTHICK + RRHTHICK); 
 
  static constexpr float PPDTHICK = 0.0025;                                                                                  
  static constexpr float PPPTHICK = 0.0356;                                                                                  
  static constexpr float PGLTHICK = 0.1428;                                                                                  
  static constexpr float PCBTHICK = 0.019;                                                                                   
  static constexpr float PPCTHICK = 0.0486;                                                                                  
  static constexpr float PRBTHICK = 0.0057;                                                                                  
  static constexpr float PELTHICK = 0.0029;                                                                                  
  static constexpr float PHCTHICK = CROH - PPDTHICK - PPPTHICK - PGLTHICK - PCBTHICK * 2.0 - PPCTHICK - PRBTHICK - PELTHICK; 
 
  //
  // Position of the material layers
  //
  static constexpr float DRZPOS = 2.4;                     
  static constexpr float AMZPOS = 0.0;                     
  static constexpr float WRZPOSA = 0.0;                    
  static constexpr float WRZPOSB = -AMTHICK / 2.0 + 0.001; 
  static constexpr float CALZPOS = 0.3;                    
 
  static constexpr int MCMMAX = 16;   
  static constexpr int MCMROW = 4;    
  static constexpr int ROBMAXC0 = 6;  
  static constexpr int ROBMAXC1 = 8;  
  static constexpr int ADCMAX = 21;   
  static constexpr int TBMAX = 60;    
  static constexpr int PADMAX = 18;   
  static constexpr int COLMAX = 144;  
  static constexpr int ROWMAXC0 = 12; 
  static constexpr int ROWMAXC1 = 16; 
 
  static constexpr float TIME0BASE = 300.65; 
  // Time-position of pad 0
  static constexpr float TIME0[6] = {TIME0BASE + 0 * (CH + VSPACE),
                                     TIME0BASE + 1 * (CH + VSPACE),
                                     TIME0BASE + 2 * (CH + VSPACE),
                                     TIME0BASE + 3 * (CH + VSPACE),
                                     TIME0BASE + 4 * (CH + VSPACE),
                                     TIME0BASE + 5 * (CH + VSPACE)};
 
  static constexpr float XTRDBEG = 288.43; 
  static constexpr float XTRDEND = 366.33; 
 
  // The outer width of the chambers
  static constexpr float CWIDTH[constants::NLAYER] = {90.4, 94.8, 99.3, 103.7, 108.1, 112.6};
 
  // The outer lengths of the chambers
  // Includes the spacings between the chambers!
  static constexpr float CLENGTH[constants::NLAYER][constants::NSTACK] = {
    {124.0, 124.0, 110.0, 124.0, 124.0},
    {124.0, 124.0, 110.0, 124.0, 124.0},
    {131.0, 131.0, 110.0, 131.0, 131.0},
    {138.0, 138.0, 110.0, 138.0, 138.0},
    {145.0, 145.0, 110.0, 145.0, 145.0},
    {147.0, 147.0, 110.0, 147.0, 147.0}};
 
  PadPlane mPadPlanes[constants::NLAYER * constants::NSTACK];
 
  int mSMStatus = 0x3ffff;
 
  ClassDefNV(GeometryBase, 1);
};
} // end namespace trd
} // end namespace o2
#endif