#include <splitcal.h>

Inheritance diagram for splitcal:

[legend]

Collaboration diagram for splitcal:

[legend]

Public Member Functions
	splitcal (const char *Name, Bool_t Active)

	splitcal ()

Bool_t	ProcessHits (FairVolume *v=0) override

void	SetZStart (Double_t ZStart)

void	SetEmpty (Double_t Empty, Double_t BigGap, Double_t ActiveECAL_gas_gap, Double_t first_precision_layer, Double_t second_precision_layer, Double_t third_precision_layer, Double_t num_precision_layers)

void	SetThickness (Double_t ActiveECALThickness, Double_t ActiveHCALThickness, Double_t FilterECALThickness, Double_t FilterECALThickness_first, Double_t FilterHCALThickness, Double_t ActiveECAL_gas_Thickness)

void	SetMaterial (Double_t ActiveECALMaterial, Double_t ActiveHCALMaterial, Double_t FilterECALMaterial, Double_t FilterHCALMaterial)

void	SetNSamplings (Int_t nECALSamplings, Int_t nHCALSamplings, Double_t ActiveHCAL)

void	SetNModules (Int_t nModulesInX, Int_t nModulesInY)

void	SetNStrips (Int_t nStrips)

void	SetStripSize (Double_t stripHalfWidth, Double_t stripHalfLength)

void	SetXMax (Double_t xMax)

void	SetYMax (Double_t yMax)

void	ConstructGeometry () override

Public Member Functions inherited from SHiP::Detector< splitcalPoint >
	Detector ()=default

	Detector (const char *Name, Bool_t Active, Int_t detID)

	Detector (const char *Name, Bool_t Active)

	~Detector () override=default

splitcalPoint *	AddHit (Args &&... args)

void	ConstructGeometry () override=0

void	Initialize () override

void	Reset () override

void	EndOfEvent () override

void	Register () override

TClonesArray *	GetCollection (Int_t iColl) const override

void	UpdatePointTrackIndices (const std::map< Int_t, Int_t > &indexMap) override
	Update track indices in point collection after track filtering.

void	SetSpecialPhysicsCuts () override

void	FinishPrimary () override

void	FinishRun () override

void	BeginPrimary () override

void	PostTrack () override

void	PreTrack () override

void	BeginEvent () override

void	CopyClones (TClonesArray cl1, TClonesArray cl2, Int_t offset) override

Public Member Functions inherited from ISTLPointContainer
virtual void	UpdatePointTrackIndices (const std::map< Int_t, Int_t > &indexMap)=0
	Update track indices in point collection after track filtering.

virtual	~ISTLPointContainer ()=default

Private Member Functions
	splitcal (const splitcal &)=delete

splitcal &	operator= (const splitcal &)=delete

Private Attributes
Double_t	fActiveECALThickness

Double_t	fActiveHCALThickness

Double_t	fFilterECALThickness

Double_t	xfFilterECALThickness

Double_t	fFilterECALThickness_first

Double_t	fFilterHCALThickness

Double_t	fActiveECALMaterial

Double_t	fActiveHCALMaterial

Double_t	fFilterECALMaterial

Double_t	fFilterHCALMaterial

Double_t	fActiveECAL_gas_gap

Double_t	fActiveECAL_gas_Thickness

Int_t	fnECALSamplings

Int_t	fnHCALSamplings

Double_t	fActiveHCAL

Double_t	fZStart

Double_t	fEmpty

Double_t	fBigGap

Double_t	fXMax

Double_t	fYMax

Double_t	ffirst_precision_layer

Double_t	fsecond_precision_layer

Double_t	fthird_precision_layer

Double_t	fnum_precision_layers

Int_t	fNModulesInX

Int_t	fNModulesInY

Int_t	fNStripsPerModule

Double_t	fStripHalfWidth

Double_t	fStripHalfLength

Additional Inherited Members
Protected Attributes inherited from SHiP::Detector< splitcalPoint >
Int_t	fEventID

Int_t	fTrackID
	event index

Int_t	fVolumeID
	track index

TLorentzVector	fPos
	volume id

TLorentzVector	fMom
	position at entrance

Double_t	fTime
	momentum at entrance

Double_t	fLength
	time

Double_t	fELoss
	length

std::vector< splitcalPoint > *	fDetPoints
	energy loss

TGeoVolume *	fDetector

Detailed Description

