SND@LHC Software
Loading...
Searching...
No Matches
Functions | Variables
shipDet_conf Namespace Reference

Functions

 getParameter (x, ship_geo, latestShipGeo)
 
 posHcal (z, hfile, HcalOption)
 
 makeEcalGeoFile (z, efile)
 
 posEcal (z, efile)
 
 configure (run, ship_geo)
 

Variables

list detectorList = []
 
 n_plates
 
 NuTauTT = ROOT.TargetTracker("TargetTrackers", ship_geo.NuTauTT.TTX, ship_geo.NuTauTT.TTY, ship_geo.NuTauTT.TTZ, ROOT.kTRUE)
 
 tauHpt = ROOT.Hpt("HighPrecisionTrackers",ship_geo.tauHPT.DX, ship_geo.tauHPT.DY, ship_geo.tauHPT.DZ, ROOT.kTRUE)
 
 YLayerOffset
 
 YPlaneOffset
 
 DeltazFrame
 
 FrameLateralWidth
 
 FrameMaterial
 
 Strawtubes = ROOT.strawtubes("Strawtubes", ROOT.kTRUE)
 
 Preshower = ROOT.preshower("Preshower", ROOT.kTRUE)
 
 ecal
 
 EcalZSize
 
 SplitCal = ROOT.splitcal("SplitCal", ROOT.kTRUE)
 
 x = ship_geo.SplitCal
 
 hcal
 
 HcalZSize
 
 Muon = ROOT.muon("Muon", ROOT.kTRUE)
 
 upstreamTagger = ROOT.UpstreamTagger("UpstreamTagger", ROOT.kTRUE)
 
 timeDet = ROOT.TimeDet("TimeDet", ROOT.kTRUE)
 
 fMagField
 
list exclusionList = []
 
dict detElements = {}
 

Function Documentation

◆ configure()

shipDet_conf.configure (   run,
  ship_geo 
)

Definition at line 75 of file shipDet_conf.py.

