DetStructs.h

Go to the documentation of this file.

#ifndef DETSTRUCT_H_
#define DETSTRUCT_H_

#include "G4SystemOfUnits.hh"

#include <limits>
#include <string>
#include <vector>

struct GeneralOptions {

  // Detectors
  std::string _chargeID;
  std::string _tracker;
  std::string _calorimeter;
  std::string _antiCoincidence;
  std::string _calibration;
  std::string _shield;
  std::string _spaceStation;

  // CALO-FIT distances
  double _caloTopFitDistance;
  double _caloSideXFitDistance;
  double _caloSideYFitDistance;
  // CALO-STK distances
  double _caloTopStkDistance;
  double _caloSideXStkDistance;
  double _caloSideYStkDistance;
  // FIT-PSD distances
  double _topFitTopPsdDistance;
  double _sideFitSidePsdDistance;
  // STK-PSD distances
  double _topStkTopPsdDistance;
  double _sideStkSidePsdDistance;
  // PSD-SCD distances
  double _topPsdTopScdDistance;
  double _sidePsdSideScdDistance;

  GeneralOptions() {

    // Detectors
    _chargeID = "none";
    _tracker = "stk";
    _calorimeter = "calo";
    _antiCoincidence = "psd";
    _calibration = "none";
    _shield = "none";
    _spaceStation = "none";

    // CALO-FIT distances
    _caloTopFitDistance = 150. * CLHEP::mm;
    _caloSideXFitDistance = 86.3 * CLHEP::mm;
    _caloSideYFitDistance = 115.3 * CLHEP::mm;
    // CALO-STK distances
    _caloTopStkDistance = 50 * CLHEP::mm;
    _caloSideXStkDistance = 50 * CLHEP::mm;
    _caloSideYStkDistance = 50 * CLHEP::mm;
    // FIT-PSD distances
    _topFitTopPsdDistance = 61. * CLHEP::mm; // Value for v1 tiles PSD
    _sideFitSidePsdDistance = 77.5;
    // STK-PSD distances
    _topStkTopPsdDistance = 61. * CLHEP::mm; // Value for v1 tiles PSD
    _sideStkSidePsdDistance = 177.5;
    // PSD-SCD distances
    _topPsdTopScdDistance = 20 * CLHEP::mm;
    _sidePsdSideScdDistance = 20 * CLHEP::mm;
  }
};

struct CaloOptions {
  bool _monolithicCalo;
  float _crystalDensity;
  float _densityHasBeenSet;
  float _crystalSize;
  float _crystalSlotSize;
  float _xGap, _yGap, _zGap;
  float _wellGapX, _wellGapY, _wellGapZ;
  float _xCenter, _yCenter, _zTop;
  std::string _cubeMaskPath;
  std::vector<int> _cubeMask;
  float _fillerDensity;
  std::string _fillerMaterial;

  CaloOptions() {
    _monolithicCalo = false;
    _densityHasBeenSet = false;
    _crystalDensity = 7.4 * CLHEP::g / CLHEP::cm3; // Default density for calo v1 geometry (the default for calo v2 is
                                                   // eventually set in ParametricGeo.cpp).
    _crystalSize = 3. * cm;
    _crystalSlotSize = 3. * cm;
    _xGap = 8 * mm;
    _yGap = 4 * mm;
    _zGap = 4 * mm;
    _wellGapX = 0 * mm;
    _wellGapY = 15 * mm;
    _wellGapZ = 15 * mm;
    _xCenter = 0 * mm;
    _yCenter = 0 * mm;
    _zTop = 0 * mm;
    _cubeMaskPath = "";
    _cubeMask.clear();
    _fillerDensity = 0.;
    _fillerMaterial = "G4_Galactic";
  }
};

