#include <NuTauMudet.h>

Inheritance diagram for NuTauMudet:

Collaboration diagram for NuTauMudet:

[legend]

Public Member Functions
	NuTauMudet (const char name, const Double_t Zcenter, Bool_t Active, const char Title="NuTauMudet")

	NuTauMudet ()

virtual	~NuTauMudet ()

void	SetDesign (Int_t Design)

void	SetTotDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetFeDimensions (Double_t X, Double_t Y, Double_t Z, Double_t Zthin=0.)

void	SetRpcDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcStripDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcGasDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcElectrodeDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcPETDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetNFeInArm (Int_t N, Int_t Nthin=0)

void	SetNRpcInArm (Int_t N)

void	SetZDimensionArm (Double_t Z)

void	SetGapDownstream (Double_t Gap)

void	SetGapMiddle (Double_t Gap)

void	SetMagneticField (Double_t B)

void	SetReturnYokeDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetSmallerYokeDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetCoilParameters (Double_t CoilH, Double_t CoilW, Int_t N, Double_t CoilG)

void	SetSupportTransverseDimensions (Double_t UpperSupportX, Double_t UpperSupportY, Double_t LowerSupportX, Double_t LowerSupportY, Double_t LateralSupportX, Double_t LateralSupportY, Double_t YSpacing)

void	SetLateralCutSize (Double_t CutHeight, Double_t CutLength)

void	SetPillarDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetUpperCoverDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetLateralCoverDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetCrossDimensions (Double_t X, Double_t Y, Double_t Z, Double_t WidthArm)

void	SetRpcOuterDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcInnerDimensions (Double_t X, Double_t Y, Double_t Z)

void	SetRpcGapDimensions (Double_t X, Double_t Y, Double_t Z)

void	ConstructGeometry ()

virtual void	Initialize ()

virtual Bool_t	ProcessHits (FairVolume *v=0)

virtual void	Register ()

virtual TClonesArray *	GetCollection (Int_t iColl) const

virtual void	Reset ()

ShipRpcPoint *	AddHit (Int_t trackID, Int_t detID, TVector3 pos, TVector3 mom, Double_t time, Double_t length, Double_t eLoss, Int_t pdgCode)

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

virtual void	SetSpecialPhysicsCuts ()

virtual void	EndOfEvent ()

virtual void	FinishPrimary ()

virtual void	FinishRun ()

virtual void	BeginPrimary ()

virtual void	PostTrack ()

virtual void	PreTrack ()

virtual void	BeginEvent ()

void	DecodeVolumeID (Int_t detID, int &nARM, int &nRPC)

Protected Member Functions
	NuTauMudet (const NuTauMudet &)

NuTauMudet &	operator= (const NuTauMudet &)

Protected Attributes
Int_t	fDesign

Double_t	fZcenter

Double_t	fXtot

Double_t	fYtot

Double_t	fZtot

Int_t	fNFe

Int_t	fNFethin

Int_t	fNRpc

Double_t	fXFe

Double_t	fXRpc

Double_t	fYFe

Double_t	fYRpc

Double_t	fZFe

Double_t	fZFethin

Double_t	fZRpc

Double_t	fZArm

Double_t	fGapDown

Double_t	fGapMiddle

Double_t	fField

Double_t	fXRyoke

Double_t	fYRyoke

Double_t	fZRyoke

Double_t	fXRyoke_s

Double_t	fYRyoke_s

Double_t	fZRyoke_s

Double_t	fCoilGap

Double_t	fCoilH

Double_t	fCoilW

Int_t	fNCoil

Double_t	fXStrip

Double_t	fYStrip

Double_t	fZStrip

Double_t	fXPet

Double_t	fYPet

Double_t	fZPet

Double_t	fXEle

Double_t	fYEle

Double_t	fZEle

Double_t	fXGas

Double_t	fYGas

Double_t	fZGas

Double_t	fUpSuppX

Double_t	fUpSuppY

Double_t	fLowSuppX

Double_t	fLowSuppY

Double_t	fLatSuppX

Double_t	fLatSuppY

Double_t	fYSpacing

Double_t	fCutHeight

Double_t	fCutLength

Double_t	fPillarX

Double_t	fPillarY

Double_t	fPillarZ

Double_t	fXCov

Double_t	fYCov

Double_t	fZCov

Double_t	fXLateral

Double_t	fYLateral

Double_t	fZLateral

Double_t	fXCross

Double_t	fYCross

Double_t	fZCross

Double_t	fWidthArm

Double_t	fXRpc_outer

Double_t	fYRpc_outer

Double_t	fZRpc_outer

Double_t	fXRpc_inner

Double_t	fYRpc_inner

Double_t	fZRpc_inner

Double_t	fXRpcGap

Double_t	fYRpcGap

Double_t	fZRpcGap

Private Member Functions
Int_t	InitMedium (const char *name)

Private Attributes
Int_t	fTrackID

Int_t	fPdgCode
	track index

Int_t	fVolumeID
	pdg code

TLorentzVector	fPos
	volume id

TLorentzVector	fMom
	position at entrance

Double32_t	fTime
	momentum at entrance

Double32_t	fLength
	time

Double32_t	fELoss
	length

TClonesArray *	fShipRpcPointCollection
	energy loss

Detailed Description

Definition at line 18 of file NuTauMudet.h.

Constructor & Destructor Documentation

◆ NuTauMudet() [1/3]

NuTauMudet::NuTauMudet	(	const char *	name,
		const Double_t	Zcenter,
		Bool_t	Active,
		const char *	Title = `"NuTauMudet"`
	)

Definition at line 61 of file NuTauMudet.cxx.

  : FairDetector(name, Active, ktauRpc),
    fTrackID(-1),
    fPdgCode(),
    fVolumeID(-1),
    fPos(),
    fMom(),
    fTime(-1.),
    fLength(-1.),
    fELoss(-1),
    fShipRpcPointCollection(new TClonesArray("ShipRpcPoint"))
{
  fZcenter = Zcenter;
}

◆ NuTauMudet() [2/3]

NuTauMudet::NuTauMudet ( )

Definition at line 47 of file NuTauMudet.cxx.

  : FairDetector("NuTauMudet",kTRUE, ktauRpc),
    fTrackID(-1),
    fPdgCode(),
    fVolumeID(-1),
    fPos(),
    fMom(),
    fTime(-1.),
    fLength(-1.),
    fELoss(-1),
    fShipRpcPointCollection(new TClonesArray("ShipRpcPoint"))
{
}

◆ ~NuTauMudet()

NuTauMudet::~NuTauMudet ( )

virtual

Definition at line 251 of file NuTauMudet.cxx.

{
  if (fShipRpcPointCollection) {
    fShipRpcPointCollection->Delete();
    delete fShipRpcPointCollection;
  }
}

◆ NuTauMudet() [3/3]

NuTauMudet::NuTauMudet ( const NuTauMudet & )

protected

Member Function Documentation

◆ AddHit()

ShipRpcPoint * NuTauMudet::AddHit	(	Int_t	trackID,
		Int_t	detID,
		TVector3	pos,
		TVector3	mom,
		Double_t	time,
		Double_t	length,
		Double_t	eLoss,
		Int_t	pdgCode
	)

This method is an example of how to add your own point of type muonPoint to the clones array

Definition at line 864 of file NuTauMudet.cxx.

{
  TClonesArray& clref = *fShipRpcPointCollection;
  Int_t size = clref.GetEntriesFast();
  //cout << "ShipRpctau hit called"<< pos.z()<<endl;
  //    return new(clref[size]) ShipRpcPoint(trackID, detID, pos, mom,time, length, eLoss, pdgCode,NArm, NRpc, NHpt);
  return new(clref[size]) ShipRpcPoint(trackID, detID, pos, mom,time, length, eLoss, pdgCode);
}

◆ BeginEvent()

virtual void NuTauMudet::BeginEvent ( )

inlinevirtual

Definition at line 93 of file NuTauMudet.h.

93{;}

◆ BeginPrimary()

virtual void NuTauMudet::BeginPrimary ( )

inlinevirtual

Definition at line 90 of file NuTauMudet.h.

90{;}

◆ ConstructGeometry()

void NuTauMudet::ConstructGeometry ( )

Definition at line 285 of file NuTauMudet.cxx.

