doxygen/0.4.0/DetStructs_8h_source.html

#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;

  // FIT-PSD distances

  double topFitTopPsdDistance;

  double sideFitSidePsdDistance;

  // PSD-SCD distances

  double topPsdTopScdDistance;

  double sidePsdSideScdDistance;


  GeneralOptions() {


    // Detectors

    chargeID = "none";

    tracker = "fit";

    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;

    // FIT-PSD distances

    topFitTopPsdDistance = 61. * CLHEP::mm; // Value for v1 tiles PSD

    sideFitSidePsdDistance = 77.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;

  int sphericalMaxCubesZ, sphericalMaxCubesX, sphericalMaxCubesY;

  float sphericalRadius;

  std::vector<double> sphericalCubesXCoo, sphericalCubesYCoo, sphericalCubesZCoo; // Set by SphericalCaloBuilder::Build


  // All the PDs parameters are relative to the active (i.e. depleted) Si volume

  float lpdSizeL, spdSizeL;

  float lpdSizeT, spdSizeT;

  float lpdThickness, spdThickness;

  float pdDistance;

  float pdShift;

  bool withSupports; // If false then the CALO supports will not be placed

  bool drawSupports; // If false then the CALO supports will not be drawn in the G4 OpenGL visualization


  CaloOptions() {

    monolithicCalo = false;

    densityHasBeenSet = false;

    crystalDensity = 7.4 * CLHEP::g / CLHEP::cm3; // Default density for calo v1 geometry (the defaults for calo v2 and

                                                  // spherical{_v2,_v3} are 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";

    sphericalMaxCubesZ = 21;

    sphericalMaxCubesX = 23;

    sphericalMaxCubesY = 23;

    sphericalRadius = 12.285;


    lpdSizeL = lpdSizeT = 5. * CLHEP::mm;

    spdSizeL = spdSizeT = 1.265 * CLHEP::mm;

    lpdThickness = 130. * CLHEP::um;

    spdThickness = 40. * CLHEP::um;

    pdDistance = 4.75 * CLHEP::mm;

    pdShift = 1.0 * CLHEP::um;


    withSupports = false;

    drawSupports = true;

  }

};


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;

  // Common settings

  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;

    double baseAngle;

  };


  struct TilesOptionsTop : TilesOptionsBase {

    int nTilesAlongXEven, nTilesAlongYEven, nTilesAlongXOdd, nTilesAlongYOdd;

    double tileLongSideSize, tileShortSideSize;

    double tileGapAlongXEven, tileGapAlongYEven, tileGapAlongXOdd, tileGapAlongYOdd;

    double staggeringX, staggeringY;

  } topTilesOptions;


  struct TilesOptionsSide : TilesOptionsBase {

    int nTilesAlongHEven, nTilesAlongVEven, nTilesAlongHOdd, nTilesAlongVOdd;

    double tileLongSideSize, tileShortSideSize;

    double tileGapAlongHEven, tileGapAlongVEven, tileGapAlongHOdd, tileGapAlongVOdd;

    double staggeringH, staggeringV;

  } sideTilesOptions;


  PSDOptions() {

    // Default values

    version = 1;

    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.nTilesAlongXEven = topTilesOptions.nTilesAlongYEven = topTilesOptions.nTilesAlongXOdd =

        topTilesOptions.nTilesAlongYOdd = 180;

    topTilesOptions.tileLongSideSize = topTilesOptions.tileShortSideSize = 10. * CLHEP::mm;

    topTilesOptions.tileGapAlongXEven = topTilesOptions.tileGapAlongYEven = topTilesOptions.tileGapAlongXOdd =

        topTilesOptions.tileGapAlongYOdd = 0. * CLHEP::mm;

    topTilesOptions.staggeringX = topTilesOptions.staggeringY = 0.; // Will be filled by TilesPsdBuilder

    topTilesOptions.baseAngle = 90 * CLHEP::degree;


    // Side tiles

    sideTilesOptions.nLayers = 1;

    sideTilesOptions.layersGap = 0;

    sideTilesOptions.hasCF = false;

    sideTilesOptions.cfThickness = sideTilesOptions.cfGap = 0.;

    sideTilesOptions.nTilesAlongHEven = sideTilesOptions.nTilesAlongHOdd = 160;

    sideTilesOptions.nTilesAlongVEven = sideTilesOptions.nTilesAlongVOdd = 100;

    sideTilesOptions.tileLongSideSize = sideTilesOptions.tileShortSideSize = 10. * CLHEP::mm;

    sideTilesOptions.tileGapAlongHEven = sideTilesOptions.tileGapAlongVEven = sideTilesOptions.tileGapAlongHOdd =

        sideTilesOptions.tileGapAlongVOdd = 0. * CLHEP::mm;

    sideTilesOptions.staggeringH = sideTilesOptions.staggeringV = 0.; // Will be filled by TilesPsdBuilder

    sideTilesOptions.baseAngle = 90 * CLHEP::degree;

  }


  void SetNTopTilesAlongLongSide(int nTiles) {

    topTilesOptions.nTilesAlongXEven = topTilesOptions.nTilesAlongYOdd = nTiles;

  }

  void SetNTopTilesAlongShortSide(int nTiles) {

    topTilesOptions.nTilesAlongYEven = topTilesOptions.nTilesAlongXOdd = nTiles;

  }

  void SetTopTilesGapAlongLongSide(double gap) {

    topTilesOptions.tileGapAlongXEven = topTilesOptions.tileGapAlongYOdd = gap;

  }

  void SetTopTilesGapAlongShortSide(double gap) {

    topTilesOptions.tileGapAlongYEven = topTilesOptions.tileGapAlongXOdd = gap;

  }

  void SetNSideTilesAlongLongSide(int nTiles) {

    sideTilesOptions.nTilesAlongHEven = sideTilesOptions.nTilesAlongVOdd = nTiles;

  }

  void SetNSideTilesAlongShortSide(int nTiles) {

    sideTilesOptions.nTilesAlongVEven = sideTilesOptions.nTilesAlongHOdd = nTiles;

  }

  void SetSideTilesGapAlongLongSide(double gap) {

    sideTilesOptions.tileGapAlongHEven = sideTilesOptions.tileGapAlongVOdd = gap;

  }

  void SetSideTilesGapAlongShortSide(double gap) {

    sideTilesOptions.tileGapAlongVEven = sideTilesOptions.tileGapAlongHOdd = gap;

  }

  void SetV2() {

    version = 2;


    // Top tiles

    topTilesOptions.nLayers = 1;

    topTilesOptions.layersGap = 4. * CLHEP::mm;

    topTilesOptions.hasCF = true;

    topTilesOptions.nTilesAlongXEven = topTilesOptions.nTilesAlongYEven = topTilesOptions.nTilesAlongXOdd =

        topTilesOptions.nTilesAlongYOdd = 20;

    topTilesOptions.tileLongSideSize = topTilesOptions.tileShortSideSize = 10. * CLHEP::cm;

    topTilesOptions.tileGapAlongXEven = topTilesOptions.tileGapAlongYEven = topTilesOptions.tileGapAlongXOdd =

        topTilesOptions.tileGapAlongYOdd = 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.nTilesAlongHEven = sideTilesOptions.nTilesAlongHOdd = 16;

    sideTilesOptions.nTilesAlongVEven = sideTilesOptions.nTilesAlongVOdd = 11;

    sideTilesOptions.tileLongSideSize = sideTilesOptions.tileShortSideSize = 10. * CLHEP::cm;

    sideTilesOptions.tileGapAlongHEven = sideTilesOptions.tileGapAlongVEven = sideTilesOptions.tileGapAlongHOdd =

        sideTilesOptions.tileGapAlongVOdd = 0. * CLHEP::mm;

    sideTilesOptions.staggeringH = sideTilesOptions.staggeringV = 0.; // Will be filled by TilesPsdBuilder

    sideTilesOptions.cfThickness = 2. * CLHEP::mm;

    sideTilesOptions.cfGap = 16. * CLHEP::mm;

  }


  void SetV3() {

    version = 3;


    // Top tiles

    topTilesOptions.nLayers = 2;

    topTilesOptions.layersGap = 10. * CLHEP::mm;

    topTilesOptions.hasCF = true;

    SetNTopTilesAlongLongSide(6);

    SetNTopTilesAlongShortSide(36);

    topTilesOptions.tileLongSideSize = 30. * CLHEP::cm;

    topTilesOptions.tileShortSideSize = 5. * CLHEP::cm;

    topTilesOptions.tileGapAlongXEven = topTilesOptions.tileGapAlongYEven = topTilesOptions.tileGapAlongXOdd =

        topTilesOptions.tileGapAlongYOdd = 1.0 * CLHEP::mm;

    topTilesOptions.staggeringX = topTilesOptions.staggeringY = 0.;

    psdTopThickness = 5. * CLHEP::mm;

    topTilesOptions.baseAngle = 45. * CLHEP::degree;

    topTilesOptions.cfThickness = 2. * CLHEP::mm;

    topTilesOptions.cfGap = 11. * CLHEP::mm;


    // Side tiles

    sideTilesOptions.nLayers = 2;

    sideTilesOptions.layersGap = 10 * CLHEP::mm;

    sideTilesOptions.hasCF = true;

    sideTilesOptions.nTilesAlongHEven = 5;

    sideTilesOptions.nTilesAlongVEven = 18;

    sideTilesOptions.nTilesAlongHOdd = 32;

    sideTilesOptions.nTilesAlongVOdd = 3;

    sideTilesOptions.tileLongSideSize = 30. * CLHEP::cm;

    sideTilesOptions.tileShortSideSize = 5. * CLHEP::cm;

    sideTilesOptions.tileGapAlongHEven = sideTilesOptions.tileGapAlongVEven = sideTilesOptions.tileGapAlongHOdd =

        sideTilesOptions.tileGapAlongVOdd = 1. * CLHEP::mm;

    topTilesOptions.staggeringX = topTilesOptions.staggeringY = 0.;

    psdSideThickness = 5. * CLHEP::mm;

    sideTilesOptions.baseAngle = 45. * CLHEP::degree;

    sideTilesOptions.cfThickness = 2. * CLHEP::mm;

    sideTilesOptions.cfGap = 11. * CLHEP::mm;

  }

};