struct AcceptanceOptions {
  int _MCCaloAccType;
  double _caloTOPZquote;
  double _caloTOPXwidth;
  double _caloTOPYwidth;
  double _caloShowerLength; // only for MCCaloAcc2
  double _caloBOTTOMZquote;
  double _caloBOTTOMXwidth;
  double _caloBOTTOMYwidth;
  bool _selectTOPcalo;    // only for MCCaloAcc2
  bool _selectBOTTOMcalo; // only for MCCaloAcc2
  bool _selectXNEGcalo;   // only for MCCaloAcc2
  bool _selectXPOScalo;   // only for MCCaloAcc2
  bool _selectYNEGcalo;   // only for MCCaloAcc2
  bool _selectYPOScalo;   // only for MCCaloAcc2

  AcceptanceOptions() {
    _MCCaloAccType = 2;
    _caloTOPXwidth = 85 * CLHEP::cm;
    _caloTOPYwidth = 80 * CLHEP::cm;
    _caloTOPZquote = 3.4 * CLHEP::cm;
    _caloShowerLength = 0 * CLHEP::cm;     // old value: 27 * CLHEP::cm
    _caloBOTTOMXwidth = 85 * CLHEP::cm;    // For _MCCaloAccType=2 must be =_caloTOPXwidth
    _caloBOTTOMYwidth = 80 * CLHEP::cm;    // For _MCCaloAccType=2 must be =_caloTOPYwidth
    _caloBOTTOMZquote = -76.6 * CLHEP::cm; // default for MCCaloType 1
    _selectTOPcalo = true;
    _selectBOTTOMcalo = false;
    _selectXNEGcalo = true;
    _selectXPOScalo = true;
    _selectYNEGcalo = true;
    _selectYPOScalo = true;
  }
};

struct PSDOptions {
  int _version;
  std::string _psdType;
  // Common settings for bars and tiles
  double _psdTopThickness;
  double _psdSideThickness;
  double _topXPos;
  double _topYPos;
  double _xSideVPos;
  double _ySideVPos;
  double _xSideHPos;
  double _ySideHPos;

  struct TilesOptionsBase {
    int _nLayers;
    double _layersGap;
    bool _hasCF;
    double _cfThickness, _cfGap;
  };

  struct TilesOptionsTop : TilesOptionsBase {
    int _nTilesAlongX;
    int _nTilesAlongY;
    double _tileSizeAlongX, _tileSizeAlongY;
    double _tileGapAlongX, _tileGapAlongY;
    double _staggeringX, _staggeringY;
  } _topTilesOptions;

  struct TilesOptionsSide : TilesOptionsBase {
    int _nTilesAlongH;
    int _nTilesAlongV;
    double _tileSizeAlongH, _tileSizeAlongV;
    double _tileGapAlongH, _tileGapAlongV;
    double _staggeringH, _staggeringV;
  } _sideTilesOptions;

  struct BarsOptionsBase {
    int _nLayers;
    double _width;
    double _barsGap, _layersGap, _planesGap;
    bool _hasCF;
    double _cfThickness, _cfGap;
  };

  struct BarsOptionsTop : BarsOptionsBase {
    int _nBarsAlongX; // Number of bars in layers segmented along X
    int _nBarsAlongY; // Number of bars in layers segmented along X
    double _lengthOfBarsAlongX;
    double _lengthOfBarsAlongY;
    double _staggeringX, _staggeringY;
  } _topBarsOptions;

  struct BarsOptionsSide : BarsOptionsBase {
    int _nBarsAlongH; // Number of bars in horizontally-segmented layers
    int _nBarsAlongV; // Number of bars in vertically-segmented layers
    double _lengthOfBarsAlongH;
    double _lengthOfBarsAlongV;
    double _staggeringH, _staggeringV;
  } _sideBarsOptions;