{
  TGeoVolume *top = gGeoManager->GetTopVolume();
  TGeoVolumeAssembly *tTauNuDet = new TGeoVolumeAssembly("tTauNuDet");
  top->AddNode(tTauNuDet, 1, new TGeoTranslation(0, 0, 0));
 
  InitMedium("RPCgas");
  TGeoMedium *RPCmat =gGeoManager->GetMedium("RPCgas");
    
  InitMedium("Bakelite");
  TGeoMedium *bakelite =gGeoManager->GetMedium("Bakelite");  
 
  InitMedium("iron");
  TGeoMedium *Iron =gGeoManager->GetMedium("iron");
 
  InitMedium("steel");
  TGeoMedium *Steel =gGeoManager->GetMedium("steel");
    
  InitMedium("copper");
  TGeoMedium *Cu =gGeoManager->GetMedium("copper");
    
  InitMedium("Concrete");
  TGeoMedium *Conc =gGeoManager->GetMedium("Concrete");
 
  InitMedium("air");
  TGeoMedium *air =gGeoManager->GetMedium("air");
 
  InitMedium("Aluminum"); //new
  TGeoMedium *Al =gGeoManager->GetMedium("Aluminum"); //new
    
  TGeoUniformMagField *retFieldU    = new TGeoUniformMagField(0.,0.,-fField); //magnetic field up return yoke
  TGeoUniformMagField *retFieldL   = new TGeoUniformMagField(0.,0.,fField); //magnetic field low return yoke
    
  Double_t d = 0;
 
  if(fDesign!=3)
    {
      TGeoVolumeAssembly *volMudetBox = new TGeoVolumeAssembly("volNuTauMudet");
      tTauNuDet->AddNode(volMudetBox, 1, new TGeoTranslation(0,10*cm,fZcenter));
  
      TGeoBBox *UpYokeBox = new TGeoBBox("UpYokeBox", fXRyoke/2, fYRyoke/2, fZRyoke/2);
      TGeoVolume *volUpYoke = new TGeoVolume("volUpYoke",UpYokeBox,air);
      volMudetBox->AddNode(volUpYoke,1,new TGeoTranslation(0,fYtot/2 - fYRyoke/2,0));
      volUpYoke->SetField(retFieldU);
    
    
      TGeoBBox *FeYoke = new TGeoBBox("FeYoke",fXtot/2, fYRyoke/2, fZArm/2);
      TGeoVolume *volFeYoke = new TGeoVolume("volFeYoke",FeYoke,Iron);
      volFeYoke->SetLineColor(kGray+1);
  
      TGeoBBox *FeYoke1 = new TGeoBBox("FeYoke1",fXtot/2, fYRyoke_s/2, fZRyoke_s/2);
      TGeoVolume *volFeYoke1 = new TGeoVolume("volFeYoke1",FeYoke1,Iron);
      volFeYoke1->SetLineColor(kGray+1);
    
      TGeoBBox *CoilContainer = new TGeoBBox("CoilContainer",fXtot/2, fCoilH/2, 40*cm);
      TGeoVolume *volCoilContainer = new TGeoVolume("volCoilContainer",CoilContainer,air);
    
      TGeoBBox *Coil = new TGeoBBox("Coil",fXtot/2, fCoilH/2, fCoilW/2);
      TGeoVolume *volCoil = new TGeoVolume("volCoil",Coil,Cu);
      volCoil->SetLineColor(kOrange -5);
      for(int i = 0; i < fNCoil; i++)
    {
      volCoilContainer->AddNode(volCoil, i, new TGeoTranslation(0,0, -40*cm + fCoilW/2 + i*(fCoilGap + fCoilW)));
    }
    
      //vertical coils
      TGeoBBox *CoilV = new TGeoBBox("CoilV",fCoilH/2, fYRyoke/2 , fCoilW/2);
      TGeoVolume *volCoilV = new TGeoVolume("volCoilV",CoilV,Cu);
      volCoilV->SetLineColor(kOrange -5);
      for(int i = 0; i < fNCoil; i++)
    {
      volUpYoke->AddNode(volCoilV, i, new TGeoTranslation(fXRyoke/2 - fCoilH/2,0, -40*cm + fCoilW/2 + i*(fCoilGap + fCoilW)));
    }
      for(int i = 0; i < fNCoil; i++)
    {
      volUpYoke->AddNode(volCoilV, i, new TGeoTranslation(-fXRyoke/2 + fCoilH/2,0, -40*cm + fCoilW/2 + i*(fCoilGap + fCoilW)));
    }
 
      //cout <<"fZArm: " << fZArm<< endl;
    
      volUpYoke->AddNode(volFeYoke,1, new TGeoTranslation(0,0,- (fZArm + fGapMiddle)/2));
      volUpYoke->AddNode(volFeYoke,2, new TGeoTranslation(0,0,(fZArm + fGapMiddle)/2));
      volUpYoke->AddNode(volFeYoke1,1,new TGeoTranslation(0,0,0));
      volUpYoke->AddNode(volCoilContainer,1,new TGeoTranslation(0,fYRyoke/2 - fCoilH/2,0)); //up
      volUpYoke->AddNode(volCoilContainer,2,new TGeoTranslation(0,-fYRyoke/2 + fCoilH/2,0)); //low
    
      TGeoBBox *LowYokeBox = new TGeoBBox("LowYokeBox", fXRyoke/2, fYRyoke/2, fZRyoke/2);
      TGeoVolume *volLowYoke = new TGeoVolume("volLowYoke",LowYokeBox,air);
      volMudetBox->AddNode(volLowYoke,1,new TGeoTranslation(0,-fYtot/2 + fYRyoke/2,0));
      volLowYoke->SetField(retFieldL);
   
      //vertical coils
      for(int i = 0; i < fNCoil; i++)
    {
      volLowYoke->AddNode(volCoilV, i, new TGeoTranslation(fXRyoke/2 - fCoilH/2,0, -40*cm + fCoilW/2 + i*(fCoilGap + fCoilW)));
    }
      for(int i = 0; i < fNCoil; i++)
    {
      volLowYoke->AddNode(volCoilV, i, new TGeoTranslation(-fXRyoke/2 + fCoilH/2,0, -40*cm + fCoilW/2 + i*(fCoilGap + fCoilW)));
    }
    
      volLowYoke->AddNode(volFeYoke,3, new TGeoTranslation(0,0,- (fZArm + fGapMiddle)/2));
      volLowYoke->AddNode(volFeYoke,4, new TGeoTranslation(0,0,(fZArm + fGapMiddle)/2));
      volLowYoke->AddNode(volFeYoke1,1,new TGeoTranslation(0,0,0));
      volLowYoke->AddNode(volCoilContainer,3,new TGeoTranslation(0,fYRyoke/2- fCoilH/2,0)); //up
      volLowYoke->AddNode(volCoilContainer,4,new TGeoTranslation(0,-fYRyoke/2 + fCoilH/2,0)); //low
 
      Int_t ArmNumber = 1;
      TGeoBBox *Arm1Box = new TGeoBBox("Arm1MudetBox", fXFe/2, fYFe/2, fZArm/2);
      TGeoVolume *volArm1 = new TGeoVolume("volArm1Mudet", Arm1Box,air);
      TGeoUniformMagField *magField1 = new TGeoUniformMagField(0.,-fField,0.); //magnetic field arm1
      volArm1->SetField(magField1);
      volMudetBox ->AddNode(volArm1,ArmNumber,new TGeoTranslation(0,0,-(fGapMiddle+fZArm)/2));
    
      Int_t nr =  ArmNumber*1E4;
 
      TGeoBBox *IronLayer = new TGeoBBox("Iron",fXFe/2, fYFe/2, fZFe/2);
      TGeoVolume *volIron = new TGeoVolume("volIron",IronLayer,Iron);
      //volIron->SetField(magField1);
 
      for(Int_t i = 0; i < fNFe; i++)
    {
      volArm1->AddNode(volIron,nr + 100 + i, new TGeoTranslation(0, 0, -fZArm/2+i*(fZFe +fZRpc) +fZFe/2));
    }
 
   
      TGeoBBox *RpcContainer = new TGeoBBox("RpcContainer", fXRpc/2, fYRpc/2, fZRpc/2);
      TGeoVolume *volRpcContainer = new TGeoVolume("volRpcContainer",RpcContainer,air); 
  
      TGeoBBox *Strip = new TGeoBBox("Strip",fXStrip/2, fYStrip/2, fZStrip/2);
      TGeoVolume *volStrip = new TGeoVolume("volStrip",Strip,Cu);
      volStrip->SetLineColor(kRed);
      volRpcContainer->AddNode(volStrip,1,new TGeoTranslation (0,0,-3.25*mm));
      volRpcContainer->AddNode(volStrip,2,new TGeoTranslation (0,0,3.25*mm));
      TGeoBBox *PETinsulator = new TGeoBBox("PETinsulator", fXPet/2, fYPet/2, fZPet/2);
      TGeoVolume *volPETinsulator = new TGeoVolume("volPETinsulator", PETinsulator, bakelite);
      volPETinsulator->SetLineColor(kYellow);
      volRpcContainer->AddNode(volPETinsulator,1,new TGeoTranslation(0,0,-3.1*mm));
      volRpcContainer->AddNode(volPETinsulator,2,new TGeoTranslation(0,0, 3.1*mm));
      TGeoBBox *Electrode = new TGeoBBox("Electrode",fXEle/2, fYEle/2, fZEle/2);
      TGeoVolume *volElectrode = new TGeoVolume("volElectrode",Electrode,bakelite);
      volElectrode->SetLineColor(kGreen);
      volRpcContainer->AddNode(volElectrode,1,new TGeoTranslation(0,0,-2*mm));
      volRpcContainer->AddNode(volElectrode,2,new TGeoTranslation(0,0, 2*mm));
      TGeoBBox *RpcGas = new TGeoBBox("RpcGas", fXGas/2, fYGas/2, fZGas/2);
      TGeoVolume *volRpc = new TGeoVolume("volRpc",RpcGas,RPCmat);
      volRpc->SetLineColor(kCyan);
      volRpcContainer->AddNode(volRpc,1,new TGeoTranslation(0,0,0));
   
      AddSensitiveVolume(volRpc);
    
      for(Int_t i = 0; i < fNRpc; i++)
    {
      volArm1->AddNode(volRpcContainer,nr + i,new TGeoTranslation(0, -fYFe/2 + fYRpc/2, -fZArm/2+(i+1)*fZFe + i*fZRpc +fZRpc/2));
    }
    
      ArmNumber = 2;
      nr =  ArmNumber*1E4;
 
      TGeoBBox *Arm2Box = new TGeoBBox("Arm2MudetBox",fXFe/2, fYFe/2, fZArm/2);
      TGeoVolume *volArm2 = new TGeoVolume("volArm2Mudet", Arm2Box,air);
      TGeoUniformMagField *magField2 = new TGeoUniformMagField(0.,fField,0.); //magnetic field arm2
      volArm2->SetField(magField2);
      volMudetBox ->AddNode(volArm2,1,new TGeoTranslation(0,0,(fGapMiddle+fZArm)/2));
      TGeoVolume *volIron2 = new TGeoVolume("volIron2",IronLayer,Iron);
 
     //different volumes for second arm
 
      TGeoVolume *volRpcContainer2 = new TGeoVolume("volRpcContainer2",RpcContainer,air);      
      TGeoVolume *volStrip2 = new TGeoVolume("volStrip2",Strip,Cu);
      
      volStrip2->SetLineColor(kRed);
      volRpcContainer2->AddNode(volStrip2,1,new TGeoTranslation (0,0,-3.25*mm));
      volRpcContainer2->AddNode(volStrip2,2,new TGeoTranslation (0,0,3.25*mm));
 
      TGeoVolume *volPETinsulator2 = new TGeoVolume("volPETinsulator2", PETinsulator, bakelite);
      volPETinsulator2->SetLineColor(kYellow);
      volRpcContainer2->AddNode(volPETinsulator2,1,new TGeoTranslation(0,0,-3.1*mm));
      volRpcContainer2->AddNode(volPETinsulator2,2,new TGeoTranslation(0,0, 3.1*mm));
 
      TGeoVolume *volElectrode2 = new TGeoVolume("volElectrode2",Electrode,bakelite);
      volElectrode2->SetLineColor(kGreen);
      volRpcContainer2->AddNode(volElectrode2,1,new TGeoTranslation(0,0,-2*mm));
      volRpcContainer2->AddNode(volElectrode2,2,new TGeoTranslation(0,0, 2*mm));
   
      TGeoVolume *volRpc2 = new TGeoVolume("volRpc2",RpcGas,RPCmat);
      volRpc2->SetLineColor(kCyan);
      volRpcContainer2->AddNode(volRpc2,1,new TGeoTranslation(0,0,0));
      AddSensitiveVolume(volRpc2);
   
      for(Int_t i = 0; i < fNFe; i++)
    {
      volArm2->AddNode(volIron2,nr + 100 + i,new TGeoTranslation(0, 0, -fZArm/2+i*(fZFe +fZRpc) +fZFe/2));
    }
    
      for(Int_t i = 0; i < fNRpc; i++)
    {
      volArm2->AddNode(volRpcContainer2, nr + i,new TGeoTranslation(0, -fYFe/2 + fYRpc/2, -fZArm/2+(i+1)*fZFe + i*fZRpc +fZRpc/2));
    }
    
      //10 cm of Concrete on which the whole Magnetic Spectrometer volume (HPT included) will be placed
      TGeoBBox *Base = new TGeoBBox("Base", fXtot/2, 10*cm/2, fZtot/2);
      TGeoVolume *volBase = new TGeoVolume("volBase",Base,Conc);
      volBase->SetLineColor(kYellow-3);
 
      tTauNuDet->AddNode(volBase,1, new TGeoTranslation(0,-fYtot/2 + 10*cm/2,fZcenter));
 
 
      TGeoBBox *Pillar1Box = new TGeoBBox(fPillarX/2,fPillarY/2, fPillarZ/2);
      TGeoVolume *Pillar1Vol = new TGeoVolume("Pillar1Vol",Pillar1Box,Steel);
      Pillar1Vol->SetLineColor(kGreen+3);
 
      tTauNuDet->AddNode(Pillar1Vol,1, new TGeoTranslation(-fXtot/2+fPillarX/2,-fYtot/2-fPillarY/2,fZcenter-fZArm/2 - fGapMiddle/2 +fPillarZ/2));
      tTauNuDet->AddNode(Pillar1Vol,2, new TGeoTranslation(fXtot/2-fPillarX/2,-fYtot/2-fPillarY/2,fZcenter-fZArm/2 - fGapMiddle/2 +fPillarZ/2));
      tTauNuDet->AddNode(Pillar1Vol,3, new TGeoTranslation(-fXtot/2+fPillarX/2,-fYtot/2-fPillarY/2,fZcenter+fZArm/2+fGapMiddle/2-fPillarZ/2));
      tTauNuDet->AddNode(Pillar1Vol,4, new TGeoTranslation(fXtot/2-fPillarX/2,-fYtot/2-fPillarY/2,fZcenter+fZArm/2+fGapMiddle/2-fPillarZ/2));
    }
  if(fDesign==3)
    {
      Double_t supportasymmetry = fUpSuppY - fLowSuppY; //upper and lower support have different dimensions, so the mother box must be large enough to contain both
      Int_t nr = 1E4;
            
      TGeoVolumeAssembly *volMudetBox = new TGeoVolumeAssembly("volTauNuMudet");
      tTauNuDet->AddNode(volMudetBox, 1, new TGeoTranslation(0,0,fZcenter));
 
      TGeoBBox *IronLayer = new TGeoBBox("Iron",fXFe/2, fYFe/2, fZFe/2);
      TGeoVolume *volIron = new TGeoVolume("volIron",IronLayer,Iron);
      volIron->SetLineColor(kGray);
 
      TGeoBBox *IronLayer1 = new TGeoBBox("Iron",fXFe/2, fYFe/2, fZFethin/2);
      TGeoVolume *volIron1 = new TGeoVolume("volIron1",IronLayer1,Iron);
      //***********************ADDING EXTERNAL DETAILS TO THE MUON FILTER
 
      //********UPPER COVER***********
 
      TGeoBBox *UpperCover = new TGeoBBox("UpperCover",fXCov/2, fYCov/2, fZCov/2);
      TGeoVolume *volUpperCover = new TGeoVolume("volUpperCover",UpperCover, Al);
      volUpperCover->SetLineColor(kYellow-7);
      volMudetBox->AddNode(volUpperCover, 1, new TGeoTranslation(0, fYFe/2+fYCov/2+fUpSuppY, -fZtot/2 + fZCov/2));
      
      //**********LATERAL COVER**********
 
      TGeoBBox *LateralCover = new TGeoBBox("LateralCover",fXLateral/2, fYLateral/2, fZLateral/2);
      TGeoVolume *volLateralCover = new TGeoVolume("volLateralCover",LateralCover, Al);
      volLateralCover->SetLineColor(kYellow-7);
      volMudetBox->AddNode(volLateralCover, 1, new TGeoTranslation(-fXFe/2.-fLatSuppX-fXLateral/2., -fYFe/2.+fYLateral/2.+fYSpacing+ 4.*cm, -fZtot/2 + fZLateral/2)); //low right
      volMudetBox->AddNode(volLateralCover, 2, new TGeoTranslation(+fXFe/2.+fLatSuppX+fXLateral/2., -fYFe/2.+fYLateral/2.+fYSpacing+ 4.*cm, -fZtot/2 + fZLateral/2)); //low left
      volMudetBox->AddNode(volLateralCover, 3, new TGeoTranslation(-fXFe/2.-fLatSuppX-fXLateral/2., +fYFe/2.-fYLateral/2.-fYSpacing- 4.*cm, -fZtot/2 + fZLateral/2)); //up right
      volMudetBox->AddNode(volLateralCover, 4, new TGeoTranslation(+fXFe/2.+fLatSuppX+fXLateral/2., +fYFe/2.-fYLateral/2.-fYSpacing- 4.*cm, -fZtot/2 + fZLateral/2)); //up left
 
      //*********** LATERAL CROSSES************
 
      Double_t Inclination =TMath::Pi()/2 - TMath::ATan(fYCross/(fZCross - fWidthArm)); 
      TGeoRotation *Crossrot1 = new TGeoRotation("Crossrot1", 0., 0.,0.); TGeoRotation *Crossrot2 = new TGeoRotation("Crossrot2", 0., 0.,0.);
      Crossrot1->RotateY(-90); Crossrot2->RotateY(90);
      Crossrot1->SetName("NegativeRot"); Crossrot2->SetName("PositiveRot");
      Crossrot1->RegisterYourself(); Crossrot2->RegisterYourself();
 
      TGeoPara *ArmCross1 = new TGeoPara ("ArmCross1", fWidthArm/2., fYCross/2, fXCross/2., TMath::RadToDeg()*Inclination, 0., 0.);//length and height are not x and y here, because it will be rotated!
      ArmCross1->SetName("ARMCROSS1");
      TGeoPara *ArmCross2 = new TGeoPara ("ArmCross2", fWidthArm/2., fYCross/2, fXCross/2., TMath::RadToDeg()*Inclination, 0., 0.);//length and height are not x and y here, because it will be rotated!
      ArmCross2->SetName("ARMCROSS2");
      TGeoCompositeShape *MuCross = new TGeoCompositeShape("MUFILTERCROSS", "ARMCROSS1:NegativeRot+ARMCROSS2:PositiveRot");
      TGeoVolume *volMuDetCross = new TGeoVolume("volMuDetCross",MuCross, Al);
      volMuDetCross->SetLineColor(kYellow-7);
      volMudetBox->AddNode(volMuDetCross, 1, new TGeoTranslation(-fXFe/2.-fLatSuppX-fXLateral+fXCross/2., 0., -fZtot/2 + fZCross/2)); // right
      volMudetBox->AddNode(volMuDetCross, 2, new TGeoTranslation(+fXFe/2.+fLatSuppX+fXLateral-fXCross/2., 0., -fZtot/2 + fZCross/2)); // left
 
      //***********************ADDING CUTS AT MID-LATERAL IN WALLS
      IronLayer->SetName("MUDETIRON");
      IronLayer1->SetName("MUDETIRON1");
 
      Double_t delta = 0.1; //to avoid border effects in the cuts (cut is not visualized in viewer, I do not know if it can affect simulation)
      TGeoTrd2  * Model= new TGeoTrd2("Model",fCutHeight/2,0, (fZFe+delta)/2,(fZFe+delta)/2,(fCutLength+delta)/2); //length and height are not x and y here, because it will be rotated!
      Model->SetName("MUDETTRIANGLE");
 
      TGeoRotation rot("rot",90,90,0);
      TGeoRotation rot1("rot1",-90,90,0);
      //cut on the right (seen from beam)
      const TGeoTranslation transright("trans",-fXFe/2.+ fCutLength/2,0,0);
      TGeoCombiTrans* combright = new TGeoCombiTrans(transright,rot);
      combright->SetName("MuDetcombright");
      combright->RegisterYourself(); 
      //cut on the left (seen from beam)
      const TGeoTranslation transleft("transleft",+fXFe/2.- fCutLength/2,0,0);
      TGeoCombiTrans* combleft = new TGeoCombiTrans(transleft,rot1);
      combleft->SetName("MuDetcombleft");
      combleft->RegisterYourself();  
      //unique volume, we cut the triangles
      TGeoCompositeShape *mudetcut = new TGeoCompositeShape("MUDETCUT", "(MUDETIRON-MUDETTRIANGLE:MuDetcombright)-MUDETTRIANGLE:MuDetcombleft");   
      mudetcut->SetName("MUDETTRIANGCUT");
      //same, for the thin layers
      TGeoCompositeShape *mudetcut1 = new TGeoCompositeShape("MUDETCUT1", "(MUDETIRON1-MUDETTRIANGLE:MuDetcombright)-MUDETTRIANGLE:MuDetcombleft");   
      mudetcut1->SetName("MUDETTRIANGCUT1");
      //addition of iron support structures
      //support layers, fot thick layers upstream
      TGeoBBox *UpperSupport = new TGeoBBox(fUpSuppX/2., fUpSuppY/2.,fZFe/2.);
      UpperSupport->SetName("MUDETUPSUPPORT");
      TGeoBBox *LowerSupport = new TGeoBBox(fLowSuppX/2., fLowSuppY/2.,fZFe/2.);
      LowerSupport->SetName("MUDETLOWSUPPORT");
      TGeoBBox *LateralSupport = new TGeoBBox(fLatSuppX/2., fLatSuppY/2., fZFe/2.);
      LateralSupport->SetName("MUDETLATERALSUPPORT");
      //support layers, for thin layers downstream
      TGeoBBox *UpperSupport1 = new TGeoBBox(fUpSuppX/2., fUpSuppY/2.,fZFethin/2.); //The 1 shapes have less z thickness
      UpperSupport1->SetName("MUDETUPSUPPORT1");
      TGeoBBox *LowerSupport1 = new TGeoBBox(fLowSuppX/2., fLowSuppY/2.,fZFethin/2.);
      LowerSupport1->SetName("MUDETLOWSUPPORT1");
      TGeoBBox *LateralSupport1 = new TGeoBBox(fLatSuppX/2., fLatSuppY/2.,fZFethin/2.);
      LateralSupport1->SetName("MUDETLATERALSUPPORT1");
      //Translations (left is considered from the beam, positive x)
 
      TGeoTranslation * upright = new TGeoTranslation("MuDetupright",-fXFe/2.+fUpSuppX/2.,fYFe/2+fUpSuppY/2.,0);
      TGeoTranslation * upleft = new TGeoTranslation("MuDetupleft",+fXFe/2.-fUpSuppX/2.,fYFe/2+fUpSuppY/2.,0); 
      TGeoTranslation * lateralupleft = new TGeoTranslation("MuDetlateralupleft",+fXFe/2.+fLowSuppX/2.,fYFe/2-fLowSuppY/2.-fYSpacing,0); 
      TGeoTranslation * lateralupright = new TGeoTranslation("MuDetlateralupright",-fXFe/2.-fLowSuppX/2.,fYFe/2-fLowSuppY/2.-fYSpacing,0); 
      TGeoTranslation * laterallowleft = new TGeoTranslation("MuDetlaterallowleft",+fXFe/2.+fLowSuppX/2.,-fYFe/2+fLowSuppY/2.+fYSpacing,0); 
      TGeoTranslation * laterallowright = new TGeoTranslation("MuDetlaterallowright",-fXFe/2.-fLowSuppX/2.,-fYFe/2+fLowSuppY/2.+fYSpacing,0); 
      TGeoTranslation * lowright = new TGeoTranslation("MuDetlowright",-fXFe/2.+fLowSuppX/2.,-fYFe/2-fLowSuppY/2.,0); 
      TGeoTranslation * lowleft = new TGeoTranslation("MuDetlowleft",+fXFe/2.-fLowSuppX/2.,-fYFe/2-fLowSuppY/2.,0);
      //necessary to put SetName, otherwise it will not find them
      upright->SetName("MuDetupright");
      upright->RegisterYourself();
      upleft->SetName("MuDetupleft");
      upleft->RegisterYourself();
      lowright->SetName("MuDetlowright");
      lowright->RegisterYourself();
      lowleft->SetName("MuDetlowleft");
      lowleft->RegisterYourself();
 
      lateralupleft->SetName("MuDetlateralupleft");
      lateralupleft->RegisterYourself();
      lateralupright->SetName("MuDetlateralupright");
      lateralupright->RegisterYourself();
      laterallowleft->SetName("MuDetlaterallowleft");
      laterallowleft->RegisterYourself();
      laterallowright->SetName("MuDetlaterallowright");
      laterallowright->RegisterYourself();
      //building composite shapes, writing compositions as TString first to improve readibility
      TString *supportaddition = new TString("MUDETTRIANGCUT+MUDETUPSUPPORT:MuDetupright+MUDETUPSUPPORT:MuDetupleft+MUDETLOWSUPPORT:MuDetlowright+MUDETLOWSUPPORT:MuDetlowleft+MUDETLATERALSUPPORT:MuDetlateralupleft+MUDETLATERALSUPPORT:MuDetlateralupright+MUDETLATERALSUPPORT:MuDetlaterallowleft+MUDETLATERALSUPPORT:MuDetlaterallowright");
      TString *supportaddition1 = new TString("MUDETTRIANGCUT1+MUDETUPSUPPORT1:MuDetupright+MUDETUPSUPPORT1:MuDetupleft+MUDETLOWSUPPORT1:MuDetlowright+MUDETLOWSUPPORT1:MuDetlowleft+MUDETLOWSUPPORT1:MuDetlowleft+MUDETLATERALSUPPORT1:MuDetlateralupleft+MUDETLATERALSUPPORT1:MuDetlateralupright+MUDETLATERALSUPPORT1:MuDetlaterallowleft+MUDETLATERALSUPPORT1:MuDetlaterallowright");
      TGeoCompositeShape * SupportedIronLayer = new TGeoCompositeShape("SupportedIronLayer",supportaddition->Data());
      TGeoCompositeShape * SupportedIronLayer1 = new TGeoCompositeShape("SupportedIronLayer1",supportaddition1->Data());
 
      TGeoVolume *MudetIronLayer = new TGeoVolume("MudetIronLayer", SupportedIronLayer, Iron);
      MudetIronLayer->SetLineColor(kRed+2);
      TGeoVolume *MudetIronLayer1 = new TGeoVolume("MudetIronLayer1", SupportedIronLayer1, Iron);
      MudetIronLayer1->SetLineColor(kRed+2);
 
      for(Int_t i = 0; i < fNFe; i++)
    {
          double dz = -fZtot/2+i*fZFe+fZFe/2+i*fZRpc;
          volMudetBox->AddNode(MudetIronLayer,nr + 100 + i, new TGeoTranslation(0, 0, dz));
    }
      for(Int_t i = 0; i < fNFethin; i++)
    {     
          double dz = -fZtot/2+fNFe*(fZRpc+fZFe)+i*fZFethin+fZFethin/2+i*fZRpc;
          volMudetBox->AddNode(MudetIronLayer1,nr + 100 + fNFe + i, new TGeoTranslation(0, 0,dz));
    }
      //*****************************RPC LAYERS****************************************
 
      TGeoBBox *RpcContainer_0 = new TGeoBBox("RpcContainer", fXRpc_outer/2, fYRpc_outer/2, fZRpc/2);
      RpcContainer_0->SetName("RPCCOINTAINER_0");
      
      /*
      TGeoBBox *Strip = new TGeoBBox("Strip",fXStrip/2, fYStrip/2, fZStrip/2);
      TGeoVolume *volStrip = new TGeoVolume("volStrip",Strip,Cu);
      volStrip->SetLineColor(kGreen);
      volRpcContainer->AddNode(volStrip,1,new TGeoTranslation (0,0,-3.25*mm));
      volRpcContainer->AddNode(volStrip,2,new TGeoTranslation (0,0,3.25*mm));
      TGeoBBox *PETinsulator = new TGeoBBox("PETinsulator", fXPet/2, fYPet/2, fZPet/2);
      TGeoVolume *volPETinsulator = new TGeoVolume("volPETinsulator", PETinsulator, bakelite);
      volPETinsulator->SetLineColor(kYellow);
      volRpcContainer->AddNode(volPETinsulator,1,new TGeoTranslation(0,0,-3.1*mm));
      volRpcContainer->AddNode(volPETinsulator,2,new TGeoTranslation(0,0, 3.1*mm));
      TGeoBBox *Electrode = new TGeoBBox("Electrode",fXEle/2, fYEle/2, fZEle/2);
      TGeoVolume *volElectrode = new TGeoVolume("volElectrode",Electrode,bakelite);
      volElectrode->SetLineColor(kGreen);
      volRpcContainer->AddNode(volElectrode,1,new TGeoTranslation(0,0,-2*mm));
      volRpcContainer->AddNode(volElectrode,2,new TGeoTranslation(0,0, 2*mm));
      TGeoBBox *RpcGas = new TGeoBBox("RpcGas", fXRpcGap/2, fYRpc_inner/2, fZGas/2);
      TGeoVolume *volRpc = new TGeoVolume("volRpc",RpcGas,RPCmat);
      volRpc->SetLineColor(kCyan);
      volRpcContainer->AddNode(volRpc,1,new TGeoTranslation(0,0,0));
      */
      
      TGeoBBox *RpcOuter =  new TGeoBBox("RpcOuter", fXRpc_outer/2, fYRpc_outer/2, fZRpc_outer/2);
      RpcOuter->SetName("RPCOUTER");
      TGeoTrd2 *Indentation = new TGeoTrd2("Indentation", (fYRpc_outer- 2*(31.2*cm+15.*cm))/2, (fYRpc_outer-2*31.2*cm)/2, (fZRpc_outer+0.1*cm)/2,(fZRpc_outer+0.1*cm)/2,(15.*cm+0.1*cm)/2); // (b, B, Z_up, Z_down, h)
      Indentation->SetName("INDENTATION");
      const TGeoTranslation leftindent("leftindent", (fXRpc_outer-15.*cm)/2, 0, 0);
      TGeoCombiTrans* left_ind = new TGeoCombiTrans(leftindent, rot);
      left_ind->SetName("LEFTINDENT");
      left_ind->RegisterYourself();
      const TGeoTranslation rightindent("rightindent", (-fXRpc_outer+15.*cm)/2, 0, 0);
      TGeoCombiTrans* right_ind = new TGeoCombiTrans(rightindent, rot1);
      right_ind->SetName("RIGHTINDENT");
      right_ind->RegisterYourself();
      TGeoBBox *RpcInner =  new TGeoBBox("RpcInner", fXRpc_inner/2, fYRpc_inner/2, fZRpc_inner/2);
      RpcInner->SetName("RPCINNER");
      TGeoTranslation *exclusion = new TGeoTranslation(0, 0, (-fZRpc_inner/2) -0.6*cm);
      exclusion->SetName("EXCLUSION");
      exclusion->RegisterYourself();
      TGeoCompositeShape *RpcShell = new TGeoCompositeShape("RpcShell", "RPCOUTER-INDENTATION:RIGHTINDENT-INDENTATION:LEFTINDENT-RPCINNER:EXCLUSION");
      TGeoVolume *volRpcShell = new TGeoVolume("volRpcShell", RpcShell, Al);
      volRpcShell->SetLineColor(kGray);
      
      TGeoBBox *GasShape = new TGeoBBox("GasShape", fXRpcGap/2, fYRpc_inner/2, fZGas/2);
      GasShape->SetName("RPCGAS");
      TGeoBBox *GapSpacing = new TGeoBBox("GapSpacing", fXRpcGap/2, 6./2*cm, (fZGas+0.01*cm)/2 );
      GapSpacing->SetName("GAPSPACE");
      TGeoTranslation *mdown = new TGeoTranslation("mdown", 0., -(fYRpcGap+6*cm)/2, 0.); // 6 cm is the spacing between two gaps
      mdown->SetName("MDOWN");
      mdown->RegisterYourself();
      TGeoTranslation *mup = new TGeoTranslation("mup",0., (fYRpcGap+6*cm)/2, 0.);
      mup->SetName("MUP");
      mup->RegisterYourself();
      TGeoCompositeShape *RpcGas = new TGeoCompositeShape("RpcGas", "RPCGAS-GAPSPACE:MUP-GAPSPACE:MDOWN");
      TGeoVolume *volRpc = new TGeoVolume("volRpc",RpcGas, RPCmat);
      volRpc->SetLineColor(kCyan);
      
      //****RPC container framing*********
      TGeoTrd2 *Indentation_0 = new TGeoTrd2("Indentation_0", (fYRpc_outer- 2*(31.2*cm+15.*cm))/2, (fYRpc_outer-2*31.2*cm)/2, (fZRpc)/2,(fZRpc)/2,(15.*cm+0.1*cm)/2);
      Indentation_0->SetName("INDENTATION_0");
      TGeoCompositeShape *RpcContainer = new TGeoCompositeShape("RpcContainer", "RPCCOINTAINER_0-INDENTATION_0:RIGHTINDENT-INDENTATION_0:LEFTINDENT"); 
      TGeoVolume *volRpcContainer = new TGeoVolume("volRpcContainer",RpcContainer,air);
      //***********************************
      
      TGeoBBox *GapShape = new TGeoBBox("GapShape", fXRpcGap/2, fYRpc_inner/2, fZRpcGap/2);
      GapShape->SetName("RPCGAP");
      TGeoBBox *GapSpacing1 = new TGeoBBox("GapSpacing1", fXRpcGap/2, 6./2*cm, (fZRpcGap+0.01*cm)/2);
      GapSpacing1->SetName("GAPSPACE1");
      TGeoCompositeShape *RpcGap = new TGeoCompositeShape("RpcGap", "RPCGAP-GAPSPACE1:MUP-GAPSPACE1:MDOWN");
      TGeoVolume *volRpcGap = new TGeoVolume("volRpcGap",RpcGap, bakelite);
      volRpcGap->SetLineColor(kOrange);
      
      TGeoBBox *Strip = new TGeoBBox("Strip", fXRpc_inner/2, fYRpc_inner/2, fZStrip/2);
      TGeoVolume *volStrip= new TGeoVolume("volStrip", Strip, Cu);
      volStrip->SetLineColor(kOrange+5);
      TGeoRotation rot2("rot2", 0., 0.,0.);
      rot2.RotateY(180);
      const TGeoTranslation trans_rot(0., 0., fZGas/2+fZRpcGap+fZStrip+fZRpc_outer/2);
      TGeoCombiTrans *comb_1 = new TGeoCombiTrans(trans_rot, rot2);
      
      volRpcContainer->AddNode(volRpcShell,1, new TGeoTranslation(0., 0., -fZGas/2-fZRpcGap-fZStrip-fZRpc_outer/2));
      volRpcContainer->AddNode(volRpcShell,2, comb_1);
      volRpcContainer->AddNode(volStrip, 1, new TGeoTranslation(0., 0., fZGas/2+fZRpcGap+fZStrip/2));
      volRpcContainer->AddNode(volStrip, 2, new TGeoTranslation(0., 0., -fZGas/2-fZRpcGap-fZStrip/2));
      volRpcContainer->AddNode(volRpcGap, 1, new TGeoTranslation(0., 0., (fZGas+fZRpcGap)/2));
      volRpcContainer->AddNode(volRpcGap, 2, new TGeoTranslation(0., 0., -(fZGas+fZRpcGap)/2));
      volRpcContainer->AddNode(volRpc, 1, new TGeoTranslation(0., 0., 0.));
 
      AddSensitiveVolume(volRpc);
      
      for(Int_t i = 0; i < fNRpc; i++)
    {
         double dy = 5.*cm;
         double dz = -fZtot/2 + (i+1)*fZFe + i*fZRpc + fZRpc/2;
         if (i >= fNFe) dz = dz - (i + 1 - fNFe) * (fZFe - fZFethin);
         if(i%2)volMudetBox->AddNode(volRpcContainer,nr + i,new TGeoTranslation(0, -dy, dz)); //staggering
         else{volMudetBox->AddNode(volRpcContainer,nr + i,new TGeoTranslation(0, dy, dz));}          
    }
    
      TGeoBBox *Pillar1Box = new TGeoBBox(fPillarX/2,fPillarY/2, fPillarZ/2);
      TGeoVolume *Pillar1Vol = new TGeoVolume("Pillar1Vol",Pillar1Box,Steel);
      Pillar1Vol->SetLineColor(kGreen+3);
 
      //tTauNuDet->AddNode(Pillar1Vol,1, new TGeoTranslation(-fXtot/2+fPillarX/2,-fYtot/2-fPillarY/2,fZcenter-fZtot/2+fPillarZ/2));
      //tTauNuDet->AddNode(Pillar1Vol,2, new TGeoTranslation(fXtot/2-fPillarX/2,-fYtot/2-fPillarY/2,fZcenter-fZtot/2 +fPillarZ/2));
      //      tTauNuDet->AddNode(Pillar1Vol,3, new TGeoTranslation(-fXtot/2+fPillarX/2,-fYtot/2-fPillarY/2,fZcenter+fZtot/2-fPillarZ/2)); //eventually two pillars at the end. Now muon det is followed by veto, so its steel pillar supports both
      //tTauNuDet->AddNode(Pillar1Vol,4, new TGeoTranslation(fXtot/2-fPillarX/2,-fYtot/2-fPillarY/2,fZcenter+fZtot/2-fPillarZ/2));
 
      
    }
 
}