struct FITOptions {

  int version = 1;

  double fitMatThickness;

  unsigned fitSideLayers;

  unsigned fitSideWLayers;

  double fitWThickness;

  double fitMatCoreThickness;

  double fitCfrpThickness;

  double fitHcombThickness; // this is valid for layers without W, if W is present the thickness of the Hcomb is =

                            // fitHcombThickness - fitWThickness

  std::string fitMatMaterial;

  std::string fitMatCoreMaterial;

  std::string fitHcombMaterial;

  std::string fitCfrpMaterial;

  double fitTrayGap; // distance between tray centers (in x or y)

  double sidePlaneSizeHLayEven, sidePlaneSizeHLayOdd;

  double sidePlaneSizeVLayEven, sidePlaneSizeVLayOdd;

  unsigned fitTopLayers;

  unsigned fitTopWLayers;

  double topPlaneSizeXLayEven,

      topPlaneSizeXLayOdd; // X dimension of the top FIT layers for even (0,2,..) and odd (1,3,...) layers

  double topPlaneSizeYLayEven,

      topPlaneSizeYLayOdd; // Y dimension of the top FIT layers for even (0,2,..) and odd (1,3,...) layers

  std::vector<bool> fitlistOfTopWDoubleLayers;

  std::vector<bool> fitlistOfSideWDoubleLayers;