  PSDOptions() {
    // Default values
    _version = 1;
    _psdType = "tiles";
    _psdTopThickness = _psdSideThickness = 10. * CLHEP::mm;
    _topXPos = 0.;
    _topYPos = 0.;
    _xSideVPos = -189.88 * CLHEP::mm; // Value for v1 tiles
    _ySideVPos = -189.88 * CLHEP::mm; // Value for v1 tiles
    _xSideHPos = 0.;                  // Value for v1 tiles
    _ySideHPos = 0.;                  // Value for v1 tiles

    // Top tiles
    _topTilesOptions._nLayers = 1;
    _topTilesOptions._layersGap = 0;
    _topTilesOptions._hasCF = false;
    _topTilesOptions._cfThickness = _topTilesOptions._cfGap = 0.;
    _topTilesOptions._nTilesAlongX = _topTilesOptions._nTilesAlongY = 180;
    _topTilesOptions._tileSizeAlongX = _topTilesOptions._tileSizeAlongY = 10. * CLHEP::mm;
    _topTilesOptions._tileGapAlongX = _topTilesOptions._tileGapAlongY = 0. * CLHEP::mm;
    _topTilesOptions._staggeringX = _topTilesOptions._staggeringY = 0.; // Will be filled by TilesPsdBuilder

    // Side tiles
    _sideTilesOptions._nLayers = 1;
    _sideTilesOptions._layersGap = 0;
    _sideTilesOptions._hasCF = false;
    _sideTilesOptions._cfThickness = _sideTilesOptions._cfGap = 0.;
    _sideTilesOptions._nTilesAlongH = 160;
    _sideTilesOptions._nTilesAlongV = 100;
    _sideTilesOptions._tileSizeAlongH = _sideTilesOptions._tileSizeAlongV = 10. * CLHEP::mm;
    _sideTilesOptions._tileGapAlongH = _sideTilesOptions._tileGapAlongV = 0. * CLHEP::mm;
    _sideTilesOptions._staggeringH = _sideTilesOptions._staggeringV = 0.; // Will be filled by TilesPsdBuilder

    // Top bars
    _topBarsOptions._nBarsAlongX = _topBarsOptions._nBarsAlongY = 180;
    _topBarsOptions._nLayers = 2;
    _topBarsOptions._lengthOfBarsAlongX = _topBarsOptions._lengthOfBarsAlongY = 0.; // Will be filled by BarPsdBuilder
    _topBarsOptions._staggeringX = _topBarsOptions._staggeringY = 0.;               // Will be filled by BarPsdBuilder
    _topBarsOptions._width = 10. * CLHEP::mm;
    _topBarsOptions._barsGap = 0. * CLHEP::mm;
    _topBarsOptions._layersGap = 10. * CLHEP::mm;
    _topBarsOptions._planesGap = 10 * CLHEP::mm;
    _topBarsOptions._hasCF = false;
    _topBarsOptions._cfThickness = 0. * CLHEP::mm;
    _topBarsOptions._cfGap = 0. * CLHEP::mm;

    // Side bars
    _sideBarsOptions._nBarsAlongV = 102;
    _sideBarsOptions._nBarsAlongH = 162;
    _sideBarsOptions._nLayers = 2;
    _sideBarsOptions._width = 10. * CLHEP::mm;
    _sideBarsOptions._lengthOfBarsAlongH = _sideBarsOptions._lengthOfBarsAlongV = 0.; // Will be filled by BarPsdBuilder
    _sideBarsOptions._staggeringH = _sideBarsOptions._staggeringV = 0.;               // Will be filled by BarPsdBuilder
    _sideBarsOptions._barsGap = 0. * CLHEP::mm;
    _sideBarsOptions._layersGap = 10. * CLHEP::mm;
    _sideBarsOptions._planesGap = 10 * CLHEP::mm;
    _sideBarsOptions._hasCF = false;
    _sideBarsOptions._cfThickness = 0. * CLHEP::mm;
    _sideBarsOptions._cfGap = 0. * CLHEP::mm;
  }