Definition at line 19 of file splitcal.h.

Constructor & Destructor Documentation

◆ splitcal() [1/3]

splitcal::splitcal	(	const char *	Name,
		Bool_t	Active
	)

Name : Detector Name Active: kTRUE for active detectors (ProcessHits() will be called) kFALSE for inactive detectors

Definition at line 41 of file splitcal.cxx.

42 : Detector(name, active, kSplitCal) {}

kSplitCal

@ kSplitCal

Definition: ShipDetectorList.h:29

SHiP::Detector< splitcalPoint >::Detector

Detector()=default

◆ splitcal() [2/3]

splitcal::splitcal ( )

default constructor

Definition at line 39 of file splitcal.cxx.

39: Detector("splitcal", kTRUE, kSplitCal) {}

◆ splitcal() [3/3]

splitcal::splitcal ( const splitcal & )

privatedelete

container for data points

Member Function Documentation

◆ ConstructGeometry()

void splitcal::ConstructGeometry ( )

overridevirtual

Create the detector geometry

If you are using the standard ASCII input for the geometry just copy this and use it for your detector, otherwise you can implement here you own way of constructing the geometry.

Implements SHiP::Detector< splitcalPoint >.

Definition at line 145 of file splitcal.cxx.

                                 {
  TGeoVolume* top = gGeoManager->GetTopVolume();
  TGeoVolume* tSplitCal = new TGeoVolumeAssembly("SplitCalDetector");
 
  ShipGeo::InitMedium("iron");
  ShipGeo::InitMedium("lead");
  ShipGeo::InitMedium("Scintillator");
  ShipGeo::InitMedium("argon");
  ShipGeo::InitMedium("GEMmixture");
 
  TGeoMedium* A2 = gGeoManager->GetMedium("iron");
  TGeoMedium* A3 = gGeoManager->GetMedium("lead");
  TGeoMedium* A4 = gGeoManager->GetMedium("GEMmixture");
  TGeoMedium* A1 = gGeoManager->GetMedium("Scintillator");
 
  Double_t zStartSplitCal = fZStart;
 
  TGeoVolume* newECALfilter_first;  // first layer can have different thickeness
  TGeoVolume* newECALfilter;
  TGeoVolume* newECALdet_gas;
  TGeoVolume* stripGivingX;
  TGeoVolume* stripGivingY;
 
  TGeoVolume* newHCALfilter[100];
  TGeoVolume* newHCALdet[100];
  const char* char_labelHCALfilter[100];
  TString labelHCALfilter;
  const char* char_labelHCALdet[100];
  TString labelHCALdet;
 
  Double_t z_splitcal = 0;
 
  // logical volume for the absorbing layers
  // first absorbing layer can have different thinkens from the others
  newECALfilter_first = gGeoManager->MakeBox(
      "ECALfilter_first", A3, fXMax, fYMax, fFilterECALThickness_first / 2);
  newECALfilter_first->SetLineColor(kGray);
  newECALfilter = gGeoManager->MakeBox("ECALfilter", A3, fXMax, fYMax,
                                       fFilterECALThickness / 2);
  newECALfilter->SetLineColor(kGray);
 
  stripGivingX =
      gGeoManager->MakeBox("stripGivingX", A1, fStripHalfWidth,
                           fStripHalfLength, fActiveECALThickness / 2);
  stripGivingX->SetVisibility(kTRUE);
  AddSensitiveVolume(stripGivingX);
  stripGivingX->SetLineColor(kGreen);
 
  stripGivingY =
      gGeoManager->MakeBox("stripGivingY", A1, fStripHalfLength,
                           fStripHalfWidth, fActiveECALThickness / 2);
  stripGivingY->SetVisibility(kTRUE);
  AddSensitiveVolume(stripGivingY);
  stripGivingY->SetLineColor(kGreen);
 
  // logical volume for the high precision sensitive layers
  newECALdet_gas = gGeoManager->MakeBox("ECALdet_gas", A4, fXMax, fYMax,
                                        fActiveECAL_gas_Thickness / 2);
  AddSensitiveVolume(newECALdet_gas);
  newECALdet_gas->SetLineColor(kRed);
 
  // now position layer volumes in tSplitCal mother volume
  for (Int_t i_nlayECAL = 0; i_nlayECAL < fnECALSamplings; i_nlayECAL++) {
    // position absorber layers
    // thinkness of first layer can be different from others
    if (i_nlayECAL == 0) {
      z_splitcal += fFilterECALThickness_first / 2;
      tSplitCal->AddNode(newECALfilter_first, i_nlayECAL * 1e5,
                         new TGeoTranslation(0, 0, z_splitcal));
      z_splitcal += fFilterECALThickness_first / 2;
    } else {
      z_splitcal += fFilterECALThickness / 2;
      tSplitCal->AddNode(newECALfilter, i_nlayECAL * 1e5,
                         new TGeoTranslation(0, 0, z_splitcal));
      z_splitcal += fFilterECALThickness / 2;
    }
 
    if (i_nlayECAL == 0)
      z_splitcal += fEmpty;  // space after first layer? set to 0 in the
                             // config file? for whar is it for?
    if (i_nlayECAL == 7) z_splitcal += fBigGap;
 
    // position high precision sensitive layers
    if (i_nlayECAL == ffirst_precision_layer ||
        i_nlayECAL == fsecond_precision_layer ||
        i_nlayECAL == fthird_precision_layer) {
      z_splitcal += fActiveECAL_gas_Thickness / 2;
 
      tSplitCal->AddNode(newECALdet_gas, 1e8 + (i_nlayECAL + 1) * 1e5,
                         new TGeoTranslation(0, 0, z_splitcal));
      z_splitcal += fActiveECAL_gas_Thickness / 2;
      if (fnum_precision_layers == 2) {
        z_splitcal += fActiveECAL_gas_gap;
        z_splitcal += fActiveECAL_gas_Thickness / 2;
        tSplitCal->AddNode(newECALdet_gas, 1e8 + (i_nlayECAL + 1) * 1e5,
                           new TGeoTranslation(0, 0, z_splitcal));
        z_splitcal += fActiveECAL_gas_Thickness / 2;
      }
    } else {
      // position sensitive layers
      z_splitcal += fActiveECALThickness / 2;
      if (i_nlayECAL % 2 == 0) {
        // strips giving x information
        for (int mx = 0; mx < fNModulesInX; mx++) {
          for (int my = 0; my < fNModulesInY; my++) {
            for (int j = 0; j < fNStripsPerModule; j++) {
              int index = (i_nlayECAL + 1) * 1e5 + (mx + 1) * 1e4 +
                          (my + 1) * 1e3 + j + 1;
              double xCoordinate =
                  -fXMax + (fNStripsPerModule * mx + j + 0.5) *
                               fStripHalfWidth *
                               2;  // the times 2 is to get the total width
                                   // from the half-width
              double yCoordinate =
                  -fYMax + (my + 0.5) * fStripHalfLength *
                               2;  // the times 2 is to get the total length
                                   // from the half-length
              tSplitCal->AddNode(
                  stripGivingX, index,
                  new TGeoTranslation(xCoordinate, yCoordinate, z_splitcal));
 
            }  // end loop on strips
          }  // end loop on modules in y
        }  // end loop on modules in x
      }  // end layer stripped in X
      else {
        // strips giving y information
        for (int mx = 0; mx < fNModulesInX; mx++) {
          for (int my = 0; my < fNModulesInY; my++) {
            for (int j = 0; j < fNStripsPerModule; j++) {
              int index = (i_nlayECAL + 1) * 1e5 + (mx + 1) * 1e4 +
                          (my + 1) * 1e3 + j + 1;
              double xCoordinate =
                  -fXMax + (mx + 0.5) * fStripHalfLength *
                               2;  // the times 2 is to get the total length
                                   // from the half-length
              double yCoordinate =
                  -fYMax + (fNStripsPerModule * my + j + 0.5) *
                               fStripHalfWidth *
                               2;  // the times 2 is to get the total width
                                   // from the half-width
              tSplitCal->AddNode(
                  stripGivingY, index,
                  new TGeoTranslation(xCoordinate, yCoordinate, z_splitcal));
 
            }  // end loop on strips
          }  // end loop on modules in y
        }  // end loop on modules in x
      }  // end layer stripped in Y
 
      z_splitcal += fActiveECALThickness / 2;
    }  // end loop on sensitive scintillator layers
 
  }  // end loop in ecal layers
 
  for (Int_t i_nlayHCAL = 0; i_nlayHCAL < 1; i_nlayHCAL++) {
    labelHCALfilter = "HCALfilter_";
    labelHCALfilter += i_nlayHCAL;
    char_labelHCALfilter[i_nlayHCAL] = labelHCALfilter;
    labelHCALdet = "HCAL_det";
    labelHCALdet += i_nlayHCAL;
    char_labelHCALdet[i_nlayHCAL] = labelHCALdet;
    newHCALfilter[i_nlayHCAL] =
        gGeoManager->MakeBox(char_labelHCALfilter[i_nlayHCAL], A2, fXMax, fYMax,
                             fFilterHCALThickness / 2);
    if (fActiveHCAL) {
      newHCALdet[i_nlayHCAL] =
          gGeoManager->MakeBox(char_labelHCALdet[i_nlayHCAL], A4, fXMax, fYMax,
                               fActiveHCALThickness / 2);
 
      AddSensitiveVolume(newHCALdet[i_nlayHCAL]);
 
      newHCALdet[i_nlayHCAL]->SetLineColor(kRed);
    }
    newHCALfilter[i_nlayHCAL]->SetLineColor(kBlue);
  }
  for (Int_t i_nlayHCAL = 0; i_nlayHCAL < fnHCALSamplings; i_nlayHCAL++) {
    z_splitcal += fFilterHCALThickness / 2;
    tSplitCal->AddNode(newHCALfilter[i_nlayHCAL], 1,
                       new TGeoTranslation(0, 0, z_splitcal));
    z_splitcal += fFilterHCALThickness / 2;
 
    z_splitcal += fActiveHCALThickness / 2;
    if (fActiveHCAL)
      tSplitCal->AddNode(newHCALdet[i_nlayHCAL], 1,
                         new TGeoTranslation(0, 0, z_splitcal));
    z_splitcal += fActiveHCALThickness / 2;
  }
 
  // finish assembly and position
  TGeoShapeAssembly* asmb =
      dynamic_cast<TGeoShapeAssembly*>(tSplitCal->GetShape());
  Double_t totLength = asmb->GetDZ();
  top->AddNode(tSplitCal, 1,
               new TGeoTranslation(0, 0, zStartSplitCal + totLength));
}