75def configure(run,ship_geo):
76# ---- for backward compatibility ----
77 if not hasattr(ship_geo,"tankDesign"): ship_geo.tankDesign = 5
78 if not hasattr(ship_geo,"muShieldGeo"): ship_geo.muShieldGeo = None
79 if not hasattr(ship_geo.hcal,"File"): ship_geo.hcal.File = "hcal.geo"
80 if not hasattr(ship_geo.Bfield,'x') : ship_geo.Bfield.x = 3.*u.m
81 if not hasattr(ship_geo,'cave') :
82 ship_geo.cave = AttrDict(z=0*u.cm)
83 ship_geo.cave.floorHeightMuonShield = 5*u.m
84 ship_geo.cave.floorHeightTankA = 4.5*u.m
85 ship_geo.cave.floorHeightTankB = 2.*u.m
86 if not hasattr(ship_geo,'NuTauTT') : ship_geo.NuTauTT= AttrDict(z=0*u.cm)
87 if not hasattr(ship_geo.NuTauTT,'design') : ship_geo.NuTauTT.design = 0
88 if not hasattr(ship_geo,'EcalOption'): ship_geo.EcalOption = 1
89 latestShipGeo = ConfigRegistry.loadpy("$FAIRSHIP/geometry/geometry_config.py",Yheight = ship_geo.Yheight/u.m, tankDesign = ship_geo.tankDesign, muShieldDesign = ship_geo.muShieldDesign, nuTauTargetDesign = ship_geo.nuTauTargetDesign, muShieldGeo = ship_geo.muShieldGeo)
90# -----Create media-------------------------------------------------
91 run.SetMaterials("media.geo") # Materials
92# ------------------------------------------------------------------------
93
94# -----Create geometry----------------------------------------------
95 cave= ROOT.ShipCave("CAVE")
96 if ship_geo.tankDesign < 5: cave.SetGeometryFileName("cave.geo")
97 else: cave.SetGeometryFileName("caveWithAir.geo")
98 detectorList.append(cave)
99
100 if ship_geo.muShieldDesign in [6, 7, 8, 9,10]: # magnetized hadron absorber defined in ShipMuonShield
101 TargetStation = ROOT.ShipTargetStation("TargetStation",ship_geo.target.length,
102 ship_geo.target.z,ship_geo.targetOpt,ship_geo.target.sl)
103 else:
104 TargetStation = ROOT.ShipTargetStation("TargetStation",ship_geo.target.length,ship_geo.hadronAbsorber.length,
105 ship_geo.target.z,ship_geo.hadronAbsorber.z,ship_geo.targetOpt,ship_geo.target.sl)
106
107 if ship_geo.targetOpt>10:
108 slices_length = ROOT.std.vector('float')()
109 slices_material = ROOT.std.vector('std::string')()
110 for i in range(1,ship_geo.targetOpt+1):
111 slices_length.push_back( eval("ship_geo.target.L"+str(i)))
112 slices_material.push_back(eval("ship_geo.target.M"+str(i)))
113 TargetStation.SetLayerPosMat(ship_geo.target.xy,slices_length,slices_material)
114 detectorList.append(TargetStation)
115
116 if ship_geo.muShieldDesign==1:
117 MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.length,\
118 ship_geo.muShield.LE)
119 elif ship_geo.muShieldDesign==2:
120 MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.dZ1,\
121 ship_geo.muShield.dZ2,ship_geo.muShield.dZ3,ship_geo.muShield.dZ4,ship_geo.muShield.dZ5,ship_geo.muShield.dZ6,ship_geo.muShield.LE)
122 elif ship_geo.muShieldDesign in [3, 4, 5, 6, 7, 9]:
123 MuonShield = ROOT.ShipMuonShield(
124 "MuonShield", ship_geo.muShieldDesign, "ShipMuonShield",
125 ship_geo.muShield.z, ship_geo.muShield.dZ0, ship_geo.muShield.dZ1,
126 ship_geo.muShield.dZ2, ship_geo.muShield.dZ3,
127 ship_geo.muShield.dZ4, ship_geo.muShield.dZ5,
128 ship_geo.muShield.dZ6, ship_geo.muShield.dZ7,
129 ship_geo.muShield.dZ8, ship_geo.muShield.dXgap,
130 ship_geo.muShield.LE, ship_geo.Yheight * 4. / 10.,
131 ship_geo.cave.floorHeightMuonShield,ship_geo.muShield.Field,
132 ship_geo.muShieldWithCobaltMagnet, ship_geo.muShieldStepGeo,
133 ship_geo.hadronAbsorber.WithConstField, ship_geo.muShield.WithConstField)
134 elif ship_geo.muShieldDesign == 8:
135 MuonShield = ROOT.ShipMuonShield(ship_geo.muShieldGeo,
136 ship_geo.muShieldWithCobaltMagnet,
137 ship_geo.muShieldStepGeo,
138 ship_geo.hadronAbsorber.WithConstField,
139 ship_geo.muShield.WithConstField)
140
141 detectorList.append(MuonShield)
142
143 if not hasattr(ship_geo,"magnetDesign"):
144 # backward compatibility
145 magnet_design = 2
146 if ship_geo.tankDesign == 5: magnet_design = 3
147 if ship_geo.tankDesign == 6: magnet_design = 4
148 ship_geo.magnetDesign = magnet_design
149 ship_geo.Bfield.YokeWidth = 200.*u.cm
150 ship_geo.Bfield.YokeDepth = 200.*u.cm
151 ship_geo.Bfield.CoilThick = 25.*u.cm
152# sanity check, 2018 layout ship_geo.tankDesign == 6 has to be together with ship_geo.nuTauTargetDesign == 3
153 if (ship_geo.tankDesign == 6 and ship_geo.nuTauTargetDesign != 3) or (ship_geo.tankDesign != 6 and ship_geo.nuTauTargetDesign == 3):
154 print("version of tankDesign and nuTauTargetDesign are not compatible, should be 6 and 3, it is ",ship_geo.tankDesign, ship_geo.nuTauTargetDesign)
155 exit()
156 if ship_geo.strawDesign > 1 :
157 if ship_geo.magnetDesign>3:
158 B = ship_geo.Bfield
159 magnet = ROOT.ShipMagnet("Magnet","SHiP Magnet",B.z, ship_geo.magnetDesign, B.x, B.y, ship_geo.cave.floorHeightTankB, B.YokeWidth, B.YokeDepth, B.CoilThick)
160# xaperture, yaperture
161 else:
162 magnet = ROOT.ShipMagnet("Magnet","SHiP Magnet",ship_geo.Bfield.z, ship_geo.magnetDesign, ship_geo.Bfield.x, ship_geo.Bfield.y, ship_geo.cave.floorHeightTankB)
163 else: magnet = ROOT.ShipMagnet("Magnet","SHiP Magnet",ship_geo.Bfield.z)
164 detectorList.append(magnet)
165
166 Veto = ROOT.veto("Veto", ROOT.kTRUE) # vacuum tank
167 Veto.SetLiquidVeto(1) # liquid scintillator
168 Veto.SetPlasticVeto(1) # plastic scintillator
169
170 Veto.SetZpositions(ship_geo.vetoStation.z, ship_geo.TrackStation1.z, ship_geo.TrackStation2.z, \
171 ship_geo.TrackStation3.z, ship_geo.TrackStation4.z,ship_geo.tankDesign)
172 Veto.SetTubZpositions(ship_geo.Chamber1.z,ship_geo.Chamber2.z,ship_geo.Chamber3.z,ship_geo.Chamber4.z,ship_geo.Chamber5.z,ship_geo.Chamber6.z)
173 Veto.SetTublengths(ship_geo.chambers.Tub1length,ship_geo.chambers.Tub2length,ship_geo.chambers.Tub3length, \
174 ship_geo.chambers.Tub6length)
175 Veto.SetB(ship_geo.Yheight/2.)
176 Veto.SetFloorHeight(ship_geo.cave.floorHeightTankA,ship_geo.cave.floorHeightTankB)
177 if ship_geo.tankDesign > 4:
178 dzX = ship_geo.zFocusX+ship_geo.target.z0
179 x1 = ship_geo.xMax/(ship_geo.Chamber1.z -ship_geo.chambers.Tub1length-dzX)*(ship_geo.TrackStation4.z-dzX)
180 dzY = ship_geo.zFocusY+ship_geo.target.z0
181 y1 = ship_geo.Yheight/(ship_geo.Chamber1.z -ship_geo.chambers.Tub1length-dzY)*(ship_geo.TrackStation4.z-dzY)
182 Veto.SetXYstart(x1,dzX,y1,dzY)
183 Veto.SetVesselStructure(ship_geo.Veto.innerSupport,ship_geo.Veto.sensitiveThickness,ship_geo.Veto.outerSupport,\
184 ship_geo.Veto.innerSupportMed,ship_geo.Veto.lidThickness,ship_geo.Veto.sensitiveMed,\
185 ship_geo.Veto.outerSupportMed,ship_geo.Veto.decayMed,\
186 ship_geo.Veto.rib)
187
188 detectorList.append(Veto)
189 if hasattr(ship_geo,'tauMudet'): # don't support old designs
190
191 if ship_geo.muShieldDesign not in [2,3,4] and hasattr(ship_geo.tauMudet,'Xtot'):
192 taumuondetector = ROOT.NuTauMudet("NuTauMudet", ship_geo.tauMudet.zMudetC, ROOT.kTRUE)
193 taumuondetector.SetDesign(ship_geo.nuTauTargetDesign)
194 taumuondetector.SetTotDimensions(ship_geo.tauMudet.Xtot,ship_geo.tauMudet.Ytot, ship_geo.tauMudet.Ztot )
195 if hasattr(ship_geo.tauMudet,'ZFethin'):
196 taumuondetector.SetFeDimensions(ship_geo.tauMudet.XFe,ship_geo.tauMudet.YFe, ship_geo.tauMudet.ZFethick,ship_geo.tauMudet.ZFethin)
197 taumuondetector.SetNFeInArm(ship_geo.tauMudet.NFethick, ship_geo.tauMudet.NFethin)
198 taumuondetector.SetLateralCutSize(ship_geo.tauMudet.CutHeight, ship_geo.tauMudet.CutLength)
199 taumuondetector.SetSupportTransverseDimensions(ship_geo.tauMudet.UpperSupportX,ship_geo.tauMudet.UpperSupportY, \
200 ship_geo.tauMudet.LowerSupportX, ship_geo.tauMudet.LowerSupportY, \
201 ship_geo.tauMudet.LateralSupportX, ship_geo.tauMudet.LateralSupportY, ship_geo.tauMudet.YSpacing)
202 else: #geometry used before new iron sampling
203 taumuondetector.SetFeDimensions(ship_geo.tauMudet.XFe,ship_geo.tauMudet.YFe, ship_geo.tauMudet.ZFe)
204 taumuondetector.SetNFeInArm(ship_geo.tauMudet.NFe)
205 taumuondetector.SetRpcDimensions(ship_geo.tauMudet.XRpc,ship_geo.tauMudet.YRpc, ship_geo.tauMudet.ZRpc)
206 taumuondetector.SetRpcGasDimensions(ship_geo.tauMudet.XGas,ship_geo.tauMudet.YGas, ship_geo.tauMudet.ZGas)
207 taumuondetector.SetRpcStripDimensions(ship_geo.tauMudet.XStrip,ship_geo.tauMudet.YStrip, ship_geo.tauMudet.ZStrip)
208 taumuondetector.SetRpcElectrodeDimensions(ship_geo.tauMudet.XEle,ship_geo.tauMudet.YEle, ship_geo.tauMudet.ZEle)
209 taumuondetector.SetRpcPETDimensions(ship_geo.tauMudet.XPet,ship_geo.tauMudet.YPet, ship_geo.tauMudet.ZPet)
210 taumuondetector.SetNRpcInArm(ship_geo.tauMudet.NRpc)
211 taumuondetector.SetUpperCoverDimensions(ship_geo.tauMudet.XCov, ship_geo.tauMudet.YCov, ship_geo.tauMudet.ZCov)
212 taumuondetector.SetLateralCoverDimensions(ship_geo.tauMudet.XLateral, ship_geo.tauMudet.YLateral, ship_geo.tauMudet.ZLateral)
213 taumuondetector.SetCrossDimensions(ship_geo.tauMudet.XCross, ship_geo.tauMudet.YCross, ship_geo.tauMudet.ZCross, ship_geo.tauMudet.WidthArm)
214 taumuondetector.SetRpcOuterDimensions(ship_geo.tauMudet.XRpc_outer, ship_geo.tauMudet.YRpc_outer, ship_geo.tauMudet.ZRpc_outer)
215 taumuondetector.SetRpcInnerDimensions(ship_geo.tauMudet.XRpc_inner, ship_geo.tauMudet.YRpc_inner, ship_geo.tauMudet.ZRpc_inner)
216 taumuondetector.SetRpcGapDimensions(ship_geo.tauMudet.XRpcGap, ship_geo.tauMudet.YRpcGap, ship_geo.tauMudet.ZRpcGap)
217 taumuondetector.SetPillarDimensions(ship_geo.tauMudet.PillarX,ship_geo.tauMudet.PillarY, ship_geo.tauMudet.PillarZ)
218 detectorList.append(taumuondetector)
219 if ship_geo.nuTauTargetDesign==3:
220 if hasattr(ship_geo.tauMudet, "deltax"): #now replaced with veto taggers
221 taumuondetector.SetRpcDimDifferences(ship_geo.tauMudet.deltax, ship_geo.tauMudet.deltay)
222 if ship_geo.nuTauTargetDesign<3:
223 taumuondetector.SetReturnYokeDimensions(ship_geo.tauMudet.XRyoke,ship_geo.tauMudet.YRyoke, ship_geo.tauMudet.ZRyoke)
224 taumuondetector.SetSmallerYokeDimensions(ship_geo.tauMudet.XRyoke_s,ship_geo.tauMudet.YRyoke_s, ship_geo.tauMudet.ZRyoke_s)
225 taumuondetector.SetZDimensionArm(ship_geo.tauMudet.ZArm)
226 taumuondetector.SetGapDownstream(ship_geo.tauMudet.GapD)
227 taumuondetector.SetGapMiddle(ship_geo.tauMudet.GapM)
228 taumuondetector.SetMagneticField(ship_geo.tauMudet.B)
229 taumuondetector.SetCoilParameters(ship_geo.tauMudet.CoilH, ship_geo.tauMudet.CoilW, ship_geo.tauMudet.N, ship_geo.tauMudet.CoilG)
230
231 if ship_geo.nuTauTargetDesign==0 or ship_geo.nuTauTargetDesign==1 or ship_geo.nuTauTargetDesign==3:
232 EmuMagnet = ROOT.EmulsionMagnet("EmuMagnet",ship_geo.EmuMagnet.zC,"EmulsionMagnet")
233 EmuMagnet.SetDesign(ship_geo.EmuMagnet.Design)
234 EmuMagnet.SetGaps(ship_geo.EmuMagnet.GapUp, ship_geo.EmuMagnet.GapDown)
235 EmuMagnet.SetMagneticField(ship_geo.EmuMagnet.B)
236 EmuMagnet.SetConstantField(ship_geo.EmuMagnet.WithConstField)
237 EmuMagnet.SetMagnetSizes(ship_geo.EmuMagnet.X, ship_geo.EmuMagnet.Y, ship_geo.EmuMagnet.Z)
238 if ship_geo.nuTauTargetDesign==0 or ship_geo.nuTauTargetDesign==1:
239 EmuMagnet.SetCoilParameters(ship_geo.EmuMagnet.Radius, ship_geo.EmuMagnet.Height1, ship_geo.EmuMagnet.Height2, ship_geo.EmuMagnet.Distance)
240 if ship_geo.nuTauTargetDesign==3:
241 EmuMagnet.SetCoilParameters(ship_geo.EmuMagnet.CoilX,ship_geo.EmuMagnet.CoilY,ship_geo.EmuMagnet.Height1, ship_geo.EmuMagnet.Height2, ship_geo.EmuMagnet.Thickness)
242 EmuMagnet.SetCutDimensions(ship_geo.EmuMagnet.CutLength, ship_geo.EmuMagnet.CutHeight)
243 EmuMagnet.SetMagnetColumn(ship_geo.EmuMagnet.ColX, ship_geo.EmuMagnet.ColY, ship_geo.EmuMagnet.ColZ)
244 EmuMagnet.SetBaseDim(ship_geo.EmuMagnet.BaseX, ship_geo.EmuMagnet.BaseY, ship_geo.EmuMagnet.BaseZ)
245 EmuMagnet.SetPillarDimensions(ship_geo.EmuMagnet.PillarX, ship_geo.EmuMagnet.PillarY, ship_geo.EmuMagnet.PillarZ)
246 detectorList.append(EmuMagnet)
247 if ship_geo.nuTauTargetDesign==2:
248 EmuMagnet = ROOT.EmulsionMagnet()
249
250 NuTauTarget = ROOT.Target("NuTauTarget",ship_geo.NuTauTarget.Ydist,ROOT.kTRUE)
251 NuTauTarget.MakeNuTargetPassive(ship_geo.NuTauTarget.nuTargetPassive)
252 if hasattr(ship_geo.NuTauTarget,"SingleEmFilm"): #for backward compatibility
253 NuTauTarget.MergeTopBot(ship_geo.NuTauTarget.SingleEmFilm)
254 NuTauTarget.SetDetectorDesign(ship_geo.NuTauTarget.Design)
255 if ship_geo.nuTauTargetDesign!=3:
256 NuTauTarget.SetCenterZ(ship_geo.NuTauTarget.zC)
257 if ship_geo.nuTauTargetDesign==3:
258 NuTauTarget.SetCenterZ(ship_geo.EmuMagnet.zC) #now the centers of emumagnet and nutautarget are different (target does not include HPT)
259 NuTauTarget.SetNumberTargets(ship_geo.NuTauTarget.target)
260 NuTauTarget.SetHpTParam(ship_geo.tauHPT.nHPT, ship_geo.tauHPT.distHPT, ship_geo.tauHPT.DZ)
261 NuTauTarget.SetNumberBricks(ship_geo.NuTauTarget.col,ship_geo.NuTauTarget.row,ship_geo.NuTauTarget.wall)
262 NuTauTarget.SetDetectorDimension(ship_geo.NuTauTarget.xdim, ship_geo.NuTauTarget.ydim, ship_geo.NuTauTarget.zdim)
263 if hasattr(ship_geo.NuTauTarget,"WallXDim") and hasattr(ship_geo.NuTauTarget,"WallYDim") and hasattr(ship_geo.NuTauTarget,"WallZDim"):
264 NuTauTarget.SetTargetWallDimension(ship_geo.NuTauTarget.WallXDim, ship_geo.NuTauTarget.WallYDim, ship_geo.NuTauTarget.WallZDim)
265 NuTauTarget.SetEmulsionParam(ship_geo.NuTauTarget.EmTh, ship_geo.NuTauTarget.EmX, ship_geo.NuTauTarget.EmY, ship_geo.NuTauTarget.PBTh,ship_geo.NuTauTarget.EPlW, ship_geo.NuTauTarget.LeadTh, ship_geo.NuTauTarget.AllPW)