  void SetV2() {
    _version = 2;

    // Top tiles
    _topTilesOptions._nLayers = 1;
    _topTilesOptions._layersGap = 4. * CLHEP::mm;
    _topTilesOptions._hasCF = true;
    _topTilesOptions._nTilesAlongX = _topTilesOptions._nTilesAlongY = 20;
    _topTilesOptions._tileSizeAlongX = _topTilesOptions._tileSizeAlongY = 10. * CLHEP::cm;
    _topTilesOptions._tileGapAlongX = _topTilesOptions._tileGapAlongY = 0. * CLHEP::mm;
    _topTilesOptions._staggeringX = _topTilesOptions._staggeringY = 0.; // Will be filled by TilesPsdBuilder
    _topTilesOptions._cfThickness = 2. * CLHEP::mm;
    _topTilesOptions._cfGap = 16. * CLHEP::mm;
    // Side tiles
    _sideTilesOptions._nLayers = 1;
    _sideTilesOptions._layersGap = 4 * CLHEP::mm;
    _sideTilesOptions._hasCF = true;
    _sideTilesOptions._nTilesAlongH = 16;
    _sideTilesOptions._nTilesAlongV = 11;
    _sideTilesOptions._tileSizeAlongH = _sideTilesOptions._tileSizeAlongV = 10. * CLHEP::cm;
    _sideTilesOptions._tileGapAlongH = _sideTilesOptions._tileGapAlongV = 0. * CLHEP::mm;
    _sideTilesOptions._staggeringH = _sideTilesOptions._staggeringV = 0.; // Will be filled by TilesPsdBuilder
    _sideTilesOptions._cfThickness = 2. * CLHEP::mm;
    _sideTilesOptions._cfGap = 16. * CLHEP::mm;

    // Top bars
    _topBarsOptions._nBarsAlongX = 45;
    _topBarsOptions._nBarsAlongY = 45;
    _topBarsOptions._nLayers = 4;
    _topBarsOptions._width = 30. * CLHEP::mm;
    _topBarsOptions._barsGap = 14. * CLHEP::mm;
    _topBarsOptions._layersGap = 4. * CLHEP::mm;
    _topBarsOptions._planesGap = 2 * CLHEP::mm;
    _topBarsOptions._hasCF = true;
    _topBarsOptions._cfThickness = 2. * CLHEP::mm;
    _topBarsOptions._cfGap = 16. * CLHEP::mm;
    // Side bars
    _sideBarsOptions._nBarsAlongV = 25;
    _sideBarsOptions._nBarsAlongH = 36;
    _sideBarsOptions._nLayers = 4;
    _sideBarsOptions._width = 30. * CLHEP::mm;
    _sideBarsOptions._barsGap = 14. * CLHEP::mm;
    _sideBarsOptions._layersGap = 4. * CLHEP::mm;
    _sideBarsOptions._planesGap = 2 * CLHEP::mm;
    _sideBarsOptions._hasCF = true;
    _sideBarsOptions._cfThickness = 2. * CLHEP::mm;
    _sideBarsOptions._cfGap = 16. * CLHEP::mm;
  }
};

struct STKOptions {
  unsigned _stkTopLayers;
  unsigned _stkTopWLayers;
  unsigned _stkSideLayers;
  unsigned int _nTopWafers;
  unsigned int _nSideWafersH;
  unsigned int _nSideWafersV;
  double _stkTopAbsThickness;
  std::string _stkTopAbsMaterial;
  double _stkTopStripPitch;
  double _stkSideStripPitch;
  int _stkTopNStripsPerWafer;
  int _stkSideNStripsPerWafer;
  double _topXPos;
  double _topYPos;
  double _xSideVPos;
  double _ySideVPos;
  double _xSideHPos;
  double _ySideHPos;

  STKOptions() {
    _stkTopLayers = 6;
    _stkTopWLayers = 3;
    _stkSideLayers = 6;
    _nTopWafers = 14;
    _nSideWafersH = 12;
    _nSideWafersV = 6;
    _stkTopAbsThickness = 1 * CLHEP::mm;
    _stkTopAbsMaterial = "W";    // Not user-settable
    _stkTopStripPitch = 0.;      // No strips by default
    _stkSideStripPitch = 0.;     // No strips by default
    _stkTopNStripsPerWafer = 0;  // Computed from number of strips, not settable
    _stkSideNStripsPerWafer = 0; // Computed from number of strips, not settable
    _topXPos = 0.;
    _topYPos = 0.;
    _xSideVPos = -260.26 * CLHEP::mm;
    _ySideVPos = -260.26 * CLHEP::mm;
    _xSideHPos = 204.56 * CLHEP::mm;
    _ySideHPos = 175.56 * CLHEP::mm;
  }
};