◆ operator=()

splitcal & splitcal::operator= ( const splitcal & )

privatedelete

◆ ProcessHits()

Bool_t splitcal::ProcessHits ( FairVolume * v = 0 )

override

this method is called for each step during simulation (see FairMCApplication::Stepping())

This method is called from the MC stepping

Definition at line 44 of file splitcal.cxx.

                                            {
  // Set parameters at entrance of volume. Reset ELoss.
  if (gMC->IsTrackEntering()) {
    fELoss = 0.;
    fTime = gMC->TrackTime() * 1.0e09;
    fLength = gMC->TrackLength();
    gMC->TrackPosition(fPos);
    gMC->TrackMomentum(fMom);
  }
 
  // Sum energy loss for all steps in the active volume
  fELoss += gMC->Edep();
 
  // Create splitcalPoint at exit of active volume
  if (gMC->IsTrackExiting() || gMC->IsTrackStop() ||
      gMC->IsTrackDisappeared()) {
    fEventID = gMC->CurrentEvent();
    fTrackID = gMC->GetStack()->GetCurrentTrackNumber();
    Int_t detID = 0;
    gMC->CurrentVolID(detID);
 
    fVolumeID = detID;
    if (fELoss == 0.) {
      return kFALSE;
    }
    TParticle* p = gMC->GetStack()->GetCurrentTrack();
    Int_t pdgCode = p->GetPdgCode();
    AddHit(fEventID, fTrackID, fVolumeID,
           TVector3(fPos.X(), fPos.Y(), fPos.Z()),
           TVector3(fMom.Px(), fMom.Py(), fMom.Pz()), fTime, fLength, fELoss,
           pdgCode);
 
    // Increment number of splitcal det points in TParticle
    ShipStack* stack = dynamic_cast<ShipStack*>(gMC->GetStack());
    stack->AddPoint(kSplitCal);
  }
 
  return kTRUE;
}