◆ getParameter()

shipDet_conf.getParameter (   x,
  ship_geo,
  latestShipGeo 
)

Definition at line 10 of file shipDet_conf.py.

10def getParameter(x,ship_geo,latestShipGeo):
11 lv = x.split('.')
12 last = lv[len(lv)-1]
13 top = ''
14 for l in range(len(lv)-1):
15 top += lv[l]
16 if l<len(lv)-2: top +='.'
17 a = getattr(ship_geo,top)
18 if hasattr(a,last): return getattr(a,last)
19# not in the list of recorded parameteres. probably added after
20# creation of file. Check newest geometry_config:
21 a = getattr(latestShipGeo,top)
22 return getattr(a,last)
23

◆ makeEcalGeoFile()

shipDet_conf.makeEcalGeoFile (   z,
  efile 
)

Definition at line 48 of file shipDet_conf.py.

48def makeEcalGeoFile(z,efile):
49 EcalZSize = 0
50 sz = efile+"z"+str(z)+".geo"
51 floc = os.environ["FAIRSHIP"]+"/geometry"
52 f_ecal = floc+"/"+efile
53 f_ecalz = floc+"/"+sz
54 f = open(f_ecal)
55 rewrite = True
56 if sz in os.listdir(floc):
57 test = os.popen("diff "+ f_ecal+ " "+ f_ecalz).read()
58 if str.count(test,'---')==1 and not test.find('Position')<0: rewrite = False # only different is z position
59 if rewrite: fn = open(f_ecalz,'w')
60 for l in f.readlines():
61 if rewrite:
62 if not l.find("ZPos")<0:
63 l ="ZPos="+str(z)+ " #Position of Ecal start [cm]\n"
64 fn.write(l)
65 if not l.find("EcalZSize")<0:
66 EcalZSize = float(l[len('EcalZSize')+1:].split('#')[0])
67 f.close()
68 if rewrite: fn.close()
69 return EcalZSize,sz