struct FITOptions {
  double _fitMatThickness;
  unsigned _fitSideLayers;
  unsigned _fitSideWLayers;
  double _fitSideWThickness;
  double _fitSideMatCoreThickness;
  double _fitSideCfprThickness;
  double _fitSideHcombThickness; // this is valid for layers without W, if W is present the thickness of the Hcomb is =
                                 // _fitSideHcombThickness - _fitSideWThickness
  std::string _fitSideMatMaterial;
  std::string _fitSideMatCoreMaterial;
  std::string _fitSideHcombMaterial;
  std::string _fitSideCfprMaterial;
  double _fitSideInterTrayDistance; // distance between tray centers (in x or y)
  double _sidePlaneSizeH;
  double _sidePlaneSizeV;
  unsigned _fitTopLayers;
  unsigned _fitTopWLayers;
  double _topPlaneSize; // XY dimension of the top FIT tray
  std::vector<bool> _fitlistOfTopWDoubleLayers;
  std::vector<bool> _fitlistOfSideWDoubleLayers;

  double _topXPos;
  double _topYPos;
  double _xSideVPos;
  double _ySideVPos;
  double _xSideHPos;
  double _ySideHPos;

  FITOptions() {
    _fitMatThickness = 1.58 * CLHEP::mm; //  (6-1) * 0.21 + 0.25 + 2* 0.14 - see Junjing's code
    _fitSideLayers = 9;
    _fitSideWLayers = 0;
    _fitSideWThickness = 2 * CLHEP::mm;         //  (6-1) * 0.21 + 0.25 - see Junjing's code
    _fitSideMatCoreThickness = 1.3 * CLHEP::mm; //  (6-1) * 0.21 + 0.25 - see Junjing's code
    _fitSideCfprThickness = 0.6 * CLHEP::mm;
    _fitSideHcombThickness = 20 * CLHEP::mm;
    _fitSideInterTrayDistance = 25 * CLHEP::mm; // distance between tray centers (in x or y)
    _fitSideMatMaterial = "Epoxy";
    _fitSideMatCoreMaterial = "G4_POLYSTYRENE";
    _fitSideHcombMaterial = "Honeycomb";
    _fitSideCfprMaterial = "CarbonFiber_M55J";
    _sidePlaneSizeH = 1060 * CLHEP::mm; // for now let's make things easy. = 10*106mm mats
    _sidePlaneSizeV = 742 * CLHEP::mm;  // for now let's make things easy. = 7*106mm mats
    _fitTopLayers = 5;
    _fitTopWLayers = 0;
    // XY dimension of the top FIT tray
    _topPlaneSize = 1166 * CLHEP::mm; // for now let's make things easy. = 11*106mm mats
    _topXPos = 0.;
    _topYPos = 0.;
    _xSideVPos = -261.9 * CLHEP::mm;
    _ySideVPos = -261.9 * CLHEP::mm;
    _xSideHPos = -64.2 * CLHEP::mm;
    _ySideHPos = -64.2 * CLHEP::mm;
  }
};

struct SCDOptions {
  double _scdSiliconThickness;
  unsigned int _scdTopLayers;
  unsigned int _scdSideLayers;
  unsigned int _nTopWafers;
  unsigned int _nSideWafersH;
  unsigned int _nSideWafersV;
  double _topXPos;
  double _topYPos;
  double _xSideVPos;
  double _ySideVPos;
  double _xSideHPos;
  double _ySideHPos;
  double _scdTopXYGap;
  double _scdSideXYGap;
  double _scdTopTrayGap;
  double _scdSideTrayGap;
  double _scdTopStripPitch;
  double _scdSideStripPitch;
  int _scdTopNStripsPerWafer;
  int _scdSideNStripsPerWafer;
  bool _hasFoam;
  float _foamDensity;
  std::string _foamMaterial;
  // double _scdSiProductionCut;