◆ CopyClones()

virtual void NuTauMudet::CopyClones	(	TClonesArray *	cl1,
		TClonesArray *	cl2,
		Int_t	offset
	)

inlinevirtual

The following methods can be implemented if you need to make any optional action in your detector during the transport.

Definition at line 84 of file NuTauMudet.h.

85 {;}

◆ DecodeVolumeID()

void NuTauMudet::DecodeVolumeID	(	Int_t	detID,
		int &	nARM,
		int &	nRPC
	)

Definition at line 846 of file NuTauMudet.cxx.

{
  nARM =  detID/1E4;
  nRPC =  detID - nARM*1E4;
}

◆ EndOfEvent()

void NuTauMudet::EndOfEvent ( )

virtual

Definition at line 825 of file NuTauMudet.cxx.

{
  fShipRpcPointCollection->Clear();
}

◆ FinishPrimary()

virtual void NuTauMudet::FinishPrimary ( )

inlinevirtual

Definition at line 88 of file NuTauMudet.h.

88{;}

◆ FinishRun()

virtual void NuTauMudet::FinishRun ( )

inlinevirtual

Definition at line 89 of file NuTauMudet.h.

89{;}

◆ GetCollection()

TClonesArray * NuTauMudet::GetCollection ( Int_t iColl ) const

