CbmTrdGeoFactory.h

Go to the documentation of this file.

/* Copyright (C) 2024 National Institute of Physics and Nuclear Engineering - Horia Hulubei, Bucharest
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Alexandru Bercuci [committer] */
 
#ifndef CBMTRDGEOFACTORY_H_
#define CBMTRDGEOFACTORY_H_
 
#include "CbmTrdDefs.h"  // for trd namespace
 
#include <FairTask.h>
 
#include <TString.h>
 
#include <array>
#include <string>
 
class TGeoMedium;
class TGeoTranslation;
class TGeoVolume;
class TGeoVolumeAssembly;
using namespace std;
using namespace cbm::trd;
namespace cbm::trd::geo
{
  enum class eException
  {
    invalid_type = 0,  
    invalid_id         
  };
 
  struct info_t {
    int address   = -1;  
    int id        = -1;  
    int superId   = -1;  
    int type      = -1;  
    int superType = -1;  
    int rotation  = -1;  
  };
  bool ReadModuleInfo(const char* modTxt, info_t& info);
 
  bool ReadFebInfo(const char* febTxt, info_t& info);
 
  int WriteModuleInfo(info_t* info);
 
  int WriteFebInfo(info_t* info);
 
 
  // chamber generic geometrical definitions
  static double sizeX, sizeY;                                  
  static double activeAreaX, activeAreaY;                      
  static map<const string, const TGeoMedium*> fMaterial = {};  
  const TGeoMedium* GetMaterial(const char* mname);
 
 
  class ChamberBuilder : public FairTask {
   public:
    enum class eGeoPart : int
    {
      kRadiator = 0,
      kWindow,
      kVolume,
      kBackPanel,
      kFEB,
      kNparts
    };
    enum eConfig
    {
      kRadiator = 8  
        ,
      kFEB  
    };
    class Component;
    class Radiator;
    class Window;
    class Volume;
    class BackPanel;
    class FEB;
    ChamberBuilder(int typ = 1);
 
    TGeoVolume* GetModule() const { return fVol; }
    bool HasFEB() const { return TESTBIT(fConfig, eConfig::kFEB); }
    bool HasRadiator() const { return TESTBIT(fConfig, eConfig::kRadiator); }
    virtual InitStatus Init();
    virtual void Exec(Option_t*);
    virtual void Finish() { ; }
 
    void SetFEB(bool feb = true) { feb ? SETBIT(fConfig, eConfig::kFEB) : CLRBIT(fConfig, eConfig::kFEB); }
    void SetRadiator(bool rad = true)
    {
      rad ? SETBIT(fConfig, eConfig::kRadiator) : CLRBIT(fConfig, eConfig::kRadiator);
    }
 
   private:
    ChamberBuilder(const ChamberBuilder&);
    ChamberBuilder operator=(const ChamberBuilder&);
 
    short fConfig                                         = 0;   
    short fChmbTyp                                        = 1;   
    array<Component*, (int) eGeoPart::kNparts> fComponent = {};  
    static const int Nfebs                                = faspFeb[1].nmax;
    const double feb_pos[Nfebs][2] = {{-18, -21.6}, {0, -21.6},  {18, -21.6},  {-18, -10.8}, {0, -10.8},
                                      {18, -10.8},  {-18, 0.0},  {0, 0.0},     {18, 0.0},    {-18, +10.8},
                                      {0, +10.8},   {18, +10.8}, {-18, +21.6}, {0, +21.6},   {18, +21.6}};
    TGeoVolume* fVol               = nullptr;  
    ClassDef(ChamberBuilder, 1)                // Manager of the TRD support structure
  };
 
 
  class ChamberBuilder::Component : public FairTask {
   public:
    friend class ChamberBuilder;
    Component(const char* name) : FairTask(name)
    {
      sizeX       = 0;
      sizeY       = 0;
      activeAreaX = 0;
      activeAreaY = 0;
    }
    virtual InitStatus Init() = 0;
    virtual void Exec(Option_t*) { ; }
    virtual void Finish() { ; }
    virtual double GetCenter() const;
    virtual double GetHeight() const { return fHeight; }
 
    static const char* fgName[(int) eGeoPart::kNparts];
 
   protected:
    TGeoVolume* fVol = nullptr;  
 
   private:
    Component(const Component&);
    //Component operator=(const Component&);
 
    double fHeight = 0;                     
    ClassDef(ChamberBuilder::Component, 1)  // Model for the TRD generic chamber component builder
  };
 
  class ChamberBuilder::Radiator : public ChamberBuilder::Component {
   public:
    Radiator();
    virtual InitStatus Init();
 
   private:
    Radiator(const Radiator&);
    const double radiator_thickness = 30.0;
    ClassDef(ChamberBuilder::Radiator, 1)  // Model for the TRD radiator
  };
 
  class ChamberBuilder::Window : public ChamberBuilder::Component {
   public:
    Window();
    virtual InitStatus Init();
 
   private:
    Window(const Window&);
 
    const double winIn_C_thickness    = 0.012;  
    const double winIn_HC_thickness   = 0.9;    
    const double WIN_FrameX_thickness = 0.5;    
    const double WIN_FrameY_thickness = 0.6;    
    const double WIN_OutX_thickness   = 0.35;   
    const double WIN_OutY_thickness   = 0.30;   
    ClassDef(ChamberBuilder::Window, 1)         // Model for the TRD2D entrance window
  };
 
  class ChamberBuilder::Volume : public ChamberBuilder::Component {
   public:
    Volume();
    virtual InitStatus Init();
 
   private:
    Volume(const Volume&);
 