  SCDOptions()
      : _scdSiliconThickness(0.15 * CLHEP::mm), _scdTopLayers(4), _scdSideLayers(4), _nTopWafers(20), _nSideWafersH(18),
        _nSideWafersV(9), _topXPos(0.), _topYPos(0), _xSideVPos(std::numeric_limits<decltype(_xSideVPos)>::max()),
        _ySideVPos(std::numeric_limits<decltype(_ySideVPos)>::max()), _xSideHPos(2. * CLHEP::cm),
        _ySideHPos(2. * CLHEP::cm), _scdTopXYGap(0.5 * CLHEP::mm), _scdSideXYGap(0.5 * CLHEP::mm),
        _scdTopTrayGap(2 * CLHEP::mm), _scdSideTrayGap(2 * CLHEP::mm), _scdTopStripPitch(0.), // No strips by default
        _scdSideStripPitch(0.),                                                               // No strips by default
        _scdTopNStripsPerWafer(0),  // Computed from number of strips, not settable
        _scdSideNStripsPerWafer(0), // Computed from number of strips, not settable
        _hasFoam(false), _foamDensity(192 * CLHEP::kg / CLHEP::m3), _foamMaterial("polyurethane")
  // ,_scdSiProductionCut(0)
  {}
};

struct TRDOptions {
  int _nModulesH, _nModulesV;
  float _posV, _posH, _posT;
  float _gapFromSideDetector;

  TRDOptions() {
    _nModulesH = 3;
    _nModulesV = 3;
    _posV = std::numeric_limits<decltype(_posT)>::max(); // Will be set by geometry datacard or filled by
                                                         // ParametricGeo::Construct
    _posH = 0.;
    _posT = std::numeric_limits<decltype(_posT)>::max(); // Will be filled by ParametricGeo::Construct
    _gapFromSideDetector = 5. * CLHEP::cm;
  }
};

struct ShieldOptions {
  float amThickness;      // Thickness of the anti-meteorite shield
  float amGap;            // Gap between the anti-meteorite shield and the nearest detector element
  std::string amMaterial; // Material of the anti-meteorite shield
  ShieldOptions() : amThickness{1 * CLHEP::mm}, amGap{5 * CLHEP::cm}, amMaterial{"Al"} {}
};

struct CSSOptions {
  // Spin angles for solar panels
  float spSpinAngleM1_1, spSpinAngleM1_2;
  float spSpinAngleM2_1, spSpinAngleM2_2;
  float spSpinAngleMC_1, spSpinAngleMC_2;

  // Revolution angles for solar panels
  float spRevAngleM1, spRevAngleM2;

  // material of the cabin shell
  std::string cabinMaterial;

  void SetSPSpinAngleM1(float angle) { spSpinAngleM1_1 = spSpinAngleM1_2 = angle; }
  void SetSPSpinAngleM2(float angle) { spSpinAngleM2_1 = spSpinAngleM2_2 = angle; }
  void SetSPSpinAngleM1M2(float angle) {
    SetSPSpinAngleM1(angle);
    SetSPSpinAngleM2(angle);
  }
  void SetSPSpinAngleMC(float angle) { spSpinAngleMC_1 = spSpinAngleMC_2 = angle; }
  void SetSPRevAngleM1M2(float angle) { spRevAngleM1 = spRevAngleM2 = angle; }
  void SetCabinMaterial(std::string mat_name) { cabinMaterial = mat_name; }

  CSSOptions()
      : spSpinAngleM1_1(0.), spSpinAngleM1_2(0.), spSpinAngleM2_1(0.), spSpinAngleM2_2(0.), spSpinAngleMC_1(0.),
        spSpinAngleMC_2(0.), spRevAngleM1(0.), spRevAngleM2(0.), cabinMaterial("G4_Al") {}
};
#endif