virtual

Gets the produced collections

Definition at line 852 of file NuTauMudet.cxx.

{
  if (iColl == 0) { return fShipRpcPointCollection; }
  else { return NULL; }
}

◆ Initialize()

void NuTauMudet::Initialize ( )

virtual

Initialization of the detector is done here

Definition at line 259 of file NuTauMudet.cxx.

{
  FairDetector::Initialize();
}

◆ InitMedium()

Int_t NuTauMudet::InitMedium ( const char * name )

private

Definition at line 265 of file NuTauMudet.cxx.

{
  static FairGeoLoader *geoLoad=FairGeoLoader::Instance();
  static FairGeoInterface *geoFace=geoLoad->getGeoInterface();
  static FairGeoMedia *media=geoFace->getMedia();
  static FairGeoBuilder *geoBuild=geoLoad->getGeoBuilder();
 
  FairGeoMedium *ShipMedium=media->getMedium(name);
 
  if (!ShipMedium)
    {
      Fatal("InitMedium","Material %s not defined in media file.", name);
      return -1111;
    }
  TGeoMedium* medium=gGeoManager->GetMedium(name);
  if (medium!=NULL)
    return ShipMedium->getMediumIndex();
  return geoBuild->createMedium(ShipMedium);
}

◆ operator=()