◆ SetEmpty()

void splitcal::SetEmpty	(	Double_t	Empty,
		Double_t	BigGap,
		Double_t	ActiveECAL_gas_gap,
		Double_t	first_precision_layer,
		Double_t	second_precision_layer,
		Double_t	third_precision_layer,
		Double_t	num_precision_layers
	)

Definition at line 86 of file splitcal.cxx.

                                                       {
  fEmpty = Empty;
  fBigGap = BigGap;
  fActiveECAL_gas_gap = ActiveECAL_gas_gap;
  ffirst_precision_layer = first_precision_layer;
  fsecond_precision_layer = second_precision_layer;
  fthird_precision_layer = third_precision_layer;
  fnum_precision_layers = num_precision_layers;
}

◆ SetMaterial()

void splitcal::SetMaterial	(	Double_t	ActiveECALMaterial,
		Double_t	ActiveHCALMaterial,
		Double_t	FilterECALMaterial,
		Double_t	FilterHCALMaterial
	)

Definition at line 114 of file splitcal.cxx.

                                                        {
  fActiveECALMaterial = ActiveECALMaterial;
  fActiveHCALMaterial = ActiveHCALMaterial;
  fFilterECALMaterial = FilterECALMaterial;
  fFilterHCALMaterial = FilterHCALMaterial;
}