◆ posEcal()

shipDet_conf.posEcal (   z,
  efile 
)

Definition at line 70 of file shipDet_conf.py.

70def posEcal(z,efile):
71 EcalZSize,sz = makeEcalGeoFile(z,efile)
72 ecal = ROOT.ecal("Ecal", ROOT.kTRUE, sz)
73 return ecal,EcalZSize
74

◆ posHcal()

shipDet_conf.posHcal (   z,
  hfile,
  HcalOption 
)

Definition at line 24 of file shipDet_conf.py.

24def posHcal(z,hfile,HcalOption):
25 HcalZSize = 0
26 sz = hfile+"z"+str(z)+".geo"
27 floc = os.environ["FAIRSHIP"]+"/geometry"
28 f_hcal = floc+"/"+hfile
29 f_hcalz = floc+"/"+sz
30 f = open(f_hcal)
31 rewrite = True
32 if sz in os.listdir(floc):
33 test = os.popen("diff "+ f_hcal+ " "+ f_hcalz).read()
34 if str.count(test,'---')==1 and not test.find('Position')<0: rewrite = False # only different is z position
35 if rewrite: fn = open(f_hcalz,'w')
36 for l in f.readlines():
37 if rewrite:
38 if not l.find("ZPos")<0:
39 l ="ZPos="+str(z)+ " #Position of Hcal center [cm]\n"
40 fn.write(l)
41 if not l.find("HcalZSize")<0:
42 HcalZSize = float(l[len('HcalZSize')+1:].split('#')[0])
43 f.close()
44 if rewrite: fn.close()
45 if HcalOption==2: hcal = ROOT.hcal("Hcal", ROOT.kFALSE, sz)
46 else: hcal = ROOT.hcal("Hcal", ROOT.kTRUE, sz)
47 return hcal,HcalZSize