NuTauMudet & NuTauMudet::operator= ( const NuTauMudet & )

protected

◆ PostTrack()

virtual void NuTauMudet::PostTrack ( )

inlinevirtual

Definition at line 91 of file NuTauMudet.h.

91{;}

◆ PreTrack()

virtual void NuTauMudet::PreTrack ( )

inlinevirtual

Definition at line 92 of file NuTauMudet.h.

92{;}

◆ ProcessHits()

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

virtual

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

This method is called from the MC stepping

Definition at line 762 of file NuTauMudet.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 muonPoint at exit of active volume
  if ( gMC->IsTrackExiting()    ||
       gMC->IsTrackStop()       ||
       gMC->IsTrackDisappeared()   ) {
    fTrackID  = gMC->GetStack()->GetCurrentTrackNumber();
    fVolumeID = vol->getMCid();
    if (fELoss == 0. ) { return kFALSE; }
    TParticle* p=gMC->GetStack()->GetCurrentTrack();
    Int_t pdgCode = p->GetPdgCode();
    Int_t detID=0;
    gMC->CurrentVolID(detID);
    //cout<<"THIS HIT"<<endl;
    //cout<< "detID = " << detID << endl;
    Int_t MaxLevel = gGeoManager->GetLevel();
    const Int_t MaxL = MaxLevel;
    //cout << "MaxLevel = " << MaxL << endl;
    //cout << gMC->CurrentVolPath()<< endl;
    Int_t NRpc =0;
    const char *name;
    name = gMC->CurrentVolName();
    //cout << name << " ";
    Int_t motherID = 0;
    if( strcmp(name, "volRpc")==0){motherID = gGeoManager->GetMother(1)->GetNumber();}
    else{motherID = gGeoManager->GetMother(0)->GetNumber();}
    /* This up here is made because of a strange behaviour of the script, volRpc gets different
    Mother volume number even if it has the correct path */
    const char *mumname = gMC->CurrentVolOffName(1);
    //cout<<mumname<<"   "<< motherID<<endl;
    detID = motherID;
    //cout<< "detID = " << detID << endl;
    //cout<<endl;
    fVolumeID = detID;
 
    TLorentzVector Pos; 
    gMC->TrackPosition(Pos); 
    Double_t xmean = (fPos.X()+Pos.X())/2. ;      
    Double_t ymean = (fPos.Y()+Pos.Y())/2. ;      
    Double_t zmean = (fPos.Z()+Pos.Z())/2. ;     
     
    AddHit(fTrackID, fVolumeID, TVector3(xmean, ymean,  zmean), TVector3(fMom.Px(), fMom.Py(), fMom.Pz()), fTime, fLength,fELoss, pdgCode);
        
    // Increment number of muon det points in TParticle
    ShipStack* stack = (ShipStack*) gMC->GetStack();
    stack->AddPoint(ktauRpc);
  }
    
  return kTRUE;
}