    const double gas_extra          = 0.6;                 
    const double gas_thickness      = 1.2;                 
    const double ridge_height       = 0.29;                
    const double ledge_thickness    = gas_thickness / 3.;  
    const double cathode_width      = 1.0;                 
    const double anode_width        = 0.65;                
    const double dist_width         = 0.40;                
    const double WIN_OutX_thickness = 0.35;                
    const double WIN_OutY_thickness = 0.30;                
    ClassDef(ChamberBuilder::Volume, 1)                    // Model for the TRD active volume
  };
 
  class ChamberBuilder::BackPanel : public ChamberBuilder::Component {
   public:
    BackPanel();
    virtual InitStatus Init();
 
   private:
    BackPanel(const BackPanel&);
    TGeoTranslation* tr = nullptr;
    TString sexpr       = "";
 
    const double pp_pads_thickness  = 0.0020;  
    const double pp_pcb_thickness   = 0.0230;  
    const double hc_thickness       = 2.30;    
    const double hc_unitx           = 6.0;     
    const double hc_unity           = 2.7;     
    const double hc_holex           = 2.4;     
    const double hc_holey           = 0.8;     
    const double cu_pcb_thickness   = 0.0150;  
    const double cu_thickness       = 0.0020;  
    const double BKP_Frame_width    = 1.;      
    const double BKP_Frame_closure  = 0.25;    
    const double BKP_OutX_thickness = 0.50;    
    const double BKP_OutY_thickness = 0.45;    
    const double BKP_OutY_correct   = 0.15;    
 
    ClassDef(ChamberBuilder::BackPanel, 1)  // Model for the TRD back panel
  };
  class ChamberBuilder::FEB : public ChamberBuilder::Component {
   public:
    FEB();
    virtual InitStatus Init();
 
   private:
    FEB(const FEB&);
    //ChamberBuilder::FEB operator=(const FEB&);
    const double FASP_x    = 1.10;    
    const double FASP_y    = 1.10;    
    const double FASP_z    = 0.10;    
    const double FPGA_x    = 2.20;    
    const double FPGA_y    = 2.20;    
    const double FPGA_z    = 0.18;    
    const double ADC_x     = 0.9;     
    const double ADC_y     = 1.5;     
    const double ADC_z     = 0.1;     
    const double DCDC_x    = 1.5012;  
    const double DCDC_y    = 0.8992;  
    const double DCDC_z    = 0.4319;  
    const double ConnFC_x  = 2.37;    
    const double ConnFC_y  = 0.535;   
    const double ConnFC_z  = 0.266;   
    const double ConnBRG_x = 0.5;     
    const double ConnBRG_y = 4.58;    
    const double ConnBRG_z = 0.658;   
 
    static const int FASPRO_Nly                = 18;    
    static const int FASPRO_Nfasp              = 12;    
    static const int FASPRO_Nadc               = 6;     
    static const int FASPRO_Nfpga              = 3;     
    static const int FASPRO_Ndcdc              = 3;     
    const double FASPRO_zspace                 = 1.0;   
    const double FASPRO_length                 = 17.8;  
    const double FASPRO_width                  = 10.6;  
    const double FASPRO_hole_x                 = 2.2;   
    const double FASPRO_hole_y                 = 0.4;   
    const double FASPRO_ly_cu[FASPRO_Nly][2]   = {      // FASPRO(Cu) layer thickness [um] and covarage [%]
                                                {54, 95}, {34, 10}, {16, 95}, {16, 10}, {16, 95}, {34, 10},
                                                {16, 95}, {16, 10}, {16, 95}, {16, 95}, {16, 10}, {16, 95},
                                                {34, 10}, {16, 95}, {16, 10}, {16, 95}, {34, 10}, {54, 95}};
    const double FASPRO_ly_pcb[FASPRO_Nly - 1] = {// FASPRO(FR4) layer thickness [um]
                                                  100, 133, 100, 127, 100, 133, 100, 127, 100,
                                                  127, 100, 133, 100, 127, 100, 133, 100};
    const double HOLE_pos[FASPRO_Nfasp][2]     = {{-6, -3.55}, {-6, -1.55}, {-6, 1.55}, {-6, 3.55},
                                              {0, -3.55},  {0, -1.55},  {0, 1.55},  {0, 3.55},
                                              {+6, -3.55}, {+6, -1.55}, {+6, 1.55}, {+6, 3.55}};
    const double FASP_pos[FASPRO_Nfasp][2]     = {{-6, -4.5}, {-6, -2.5}, {-6, +2.5}, {-6, +4.5}, {0, -4.5},  {0, -2.5},
                                              {0, +2.5},  {0, +4.5},  {+6, -4.5}, {+6, -2.5}, {+6, +2.5}, {+6, +4.5}};
    const double ADC_pos[FASPRO_Nadc][2]       = {{-4.15, -3.35}, {1.85, -3.35}, {7.85, -3.35},
                                            {-4.15, +3.35}, {1.85, +3.35}, {7.85, +3.35}};
    const double FPGA_pos[FASPRO_Nfpga][2]     = {{-6, 0}, {0, 0}, {+6, 0}};
    const double DCDC_pos[FASPRO_Ndcdc][2]     = {{-3, 0.1}, {3, -1.2}, {2.89, 0.1}};
    const double ConnFC_pos[FASPRO_Nfasp][2]   = {{-6, -4.9}, {-6, -2.9}, {-6, 2.9},  {-6, 4.9},  {0, -4.9}, {0, -2.9},
                                                {0, 2.9},   {0, 4.9},   {+6, -4.9}, {+6, -2.9}, {+6, 2.9}, {+6, 4.9}};
    const double ConnBRG_pos[2][2]             = {{-8.4, 0}, {+8.4, 0}};
 
    ClassDef(ChamberBuilder::FEB, 1)  // Model for the TRD FEB geometry
  };
}  // namespace cbm::trd::geo
#endif  // CBMTRDGEOFACTORY_H_