  double topXPos;

  double topYPos;

  double xSideVPos;

  double ySideVPos;

  double xSideHPos;

  double ySideHPos;


  FITOptions() {

    fitMatThickness = 1.580000 * CLHEP::mm; //  (6-1) * 0.21 + 0.25 + 2* 0.14 - see Junjing's code

    fitSideLayers = 9;

    fitSideWLayers = 0;

    fitWThickness = 2 * CLHEP::mm;         //  (6-1) * 0.21 + 0.25 - see Junjing's code

    fitMatCoreThickness = 1.3 * CLHEP::mm; //  (6-1) * 0.21 + 0.25 - see Junjing's code

    fitCfrpThickness = 0.6 * CLHEP::mm;

    fitHcombThickness = 20 * CLHEP::mm;

    fitTrayGap = 0.64 * CLHEP::mm; // Distance between faces of neihgboring trays

    fitMatMaterial = "Epoxy";

    fitMatCoreMaterial = "G4_POLYSTYRENE";

    fitHcombMaterial = "Honeycomb";

    fitCfrpMaterial = "CarbonFiber_M55J";

    sidePlaneSizeHLayEven = 1060 * CLHEP::mm; // for now let's make things easy. = 10*106mm mats

    sidePlaneSizeHLayOdd = 1060 * CLHEP::mm;

    sidePlaneSizeVLayEven = 742 * CLHEP::mm; // for now let's make things easy. = 7*106mm mats

    sidePlaneSizeVLayOdd = 742 * CLHEP::mm;

    fitTopLayers = 5;

    fitTopWLayers = 0;

    // XY dimension of the top FIT tray

    topPlaneSizeXLayEven = 1166 * CLHEP::mm; // for now let's make things easy. = 11*106mm mats

    topPlaneSizeXLayOdd = 1166 * CLHEP::mm;

    topPlaneSizeYLayEven = 1166 * CLHEP::mm;

    topPlaneSizeYLayOdd = 1166 * CLHEP::mm;

    topXPos = 0.;

    topYPos = 0.;

    xSideVPos = -261.9 * CLHEP::mm;

    ySideVPos = -261.9 * CLHEP::mm;

    xSideHPos = -64.2 * CLHEP::mm;

    ySideHPos = -64.2 * CLHEP::mm;

  }