◆ Register()

void NuTauMudet::Register ( )

virtual

Registers the produced collections in FAIRRootManager.

This will create a branch in the output tree called ShipRpcPoint, setting the last parameter to kFALSE means: this collection will not be written to the file, it will exist only during the simulation.

Definition at line 831 of file NuTauMudet.cxx.

{
    
  FairRootManager::Instance()->Register("ShipRpcPoint", "NuTauMudet",
                    fShipRpcPointCollection, kTRUE);
}

◆ Reset()

void NuTauMudet::Reset ( )

virtual

has to be called after each event to reset the containers

Definition at line 858 of file NuTauMudet.cxx.

{
  fShipRpcPointCollection->Clear();
}

◆ SetCoilParameters()

void NuTauMudet::SetCoilParameters	(	Double_t	CoilH,
		Double_t	CoilW,
		Int_t	N,
		Double_t	CoilG
	)

Definition at line 177 of file NuTauMudet.cxx.

{
  fCoilH = CoilH;
  fCoilW = CoilW;
  fCoilGap = CoilG;
  fNCoil = N;
}

◆ SetCrossDimensions()

void NuTauMudet::SetCrossDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z,
		Double_t	WidthArm
	)

Definition at line 221 of file NuTauMudet.cxx.

{
  fXCross = X;
  fYCross = Y;
  fZCross = Z;
  fWidthArm = WidthArm;
}

◆ SetDesign()

void NuTauMudet::SetDesign ( Int_t Design )

Definition at line 76 of file NuTauMudet.cxx.

{  
  fDesign = Design;
  cout <<" Mag Spectro Design "<< fDesign<<endl;
}

◆ SetFeDimensions()

void NuTauMudet::SetFeDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z,
		Double_t	Zthin = `0.`
	)

Definition at line 89 of file NuTauMudet.cxx.

{  
  fXFe = X;
  fYFe = Y;
  fZFe = Z;
  fZFethin = Zthin;
}

◆ SetGapDownstream()

void NuTauMudet::SetGapDownstream ( Double_t Gap )

Definition at line 151 of file NuTauMudet.cxx.