Variable Documentation

◆ DeltazFrame

shipDet_conf.DeltazFrame

Definition at line 326 of file shipDet_conf.py.

◆ detectorList

list shipDet_conf.detectorList = []

Definition at line 8 of file shipDet_conf.py.

◆ detElements

dict shipDet_conf.detElements = {}

Definition at line 474 of file shipDet_conf.py.

◆ ecal

shipDet_conf.ecal

Definition at line 379 of file shipDet_conf.py.

◆ EcalZSize

shipDet_conf.EcalZSize

Definition at line 379 of file shipDet_conf.py.

◆ exclusionList

list shipDet_conf.exclusionList = []

Definition at line 466 of file shipDet_conf.py.

◆ fMagField

shipDet_conf.fMagField

Definition at line 461 of file shipDet_conf.py.

◆ FrameLateralWidth

shipDet_conf.FrameLateralWidth

Definition at line 327 of file shipDet_conf.py.

◆ FrameMaterial

shipDet_conf.FrameMaterial

Definition at line 328 of file shipDet_conf.py.

◆ hcal

shipDet_conf.hcal

Definition at line 398 of file shipDet_conf.py.

◆ HcalZSize

shipDet_conf.HcalZSize

Definition at line 398 of file shipDet_conf.py.

◆ Muon