  void SetTopPlaneSize(double size) {

    topPlaneSizeXLayEven = topPlaneSizeXLayOdd = topPlaneSizeYLayEven = topPlaneSizeYLayOdd = size;

  }

  void SetSidePlaneSizeH(double size) { sidePlaneSizeHLayEven = sidePlaneSizeHLayOdd = size; }

  void SetSidePlaneSizeV(double size) { sidePlaneSizeVLayEven = sidePlaneSizeVLayOdd = size; }


  void SetV2() {

    fitTopLayers = fitSideLayers = 7;


    topPlaneSizeXLayEven = 1060. * CLHEP::mm;

    topPlaneSizeYLayEven = 979.8 * CLHEP::mm; // 10x97.8mm mats + small spacings between mats

    topPlaneSizeYLayOdd = 1060. * CLHEP::mm;

    topPlaneSizeXLayOdd = 979.8 * CLHEP::mm; // 10x97.8mm mats + small spacings between mats


    sidePlaneSizeVLayEven = 672. * CLHEP::mm;

    sidePlaneSizeHLayEven = 980. * CLHEP::mm; // 10x97.8mm mats + small spacings between mats

    sidePlaneSizeHLayOdd = 1060 * CLHEP::mm;

    sidePlaneSizeVLayOdd = 587.8 * CLHEP::mm; // 6x97.8mm mats + small spacings between mats

  }

};


struct SCDOptions {

  int version = 1;

  double waferThickness = 0.15 * CLHEP::mm;

  double waferLength = 95 * CLHEP::mm; // Only for v2

  double waferWidth = 95 * CLHEP::mm;  // Only for v2

  double cfhThickness = 3 * CLHEP::mm; // Only for v2

  unsigned int scdTopLayers = 4;

  unsigned int scdSideLayers = 4;

  unsigned int nTopWafers = 20;

  unsigned int nSideWafersH = 18;

  unsigned int nSideWafersV = 9;

  unsigned int topLadderSize = 1;   // Settable only for v2

  unsigned int sideLadderSizeH = 1; // Settable only for v2

  unsigned int sideLadderSizeV = 1; // Settable only for v2

  bool sideLaddersAllV = false;     // Only for v2

  double topStaggeringX = 0.;       // Only for v2

  double topStaggeringY = 0.;       // Only for v2

  double sideStaggeringH = 0.;      // Only for v2

  double sideStaggeringV = 0.;      // Only for v2

  double topXPos = 0.;

  double topYPos = 0.;

  double xSideVPos = std::numeric_limits<decltype(xSideVPos)>::max();

  double ySideVPos = std::numeric_limits<decltype(ySideVPos)>::max();

  double xSideHPos = 2. * CLHEP::cm;

  double ySideHPos = 2. * CLHEP::cm;

  double waferGap = 0.;                  // Settable only for v2

  double ladderGap = 0.1 * CLHEP::mm;    // Settable only for v2

  double topSiCfhGap = 0.5 * CLHEP::mm;  // Settable only for v2

  double sideSiCfhGap = 0.5 * CLHEP::mm; // Settable only for v2

  double topXYGap = 0.5 * CLHEP::mm;

  double sideXYGap = 0.5 * CLHEP::mm;

  double topTrayGap = 2 * CLHEP::mm;

  double sideTrayGap = 2 * CLHEP::mm;

  bool hasFoam = false;

  float foamDensity = 192 * CLHEP::kg / CLHEP::m3;

  std::string foamMaterial = "polyurethane";


  void SetV2() {

    version = 2;

    waferThickness = 0.3 * CLHEP::mm;

    waferLength = 97.5 * CLHEP::mm;

    waferWidth = 97.5 * CLHEP::mm;

    cfhThickness = 50 * CLHEP::mm;

    waferGap = 0.2 * CLHEP::mm;

    ladderGap = 0.2 * CLHEP::mm;

    nTopWafers = 16;

    topLadderSize = 8;

    topSiCfhGap = 0.05 * CLHEP::mm;

    topXYGap = 5.5 * CLHEP::mm;

    topTrayGap = 7.4 * CLHEP::mm;

    nSideWafersH = 16;

    nSideWafersV = 8;

    sideLadderSizeH = 8;

    sideLadderSizeV = 8;

    sideSiCfhGap = 0.05 * CLHEP::mm;

    sideXYGap = 5.5 * CLHEP::mm;

    sideTrayGap = 7.4 * CLHEP::mm;

  }

};


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