◆ SetNModules()

void splitcal::SetNModules	(	Int_t	nModulesInX,
		Int_t	nModulesInY
	)

Definition at line 131 of file splitcal.cxx.

                                                               {
  fNModulesInX = nModulesInX;
  fNModulesInY = nModulesInY;
}

◆ SetNSamplings()

void splitcal::SetNSamplings	(	Int_t	nECALSamplings,
		Int_t	nHCALSamplings,
		Double_t	ActiveHCAL
	)

Definition at line 124 of file splitcal.cxx.

                                                  {
  fnHCALSamplings = nHCALSamplings;
  fnECALSamplings = nECALSamplings;
  fActiveHCAL = ActiveHCAL;
}

◆ SetNStrips()

void splitcal::SetNStrips ( Int_t nStrips )

Definition at line 136 of file splitcal.cxx.

136{ fNStripsPerModule = nStrips; }

◆ SetStripSize()

void splitcal::SetStripSize	(	Double_t	stripHalfWidth,
		Double_t	stripHalfLength
	)

Definition at line 138 of file splitcal.cxx.

                                                                             {
  fStripHalfWidth = stripHalfWidth;
  fStripHalfLength = stripHalfLength;
}

◆ SetThickness()

void splitcal::SetThickness	(	Double_t	ActiveECALThickness,
		Double_t	ActiveHCALThickness,
		Double_t	FilterECALThickness,
		Double_t	FilterECALThickness_first,
		Double_t	FilterHCALThickness,
		Double_t	ActiveECAL_gas_Thickness
	)

Definition at line 101 of file splitcal.cxx.

                                                               {
  fActiveECALThickness = ActiveECALThickness;
  fActiveHCALThickness = ActiveHCALThickness;
  fFilterECALThickness = FilterECALThickness;
  fFilterECALThickness_first = FilterECALThickness_first;
  fFilterHCALThickness = FilterHCALThickness;
  fActiveECAL_gas_Thickness = ActiveECAL_gas_Thickness;
}

◆ SetXMax()

void splitcal::SetXMax ( Double_t xMax )

Definition at line 143 of file splitcal.cxx.

143{ fXMax = xMax; }

◆ SetYMax()

void splitcal::SetYMax ( Double_t yMax )

Definition at line 144 of file splitcal.cxx.

144{ fYMax = yMax; }

◆ SetZStart()

void splitcal::SetZStart ( Double_t ZStart )

Definition at line 85 of file splitcal.cxx.

85{ fZStart = ZStart; }

Member Data Documentation

◆ fActiveECAL_gas_gap

Double_t splitcal::fActiveECAL_gas_gap

private

Definition at line 73 of file splitcal.h.

◆ fActiveECAL_gas_Thickness

Double_t splitcal::fActiveECAL_gas_Thickness

private

Definition at line 73 of file splitcal.h.

◆ fActiveECALMaterial

Double_t splitcal::fActiveECALMaterial

private

Definition at line 71 of file splitcal.h.

◆ fActiveECALThickness

Double_t splitcal::fActiveECALThickness

private

Track information to be stored until the track leaves the active volume.

Definition at line 69 of file splitcal.h.

◆ fActiveHCAL

Double_t splitcal::fActiveHCAL

private

Definition at line 75 of file splitcal.h.

◆ fActiveHCALMaterial

Double_t splitcal::fActiveHCALMaterial

private

Definition at line 71 of file splitcal.h.

◆ fActiveHCALThickness

Double_t splitcal::fActiveHCALThickness