shipDet_conf.Muon = ROOT.muon("Muon", ROOT.kTRUE)

Definition at line 403 of file shipDet_conf.py.

◆ n_plates

shipDet_conf.n_plates

Definition at line 268 of file shipDet_conf.py.

◆ NuTauTT

shipDet_conf.NuTauTT = ROOT.TargetTracker("TargetTrackers", ship_geo.NuTauTT.TTX, ship_geo.NuTauTT.TTY, ship_geo.NuTauTT.TTZ, ROOT.kTRUE)

Definition at line 286 of file shipDet_conf.py.

◆ Preshower

shipDet_conf.Preshower = ROOT.preshower("Preshower", ROOT.kTRUE)

Definition at line 370 of file shipDet_conf.py.

◆ SplitCal

shipDet_conf.SplitCal = ROOT.splitcal("SplitCal", ROOT.kTRUE)

Definition at line 383 of file shipDet_conf.py.

◆ Strawtubes

shipDet_conf.Strawtubes = ROOT.strawtubes("Strawtubes", ROOT.kTRUE)

Definition at line 334 of file shipDet_conf.py.

◆ tauHpt

shipDet_conf.tauHpt = ROOT.Hpt("HighPrecisionTrackers",ship_geo.tauHPT.DX, ship_geo.tauHPT.DY, ship_geo.tauHPT.DZ, ROOT.kTRUE)

Definition at line 301 of file shipDet_conf.py.

◆ timeDet

shipDet_conf.timeDet = ROOT.TimeDet("TimeDet", ROOT.kTRUE)

Definition at line 451 of file shipDet_conf.py.

◆ upstreamTagger

shipDet_conf.upstreamTagger = ROOT.UpstreamTagger("UpstreamTagger", ROOT.kTRUE)

Definition at line 412 of file shipDet_conf.py.

◆ x

shipDet_conf.x = ship_geo.SplitCal

Definition at line 384 of file shipDet_conf.py.

◆ YLayerOffset

shipDet_conf.YLayerOffset

Definition at line 321 of file shipDet_conf.py.

◆ YPlaneOffset

shipDet_conf.YPlaneOffset

Definition at line 322 of file shipDet_conf.py.