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() double getTime0(int layer) { return TIME0[layer]; }
  static constexpr GPUd() double getXtrdBeg() { return XTRDBEG; }
  static constexpr GPUd() double getXtrdEnd() { return XTRDEND; }
  static constexpr GPUd() double getChamberWidth(int layer) { return CWIDTH[layer]; }
  static constexpr GPUd() double getChamberLength(int layer, int stack) { return CLENGTH[layer][stack]; }
  static constexpr GPUd() double getAlpha() { return 2.0 * 3.14159265358979324 / constants::NSECTOR; }
  static constexpr GPUd() double cheight() { return CH; }
  static constexpr GPUd() double cheightSV() { return CHSV; }
  static constexpr GPUd() double cspace() { return VSPACE; }
  static constexpr GPUd() double craHght() { return CRAH; }
  static constexpr GPUd() double cdrHght() { return CDRH; }
  static constexpr GPUd() double camHght() { return CAMH; }
  static constexpr GPUd() double croHght() { return CROH; }
  static constexpr GPUd() double csvHght() { return CSVH; }
  static constexpr GPUd() double croWid() { return CROW; }
  static constexpr GPUd() double anodePos() { return ANODEPOS; }
  static constexpr GPUd() double myThick() { return RMYTHICK; }
  static constexpr GPUd() double drThick() { return DRTHICK; }
  static constexpr GPUd() double amThick() { return AMTHICK; }
  static constexpr GPUd() double drZpos() { return DRZPOS; }
  static constexpr GPUd() double rpadW() { return RPADW; }
  static constexpr GPUd() double cpadW() { return CPADW; }
  static constexpr GPUd() double 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 GPUglobalconstexpr() double TLENGTH = 751.0; 
 
  // Parameter of the super module mother volumes
  static GPUglobalconstexpr() double SHEIGHT = 77.9;    
  static GPUglobalconstexpr() double SWIDTH1 = 94.881;  
  static GPUglobalconstexpr() double SWIDTH2 = 122.353; 
  static GPUglobalconstexpr() double SLENGTH = 702.0;   
 
  // Length of the additional space in front of the supermodule used for services
  static GPUglobalconstexpr() double FLENGTH = (TLENGTH - SLENGTH) / 2.0;
 
  static GPUglobalconstexpr() double SMPLTT = 0.2; 
 
  static GPUglobalconstexpr() double VSPACE = 1.784; 
  static GPUglobalconstexpr() double HSPACE = 2.0;   
  static GPUglobalconstexpr() double VROCSM = 1.2;   
 
  static GPUglobalconstexpr() double CRAH = 4.8;                     
  static GPUglobalconstexpr() double CDRH = 3.0;                     
  static GPUglobalconstexpr() double CAMH = 0.7;                     
  static GPUglobalconstexpr() double CROH = 2.316;                   
  static GPUglobalconstexpr() double CROW = 0.9;                     
  static GPUglobalconstexpr() double CSVH = VSPACE - 0.742;          
  static GPUglobalconstexpr() double CH = CRAH + CDRH + CAMH + CROH; 
  static GPUglobalconstexpr() double CHSV = CH + CSVH;               
 
  // Distance of anode wire plane relative to middle of alignable volume
  static GPUglobalconstexpr() double ANODEPOS = CRAH + CDRH + CAMH / 2.0 - CHSV / 2.0;
 
  static GPUglobalconstexpr() double CALT = 0.4;    
  static GPUglobalconstexpr() double CCLST = 0.21;  
  static GPUglobalconstexpr() double CCLFT = 1.0;   
  static GPUglobalconstexpr() double CGLT = 0.25;   
  static GPUglobalconstexpr() double CCUTA = 1.0;   
  static GPUglobalconstexpr() double CCUTB = 0.8;   
  static GPUglobalconstexpr() double CAUT = 1.5;    
  static GPUglobalconstexpr() double CALW = 2.5;    
  static GPUglobalconstexpr() double CALH = 0.4;    
  static GPUglobalconstexpr() double CALWMOD = 0.4; 
  static GPUglobalconstexpr() double CALHMOD = 2.5; 
  static GPUglobalconstexpr() double CWSW = 1.2;    
  static GPUglobalconstexpr() double CWSH = 0.3;    
 
  static GPUglobalconstexpr() double CPADW = 0.0; 
  static GPUglobalconstexpr() double RPADW = 1.0; 
 
  //
  // Thickness of the the material layers
  //
  static GPUglobalconstexpr() double DRTHICK = CDRH;              
  static GPUglobalconstexpr() double AMTHICK = CAMH;              
  static GPUglobalconstexpr() double XETHICK = DRTHICK + AMTHICK; 
  static GPUglobalconstexpr() double WRTHICK = 0.00011;           
 
  static GPUglobalconstexpr() double RMYTHICK = 0.0015;                                        
  static GPUglobalconstexpr() double RCBTHICK = 0.0055;                                        
  static GPUglobalconstexpr() double RGLTHICK = 0.0065;                                        
  static GPUglobalconstexpr() double RRHTHICK = 0.8;                                           
  static GPUglobalconstexpr() double RFBTHICK = CRAH - 2.0 * (RMYTHICK + RCBTHICK + RRHTHICK); 
 
  static GPUglobalconstexpr() double PPDTHICK = 0.0025;                                                                                  
  static GPUglobalconstexpr() double PPPTHICK = 0.0356;                                                                                  
  static GPUglobalconstexpr() double PGLTHICK = 0.1428;                                                                                  
  static GPUglobalconstexpr() double PCBTHICK = 0.019;                                                                                   
  static GPUglobalconstexpr() double PPCTHICK = 0.0486;                                                                                  
  static GPUglobalconstexpr() double PRBTHICK = 0.0057;                                                                                  
  static GPUglobalconstexpr() double PELTHICK = 0.0029;                                                                                  
  static GPUglobalconstexpr() double PHCTHICK = CROH - PPDTHICK - PPPTHICK - PGLTHICK - PCBTHICK * 2.0 - PPCTHICK - PRBTHICK - PELTHICK; 
 
  //
  // Position of the material layers
  //
  static GPUglobalconstexpr() double DRZPOS = 2.4;                     
  static GPUglobalconstexpr() double AMZPOS = 0.0;                     
  static GPUglobalconstexpr() double WRZPOSA = 0.0;                    
  static GPUglobalconstexpr() double WRZPOSB = -AMTHICK / 2.0 + 0.001; 
  static GPUglobalconstexpr() double CALZPOS = 0.3;                    
 
  static GPUglobalconstexpr() int MCMMAX = 16;   
  static GPUglobalconstexpr() int MCMROW = 4;    
  static GPUglobalconstexpr() int ROBMAXC0 = 6;  
  static GPUglobalconstexpr() int ROBMAXC1 = 8;  
  static GPUglobalconstexpr() int ADCMAX = 21;   
  static GPUglobalconstexpr() int TBMAX = 60;    
  static GPUglobalconstexpr() int PADMAX = 18;   
  static GPUglobalconstexpr() int COLMAX = 144;  
  static GPUglobalconstexpr() int ROWMAXC0 = 12; 
  static GPUglobalconstexpr() int ROWMAXC1 = 16; 
 
  static GPUglobalconstexpr() double TIME0BASE = 300.65; 
  // Time-position of pad 0
  static GPUglobalconstexpr() double 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 GPUglobalconstexpr() double XTRDBEG = 288.43; 
  static GPUglobalconstexpr() double XTRDEND = 366.33; 
 
  // The outer width of the chambers
  static GPUglobalconstexpr() double 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 GPUglobalconstexpr() double 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