{
  fGapDown = Gap;
}

◆ SetGapMiddle()

void NuTauMudet::SetGapMiddle ( Double_t Gap )

Definition at line 156 of file NuTauMudet.cxx.

{
  fGapMiddle = Gap;
}

◆ SetLateralCoverDimensions()

void NuTauMudet::SetLateralCoverDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 214 of file NuTauMudet.cxx.

{
  fXLateral = X;
  fYLateral = Y;
  fZLateral = Z;
}

◆ SetLateralCutSize()

void NuTauMudet::SetLateralCutSize	(	Double_t	CutHeight,
		Double_t	CutLength
	)

Definition at line 196 of file NuTauMudet.cxx.

                                                                         {
  fCutHeight = CutHeight;
  fCutLength = CutLength;
}

◆ SetMagneticField()

void NuTauMudet::SetMagneticField ( Double_t B )

Definition at line 146 of file NuTauMudet.cxx.

{
  fField =B;
}

◆ SetNFeInArm()

void NuTauMudet::SetNFeInArm	(	Int_t	N,
		Int_t	Nthin = `0`
	)

Definition at line 166 of file NuTauMudet.cxx.

{
  fNFe = N;
  fNFethin = Nthin;
}

◆ SetNRpcInArm()

void NuTauMudet::SetNRpcInArm ( Int_t N )

Definition at line 172 of file NuTauMudet.cxx.

{
  fNRpc = N;
}

◆ SetPillarDimensions()

void NuTauMudet::SetPillarDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 201 of file NuTauMudet.cxx.

{
  fPillarX = X;
  fPillarY = Y;
  fPillarZ = Z;
}

◆ SetReturnYokeDimensions()

void NuTauMudet::SetReturnYokeDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 132 of file NuTauMudet.cxx.

{  
  fXRyoke = X;
  fYRyoke = Y;
  fZRyoke = Z;
}

◆ SetRpcDimensions()

void NuTauMudet::SetRpcDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 97 of file NuTauMudet.cxx.

{  
  fXRpc = X;
  fYRpc = Y;
  fZRpc = Z;
}

◆ SetRpcElectrodeDimensions()

void NuTauMudet::SetRpcElectrodeDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 118 of file NuTauMudet.cxx.

{  
  fXEle = X;
  fYEle = Y;
  fZEle = Z;
}

◆ SetRpcGapDimensions()

void NuTauMudet::SetRpcGapDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 243 of file NuTauMudet.cxx.

{
  fXRpcGap = X;
  fYRpcGap = Y;
  fZRpcGap = Z;
}

◆ SetRpcGasDimensions()

void NuTauMudet::SetRpcGasDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 104 of file NuTauMudet.cxx.

{  
  fXGas = X;
  fYGas = Y;
  fZGas = Z;
}

◆ SetRpcInnerDimensions()

void NuTauMudet::SetRpcInnerDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 236 of file NuTauMudet.cxx.

{
  fXRpc_inner = X;
  fYRpc_inner = Y;
  fZRpc_inner = Z;
}

◆ SetRpcOuterDimensions()

void NuTauMudet::SetRpcOuterDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 229 of file NuTauMudet.cxx.

{
  fXRpc_outer = X;
  fYRpc_outer = Y;
  fZRpc_outer = Z;
}

◆ SetRpcPETDimensions()

void NuTauMudet::SetRpcPETDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 111 of file NuTauMudet.cxx.

{  
  fXPet = X;
  fYPet = Y;
  fZPet = Z;
}

◆ SetRpcStripDimensions()

void NuTauMudet::SetRpcStripDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 125 of file NuTauMudet.cxx.

{  
  fXStrip = X;
  fYStrip = Y;
  fZStrip = Z;
}

◆ SetSmallerYokeDimensions()

void NuTauMudet::SetSmallerYokeDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 139 of file NuTauMudet.cxx.

{  
  fXRyoke_s = X;
  fYRyoke_s = Y;
  fZRyoke_s = Z;
}

◆ SetSpecialPhysicsCuts()

virtual void NuTauMudet::SetSpecialPhysicsCuts ( )

inlinevirtual

Definition at line 86 of file NuTauMudet.h.

86{;}

◆ SetSupportTransverseDimensions()

void NuTauMudet::SetSupportTransverseDimensions	(	Double_t	UpperSupportX,
		Double_t	UpperSupportY,
		Double_t	LowerSupportX,
		Double_t	LowerSupportY,
		Double_t	LateralSupportX,
		Double_t	LateralSupportY,
		Double_t	YSpacing
	)

Definition at line 185 of file NuTauMudet.cxx.

{
  fUpSuppX = UpperSupportX;
  fUpSuppY = UpperSupportY;
  fLowSuppX = LowerSupportX;
  fLowSuppY = LowerSupportY;
  fLatSuppX = LateralSupportX;
  fLatSuppY = LateralSupportY;
  fYSpacing = YSpacing;
}

◆ SetTotDimensions()

void NuTauMudet::SetTotDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 82 of file NuTauMudet.cxx.

{  
  fXtot = X;
  fYtot = Y;
  fZtot = Z;
}

◆ SetUpperCoverDimensions()

void NuTauMudet::SetUpperCoverDimensions	(	Double_t	X,
		Double_t	Y,
		Double_t	Z
	)

Definition at line 208 of file NuTauMudet.cxx.

{
  fXCov = X;
  fYCov = Y;
  fZCov = Z;
}

◆ SetZDimensionArm()

void NuTauMudet::SetZDimensionArm ( Double_t Z )

Definition at line 161 of file NuTauMudet.cxx.

{
  fZArm = Z;
}

Member Data Documentation

◆ fCoilGap

Double_t NuTauMudet::fCoilGap

protected

Definition at line 146 of file NuTauMudet.h.

◆ fCoilH

Double_t NuTauMudet::fCoilH

protected

Definition at line 147 of file NuTauMudet.h.

◆ fCoilW

Double_t NuTauMudet::fCoilW

protected

Definition at line 148 of file NuTauMudet.h.

◆ fCutHeight

Double_t NuTauMudet::fCutHeight

protected

Definition at line 169 of file NuTauMudet.h.

◆ fCutLength

Double_t NuTauMudet::fCutLength

protected

Definition at line 169 of file NuTauMudet.h.

◆ fDesign

Int_t NuTauMudet::fDesign

protected

Definition at line 120 of file NuTauMudet.h.

◆ fELoss

Double32_t NuTauMudet::fELoss

private

length

Definition at line 109 of file NuTauMudet.h.

◆ fField

Double_t NuTauMudet::fField

protected

Definition at line 136 of file NuTauMudet.h.

◆ fGapDown

Double_t NuTauMudet::fGapDown

protected

Definition at line 134 of file NuTauMudet.h.

◆ fGapMiddle

Double_t NuTauMudet::fGapMiddle

protected

Definition at line 135 of file NuTauMudet.h.

◆ fLatSuppX

Double_t NuTauMudet::fLatSuppX

protected

Definition at line 166 of file NuTauMudet.h.

◆ fLatSuppY

Double_t NuTauMudet::fLatSuppY

protected

Definition at line 166 of file NuTauMudet.h.

◆ fLength

Double32_t NuTauMudet::fLength

private

time

Definition at line 108 of file NuTauMudet.h.

◆ fLowSuppX

Double_t NuTauMudet::fLowSuppX

protected

Definition at line 165 of file NuTauMudet.h.

◆ fLowSuppY

Double_t NuTauMudet::fLowSuppY

protected

Definition at line 165 of file NuTauMudet.h.

◆ fMom

TLorentzVector NuTauMudet::fMom

private

position at entrance

Definition at line 106 of file NuTauMudet.h.

◆ fNCoil

Int_t NuTauMudet::fNCoil

protected

Definition at line 149 of file NuTauMudet.h.

◆ fNFe

Int_t NuTauMudet::fNFe

protected

Definition at line 125 of file NuTauMudet.h.

◆ fNFethin

Int_t NuTauMudet::fNFethin

protected

Definition at line 125 of file NuTauMudet.h.

◆ fNRpc

Int_t NuTauMudet::fNRpc

protected

Definition at line 126 of file NuTauMudet.h.

◆ fPdgCode

Int_t NuTauMudet::fPdgCode

private

track index

Definition at line 103 of file NuTauMudet.h.

◆ fPillarX

Double_t NuTauMudet::fPillarX

protected

Definition at line 171 of file NuTauMudet.h.

◆ fPillarY

Double_t NuTauMudet::fPillarY

protected

Definition at line 172 of file NuTauMudet.h.

◆ fPillarZ

Double_t NuTauMudet::fPillarZ

protected

Definition at line 173 of file NuTauMudet.h.

◆ fPos

TLorentzVector NuTauMudet::fPos

private

volume id

Definition at line 105 of file NuTauMudet.h.

◆ fShipRpcPointCollection

TClonesArray* NuTauMudet::fShipRpcPointCollection

private

energy loss

container for data points

Definition at line 112 of file NuTauMudet.h.

◆ fTime

Double32_t NuTauMudet::fTime

private

momentum at entrance

Definition at line 107 of file NuTauMudet.h.

◆ fTrackID