private

Definition at line 69 of file splitcal.h.

◆ fBigGap

Double_t splitcal::fBigGap

private

Definition at line 77 of file splitcal.h.

◆ fEmpty

Double_t splitcal::fEmpty

private

Definition at line 77 of file splitcal.h.

◆ fFilterECALMaterial

Double_t splitcal::fFilterECALMaterial

private

Definition at line 71 of file splitcal.h.

◆ fFilterECALThickness

Double_t splitcal::fFilterECALThickness

private

Definition at line 69 of file splitcal.h.

◆ fFilterECALThickness_first

Double_t splitcal::fFilterECALThickness_first

private

Definition at line 70 of file splitcal.h.

◆ fFilterHCALMaterial

Double_t splitcal::fFilterHCALMaterial

private

Definition at line 72 of file splitcal.h.

◆ fFilterHCALThickness

Double_t splitcal::fFilterHCALThickness

private

Definition at line 70 of file splitcal.h.

◆ ffirst_precision_layer

Double_t splitcal::ffirst_precision_layer

private

Definition at line 80 of file splitcal.h.

◆ fnECALSamplings

Int_t splitcal::fnECALSamplings

private

Definition at line 74 of file splitcal.h.

◆ fnHCALSamplings

Int_t splitcal::fnHCALSamplings

private

Definition at line 74 of file splitcal.h.

◆ fNModulesInX

Int_t splitcal::fNModulesInX

private

Definition at line 82 of file splitcal.h.

◆ fNModulesInY

Int_t splitcal::fNModulesInY

private

Definition at line 82 of file splitcal.h.

◆ fNStripsPerModule

Int_t splitcal::fNStripsPerModule

private

Definition at line 83 of file splitcal.h.

◆ fnum_precision_layers

Double_t splitcal::fnum_precision_layers

private

Definition at line 81 of file splitcal.h.

◆ fsecond_precision_layer

Double_t splitcal::fsecond_precision_layer

private

Definition at line 80 of file splitcal.h.

◆ fStripHalfLength

Double_t splitcal::fStripHalfLength

private

Definition at line 84 of file splitcal.h.

◆ fStripHalfWidth

Double_t splitcal::fStripHalfWidth

private

Definition at line 84 of file splitcal.h.

◆ fthird_precision_layer

Double_t splitcal::fthird_precision_layer

private

Definition at line 81 of file splitcal.h.

◆ fXMax

Double_t splitcal::fXMax

private

Definition at line 78 of file splitcal.h.

◆ fYMax

Double_t splitcal::fYMax

private

Definition at line 79 of file splitcal.h.

◆ fZStart

Double_t splitcal::fZStart

private

Definition at line 76 of file splitcal.h.

◆ xfFilterECALThickness

Double_t splitcal::xfFilterECALThickness

private

Definition at line 70 of file splitcal.h.

The documentation for this class was generated from the following files:

splitcal/splitcal.h
splitcal/splitcal.cxx

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ splitcal() [1/3]

◆ splitcal() [2/3]

◆ splitcal() [3/3]

Member Function Documentation

◆ ConstructGeometry()

◆ operator=()

◆ ProcessHits()

◆ SetEmpty()

◆ SetMaterial()

◆ SetNModules()

◆ SetNSamplings()

◆ SetNStrips()

◆ SetStripSize()

◆ SetThickness()

◆ SetXMax()

◆ SetYMax()

◆ SetZStart()

Member Data Documentation

◆ fActiveECAL_gas_gap

◆ fActiveECAL_gas_Thickness

◆ fActiveECALMaterial

◆ fActiveECALThickness

◆ fActiveHCAL

◆ fActiveHCALMaterial

◆ fActiveHCALThickness

◆ fBigGap

◆ fEmpty

◆ fFilterECALMaterial

◆ fFilterECALThickness

◆ fFilterECALThickness_first

◆ fFilterHCALMaterial

◆ fFilterHCALThickness

◆ ffirst_precision_layer

◆ fnECALSamplings

◆ fnHCALSamplings

◆ fNModulesInX

◆ fNModulesInY

◆ fNStripsPerModule

◆ fnum_precision_layers

◆ fsecond_precision_layer

◆ fStripHalfLength

◆ fStripHalfWidth

◆ fthird_precision_layer

◆ fXMax

◆ fYMax

◆ fZStart

◆ xfFilterECALThickness