Int_t NuTauMudet::fTrackID

private

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

Definition at line 102 of file NuTauMudet.h.

◆ fUpSuppX

Double_t NuTauMudet::fUpSuppX

protected

Definition at line 164 of file NuTauMudet.h.

◆ fUpSuppY

Double_t NuTauMudet::fUpSuppY

protected

Definition at line 164 of file NuTauMudet.h.

◆ fVolumeID

Int_t NuTauMudet::fVolumeID

private

pdg code

Definition at line 104 of file NuTauMudet.h.

◆ fWidthArm

Double_t NuTauMudet::fWidthArm

protected

Definition at line 186 of file NuTauMudet.h.

◆ fXCov

Double_t NuTauMudet::fXCov

protected

Definition at line 175 of file NuTauMudet.h.

◆ fXCross

Double_t NuTauMudet::fXCross

protected

Definition at line 183 of file NuTauMudet.h.

◆ fXEle

Double_t NuTauMudet::fXEle

protected

Definition at line 158 of file NuTauMudet.h.

◆ fXFe

Double_t NuTauMudet::fXFe

protected

Definition at line 127 of file NuTauMudet.h.

◆ fXGas

Double_t NuTauMudet::fXGas

protected

Definition at line 161 of file NuTauMudet.h.

◆ fXLateral

Double_t NuTauMudet::fXLateral

protected

Definition at line 179 of file NuTauMudet.h.

◆ fXPet

Double_t NuTauMudet::fXPet

protected

Definition at line 155 of file NuTauMudet.h.

◆ fXRpc

Double_t NuTauMudet::fXRpc

protected

Definition at line 128 of file NuTauMudet.h.

◆ fXRpc_inner

Double_t NuTauMudet::fXRpc_inner

protected

Definition at line 192 of file NuTauMudet.h.

◆ fXRpc_outer

Double_t NuTauMudet::fXRpc_outer

protected

Definition at line 188 of file NuTauMudet.h.

◆ fXRpcGap

Double_t NuTauMudet::fXRpcGap

protected

Definition at line 196 of file NuTauMudet.h.

◆ fXRyoke

Double_t NuTauMudet::fXRyoke

protected

Definition at line 137 of file NuTauMudet.h.

◆ fXRyoke_s

Double_t NuTauMudet::fXRyoke_s

protected

Definition at line 142 of file NuTauMudet.h.

◆ fXStrip

Double_t NuTauMudet::fXStrip

protected

Definition at line 152 of file NuTauMudet.h.

◆ fXtot

Double_t NuTauMudet::fXtot

protected

Definition at line 122 of file NuTauMudet.h.

◆ fYCov

Double_t NuTauMudet::fYCov

protected

Definition at line 176 of file NuTauMudet.h.

◆ fYCross

Double_t NuTauMudet::fYCross

protected

Definition at line 184 of file NuTauMudet.h.

◆ fYEle

Double_t NuTauMudet::fYEle

protected

Definition at line 159 of file NuTauMudet.h.

◆ fYFe

Double_t NuTauMudet::fYFe

protected

Definition at line 129 of file NuTauMudet.h.

◆ fYGas

Double_t NuTauMudet::fYGas

protected

Definition at line 162 of file NuTauMudet.h.

◆ fYLateral

Double_t NuTauMudet::fYLateral

protected

Definition at line 180 of file NuTauMudet.h.

◆ fYPet

Double_t NuTauMudet::fYPet

protected

Definition at line 156 of file NuTauMudet.h.

◆ fYRpc

Double_t NuTauMudet::fYRpc

protected

Definition at line 130 of file NuTauMudet.h.

◆ fYRpc_inner

Double_t NuTauMudet::fYRpc_inner

protected

Definition at line 193 of file NuTauMudet.h.

◆ fYRpc_outer

Double_t NuTauMudet::fYRpc_outer

protected

Definition at line 189 of file NuTauMudet.h.

◆ fYRpcGap

Double_t NuTauMudet::fYRpcGap

protected

Definition at line 197 of file NuTauMudet.h.

◆ fYRyoke

Double_t NuTauMudet::fYRyoke

protected

Definition at line 138 of file NuTauMudet.h.

◆ fYRyoke_s

Double_t NuTauMudet::fYRyoke_s

protected

Definition at line 143 of file NuTauMudet.h.

◆ fYSpacing

Double_t NuTauMudet::fYSpacing

protected

Definition at line 167 of file NuTauMudet.h.

◆ fYStrip

Double_t NuTauMudet::fYStrip

protected

Definition at line 153 of file NuTauMudet.h.

◆ fYtot

Double_t NuTauMudet::fYtot

protected

Definition at line 123 of file NuTauMudet.h.

◆ fZArm

Double_t NuTauMudet::fZArm

protected

Definition at line 133 of file NuTauMudet.h.

◆ fZcenter

Double_t NuTauMudet::fZcenter

protected

Definition at line 121 of file NuTauMudet.h.

◆ fZCov

Double_t NuTauMudet::fZCov

protected

Definition at line 177 of file NuTauMudet.h.

◆ fZCross

Double_t NuTauMudet::fZCross

protected

Definition at line 185 of file NuTauMudet.h.

◆ fZEle

Double_t NuTauMudet::fZEle

protected

Definition at line 160 of file NuTauMudet.h.

◆ fZFe

Double_t NuTauMudet::fZFe

protected

Definition at line 131 of file NuTauMudet.h.

◆ fZFethin

Double_t NuTauMudet::fZFethin

protected

Definition at line 131 of file NuTauMudet.h.

◆ fZGas

Double_t NuTauMudet::fZGas

protected

Definition at line 163 of file NuTauMudet.h.

◆ fZLateral

Double_t NuTauMudet::fZLateral

protected

Definition at line 181 of file NuTauMudet.h.

◆ fZPet

Double_t NuTauMudet::fZPet

protected

Definition at line 157 of file NuTauMudet.h.

◆ fZRpc

Double_t NuTauMudet::fZRpc

protected

Definition at line 132 of file NuTauMudet.h.

◆ fZRpc_inner

Double_t NuTauMudet::fZRpc_inner

protected

Definition at line 194 of file NuTauMudet.h.

◆ fZRpc_outer

Double_t NuTauMudet::fZRpc_outer

protected

Definition at line 190 of file NuTauMudet.h.

◆ fZRpcGap

Double_t NuTauMudet::fZRpcGap

protected

Definition at line 198 of file NuTauMudet.h.

◆ fZRyoke

Double_t NuTauMudet::fZRyoke

protected

Definition at line 139 of file NuTauMudet.h.

◆ fZRyoke_s

Double_t NuTauMudet::fZRyoke_s

protected

Definition at line 144 of file NuTauMudet.h.

◆ fZStrip

Double_t NuTauMudet::fZStrip

protected

Definition at line 154 of file NuTauMudet.h.

◆ fZtot

Double_t NuTauMudet::fZtot

protected

Definition at line 124 of file NuTauMudet.h.

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

nutaudet/NuTauMudet.h
nutaudet/NuTauMudet.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ NuTauMudet() [1/3]

◆ NuTauMudet() [2/3]

◆ ~NuTauMudet()

◆ NuTauMudet() [3/3]

Member Function Documentation

◆ AddHit()

◆ BeginEvent()

◆ BeginPrimary()

◆ ConstructGeometry()

◆ CopyClones()

◆ DecodeVolumeID()

◆ EndOfEvent()

◆ FinishPrimary()

◆ FinishRun()

◆ GetCollection()

◆ Initialize()

◆ InitMedium()

◆ operator=()

◆ PostTrack()

◆ PreTrack()

◆ ProcessHits()

◆ Register()

◆ Reset()

◆ SetCoilParameters()

◆ SetCrossDimensions()

◆ SetDesign()

◆ SetFeDimensions()

◆ SetGapDownstream()

◆ SetGapMiddle()

◆ SetLateralCoverDimensions()

◆ SetLateralCutSize()

◆ SetMagneticField()

◆ SetNFeInArm()

◆ SetNRpcInArm()

◆ SetPillarDimensions()

◆ SetReturnYokeDimensions()

◆ SetRpcDimensions()

◆ SetRpcElectrodeDimensions()

◆ SetRpcGapDimensions()

◆ SetRpcGasDimensions()

◆ SetRpcInnerDimensions()

◆ SetRpcOuterDimensions()

◆ SetRpcPETDimensions()

◆ SetRpcStripDimensions()

◆ SetSmallerYokeDimensions()

◆ SetSpecialPhysicsCuts()

◆ SetSupportTransverseDimensions()

◆ SetTotDimensions()

◆ SetUpperCoverDimensions()

◆ SetZDimensionArm()

Member Data Documentation

◆ fCoilGap

◆ fCoilH

◆ fCoilW

◆ fCutHeight

◆ fCutLength

◆ fDesign

◆ fELoss

◆ fField

◆ fGapDown

◆ fGapMiddle

◆ fLatSuppX

◆ fLatSuppY

◆ fLength

◆ fLowSuppX

◆ fLowSuppY

◆ fMom

◆ fNCoil

◆ fNFe

◆ fNFethin

◆ fNRpc

◆ fPdgCode

◆ fPillarX