def setUp(self):
with ConfigRegistry.register_config("bb") as c:
c.length = 10
c.width = 20
c.muShield = AttrDict(z=10)
with ConfigRegistry.register_config("cc", base="bb") as c:
c.height = 30
c.volume = c.length * c.height * c.width
def retrieveGitTags(o):
# record some basic information about version of software:
tmp = os.environ['FAIRSHIP']+'/.git/refs/remotes/origin/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairShip = AttrDict(origin=x)
tmp = os.environ['FAIRSHIP']+'/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairShip = AttrDict(local=x)
tmp = os.environ['SIMPATH']+'/../FairSoft/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairSoft = AttrDict(master=x)
tmp = os.environ['SIMPATH']+'/../FairSoft/.git/refs/heads/dev'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairSoft = AttrDict(dev=x)
tmp = os.environ['FAIRROOTPATH']+'/../FairRoot/.git/refs/heads/dev'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairRoot = AttrDict(dev=x)
tmp = os.environ['FAIRROOTPATH']+'/../FairRoot/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairRoot = AttrDict(master=x)
return o
def execute(f,o):
# record some basic information about version of software:
tmp = os.environ['FAIRSHIP']+'/.git/refs/remotes/origin/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairShip = AttrDict(origin=x)
tmp = os.environ['FAIRSHIP']+'/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairShip = AttrDict(local=x)
tmp = os.environ['SIMPATH']+'/../FairSoft/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairSoft = AttrDict(master=x)
tmp = os.environ['SIMPATH']+'/../FairSoft/.git/refs/heads/dev'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairSoft = AttrDict(dev=x)
tmp = os.environ['FAIRROOTPATH']+'/../FairRoot/.git/refs/heads/dev'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairRoot = AttrDict(dev=x)
tmp = os.environ['FAIRROOTPATH']+'/../FairRoot/.git/refs/heads/master'
if os.path.isfile(tmp):
x = subprocess.check_output(['more',tmp]).replace('\n','')
o.FairRoot = AttrDict(master=x)
fg = ROOT.TFile.Open(f,'update')
pkl=Pickler(fg)
pkl.dump(o,'ShipGeo')
fg.Close()
import shipunit as u
from ShipGeoConfig import AttrDict, ConfigRegistry
# the following params should be passed through 'ConfigRegistry.loadpy' method
# none for the moment
with ConfigRegistry.register_config("basic") as c:
c.MufluxSpectrometer = AttrDict(z=0 * u.cm)
# False = charm cross-section; True = muon flux measurement
c.MufluxSpectrometer.muflux = False
if "targetOpt" not in globals():
targetOpt = 18 # add extra 20cm of tungsten as per 13/06/2017
c.target = AttrDict(z0=0 * u.cm)
c.Bfield = AttrDict(z=0 * u.cm)
c.Bfield.max = 10. * u.kilogauss # 1.4361*u.kilogauss for SHiP
c.Bfield.y = 1.8 * u.m # dummy value
c.Bfield.x = 5.0 * u.m # dummy value
c.Bfield.z = 3.571 * u.m
#BOX (Brick!)
c.Box = AttrDict(z=0 * u.cm)
c.Box.BX = 13 * u.cm
c.Box.BY = 11 * u.cm
c.Box.BZ = 20 * u.cm
c.Box.zBox = 0 * u.cm
c.Box.EmTh = 0.0045 * u.cm
c.Box.EmX = 10 * u.cm #for the moment, replace the previous values for normal simulations
c.Box.EmY = 10 * u.cm
c.Box.PBTh = 0.0205 * u.cm
c.Box.MolybdenumTh = 0.3 * u.cm
def configure(run, ship_geo):
# ---- for backward compatibility ----
if not hasattr(ship_geo, "tankDesign"): ship_geo.tankDesign = 5
if not hasattr(ship_geo, "muShieldGeo"): ship_geo.muShieldGeo = None
if not hasattr(ship_geo.hcal, "File"): ship_geo.hcal.File = "hcal.geo"
if not hasattr(ship_geo.Bfield, 'x'): ship_geo.Bfield.x = 3. * u.m
if not hasattr(ship_geo, 'cave'):
ship_geo.cave = AttrDict(z=0 * u.cm)
ship_geo.cave.floorHeightMuonShield = 5 * u.m
ship_geo.cave.floorHeightTankA = 4.5 * u.m
ship_geo.cave.floorHeightTankB = 2. * u.m
if not hasattr(ship_geo, 'NuTauTT'):
ship_geo.NuTauTT = AttrDict(z=0 * u.cm)
if not hasattr(ship_geo.NuTauTT, 'design'): ship_geo.NuTauTT.design = 0
if not hasattr(ship_geo, 'EcalOption'): ship_geo.EcalOption = 1
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)
# -----Create media-------------------------------------------------
run.SetMaterials("media.geo") # Materials
# ------------------------------------------------------------------------
# -----Create geometry----------------------------------------------
cave = ROOT.ShipCave("CAVE")
if ship_geo.tankDesign < 5: cave.SetGeometryFileName("cave.geo")
else: cave.SetGeometryFileName("caveWithAir.geo")
detectorList.append(cave)
if ship_geo.muShieldDesign in [
6, 7, 8, 9
]: # magnetized hadron absorber defined in ShipMuonShield
TargetStation = ROOT.ShipTargetStation("TargetStation",
ship_geo.target.length,
ship_geo.target.z,
ship_geo.targetOpt,
ship_geo.target.sl)
else:
TargetStation = ROOT.ShipTargetStation(
"TargetStation", ship_geo.target.length,
ship_geo.hadronAbsorber.length, ship_geo.target.z,
ship_geo.hadronAbsorber.z, ship_geo.targetOpt, ship_geo.target.sl)
if ship_geo.targetOpt > 10:
slices_length = ROOT.std.vector('float')()
slices_material = ROOT.std.vector('std::string')()
for i in range(1, ship_geo.targetOpt + 1):
slices_length.push_back(eval("ship_geo.target.L" + str(i)))
slices_material.push_back(eval("ship_geo.target.M" + str(i)))
TargetStation.SetLayerPosMat(ship_geo.target.xy, slices_length,
slices_material)
detectorList.append(TargetStation)
if ship_geo.muShieldDesign == 1:
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.length,\
ship_geo.muShield.LE)
elif ship_geo.muShieldDesign == 2:
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.dZ1,\
ship_geo.muShield.dZ2,ship_geo.muShield.dZ3,ship_geo.muShield.dZ4,ship_geo.muShield.dZ5,ship_geo.muShield.dZ6,ship_geo.muShield.LE)
elif ship_geo.muShieldDesign in [3, 4, 5, 6, 7, 9]:
if not hasattr(ship_geo.muShield, "Field"):
MuonShield = ROOT.ShipMuonShield(
"MuonShield", ship_geo.muShieldDesign, "ShipMuonShield",
ship_geo.muShield.z, ship_geo.muShield.dZ0,
ship_geo.muShield.dZ1, ship_geo.muShield.dZ2,
ship_geo.muShield.dZ3, ship_geo.muShield.dZ4,
ship_geo.muShield.dZ5, ship_geo.muShield.dZ6,
ship_geo.muShield.dZ7, ship_geo.muShield.dZ8,
ship_geo.muShield.dXgap, ship_geo.muShield.LE,
ship_geo.Yheight * 4. / 10.,
ship_geo.cave.floorHeightMuonShield)
else:
MuonShield = ROOT.ShipMuonShield(
"MuonShield", ship_geo.muShieldDesign, "ShipMuonShield",
ship_geo.muShield.z, ship_geo.muShield.dZ0,
ship_geo.muShield.dZ1, ship_geo.muShield.dZ2,
ship_geo.muShield.dZ3, ship_geo.muShield.dZ4,
ship_geo.muShield.dZ5, ship_geo.muShield.dZ6,
ship_geo.muShield.dZ7, ship_geo.muShield.dZ8,
ship_geo.muShield.dXgap, ship_geo.muShield.LE,
ship_geo.Yheight * 4. / 10.,
ship_geo.cave.floorHeightMuonShield, ship_geo.muShield.Field)
elif ship_geo.muShieldDesign == 8:
MuonShield = ROOT.ShipMuonShield(ship_geo.muShieldGeo)
detectorList.append(MuonShield)
if not hasattr(ship_geo, "magnetDesign"):
# backward compatibility
magnet_design = 2
if ship_geo.tankDesign == 5: magnet_design = 3
if ship_geo.tankDesign == 6: magnet_design = 4
ship_geo.magnetDesign = magnet_design
ship_geo.Bfield.YokeWidth = 200. * u.cm
ship_geo.Bfield.YokeDepth = 200. * u.cm
ship_geo.Bfield.CoilThick = 25. * u.cm
# sanity check, 2018 layout ship_geo.tankDesign == 6 has to be together with ship_geo.nuTauTargetDesign == 3
if (ship_geo.tankDesign == 6 and ship_geo.nuTauTargetDesign != 3) or (
ship_geo.tankDesign != 6 and ship_geo.nuTauTargetDesign == 3):
print "version of tankDesign and nuTauTargetDesign are not compatible, should be 6 and 3, it is ", ship_geo.tankDesign, ship_geo.nuTauTargetDesign
exit()
if ship_geo.strawDesign > 1:
if ship_geo.magnetDesign > 3:
B = ship_geo.Bfield
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)
# xaperture, yaperture
else:
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)
else:
magnet = ROOT.ShipMagnet("Magnet", "SHiP Magnet", ship_geo.Bfield.z)
detectorList.append(magnet)
Veto = ROOT.veto("Veto", ROOT.kTRUE) # vacuum tank
Veto.SetLiquidVeto(1) # liquid scintillator
Veto.SetPlasticVeto(1) # plastic scintillator
Veto.SetZpositions(ship_geo.vetoStation.z, ship_geo.TrackStation1.z, ship_geo.TrackStation2.z, \
ship_geo.TrackStation3.z, ship_geo.TrackStation4.z,ship_geo.tankDesign)
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)
Veto.SetTublengths(ship_geo.chambers.Tub1length,ship_geo.chambers.Tub2length,ship_geo.chambers.Tub3length, \
ship_geo.chambers.Tub4length,ship_geo.chambers.Tub5length,ship_geo.chambers.Tub6length)
Veto.SetB(ship_geo.Yheight / 2.)
Veto.SetFloorHeight(ship_geo.cave.floorHeightTankA,
ship_geo.cave.floorHeightTankB)
if ship_geo.tankDesign > 4:
dzX = ship_geo.zFocusX + ship_geo.target.z0
x1 = ship_geo.xMax / (ship_geo.Chamber1.z -
ship_geo.chambers.Tub1length -
dzX) * (ship_geo.TrackStation4.z - dzX)
dzY = ship_geo.zFocusY + ship_geo.target.z0
y1 = ship_geo.Yheight / (ship_geo.Chamber1.z -
ship_geo.chambers.Tub1length -
dzY) * (ship_geo.TrackStation4.z - dzY)
Veto.SetXYstart(x1, dzX, y1, dzY)
Veto.SetVesselStructure(ship_geo.Veto.innerSupport,ship_geo.Veto.sensitiveThickness,ship_geo.Veto.outerSupport,\
ship_geo.Veto.innerSupportMed,ship_geo.Veto.lidThickness,ship_geo.Veto.sensitiveMed,\
ship_geo.Veto.outerSupportMed,ship_geo.Veto.decayMed,\
ship_geo.Veto.rib,ship_geo.Veto.ribMed)
detectorList.append(Veto)
if hasattr(ship_geo, 'tauMudet'): # don't support old designs
if ship_geo.muShieldDesign not in [2, 3, 4] and hasattr(
ship_geo.tauMudet, 'Xtot'):
taumuondetector = ROOT.NuTauMudet("NuTauMudet",
ship_geo.tauMudet.zMudetC,
ROOT.kTRUE)
taumuondetector.SetDesign(ship_geo.nuTauTargetDesign)
taumuondetector.SetTotDimensions(ship_geo.tauMudet.Xtot,
ship_geo.tauMudet.Ytot,
ship_geo.tauMudet.Ztot)
taumuondetector.SetFeDimensions(ship_geo.tauMudet.XFe,
ship_geo.tauMudet.YFe,
ship_geo.tauMudet.ZFe)
taumuondetector.SetRpcDimensions(ship_geo.tauMudet.XRpc,
ship_geo.tauMudet.YRpc,
ship_geo.tauMudet.ZRpc)
taumuondetector.SetRpcGasDimensions(ship_geo.tauMudet.XGas,
ship_geo.tauMudet.YGas,
ship_geo.tauMudet.ZGas)
taumuondetector.SetRpcStripDimensions(ship_geo.tauMudet.XStrip,
ship_geo.tauMudet.YStrip,
ship_geo.tauMudet.ZStrip)
taumuondetector.SetRpcElectrodeDimensions(ship_geo.tauMudet.XEle,
ship_geo.tauMudet.YEle,
ship_geo.tauMudet.ZEle)
taumuondetector.SetRpcPETDimensions(ship_geo.tauMudet.XPet,
ship_geo.tauMudet.YPet,
ship_geo.tauMudet.ZPet)
taumuondetector.SetNFeInArm(ship_geo.tauMudet.NFe)
taumuondetector.SetNRpcInArm(ship_geo.tauMudet.NRpc)
taumuondetector.SetPillarDimensions(ship_geo.tauMudet.PillarX,
ship_geo.tauMudet.PillarY,
ship_geo.tauMudet.PillarZ)
detectorList.append(taumuondetector)
if ship_geo.nuTauTargetDesign == 3:
taumuondetector.SetRpcDimDifferences(ship_geo.tauMudet.deltax,
ship_geo.tauMudet.deltay)
if ship_geo.nuTauTargetDesign < 3:
taumuondetector.SetReturnYokeDimensions(
ship_geo.tauMudet.XRyoke, ship_geo.tauMudet.YRyoke,
ship_geo.tauMudet.ZRyoke)
taumuondetector.SetSmallerYokeDimensions(
ship_geo.tauMudet.XRyoke_s, ship_geo.tauMudet.YRyoke_s,
ship_geo.tauMudet.ZRyoke_s)
taumuondetector.SetZDimensionArm(ship_geo.tauMudet.ZArm)
taumuondetector.SetGapDownstream(ship_geo.tauMudet.GapD)
taumuondetector.SetGapMiddle(ship_geo.tauMudet.GapM)
taumuondetector.SetMagneticField(ship_geo.tauMudet.B)
taumuondetector.SetCoilParameters(ship_geo.tauMudet.CoilH,
ship_geo.tauMudet.CoilW,
ship_geo.tauMudet.N,
ship_geo.tauMudet.CoilG)
if ship_geo.nuTauTargetDesign == 0 or ship_geo.nuTauTargetDesign == 1 or ship_geo.nuTauTargetDesign == 3:
EmuMagnet = ROOT.EmulsionMagnet("EmuMagnet",
ship_geo.EmuMagnet.zC,
"EmulsionMagnet")
EmuMagnet.SetDesign(ship_geo.EmuMagnet.Design)
EmuMagnet.SetGaps(ship_geo.EmuMagnet.GapUp,
ship_geo.EmuMagnet.GapDown)
EmuMagnet.SetMagneticField(ship_geo.EmuMagnet.B)
EmuMagnet.SetMagnetSizes(ship_geo.EmuMagnet.X,
ship_geo.EmuMagnet.Y,
ship_geo.EmuMagnet.Z)
if ship_geo.nuTauTargetDesign == 0 or ship_geo.nuTauTargetDesign == 1:
EmuMagnet.SetCoilParameters(ship_geo.EmuMagnet.Radius,
ship_geo.EmuMagnet.Height1,
ship_geo.EmuMagnet.Height2,
ship_geo.EmuMagnet.Distance)
if ship_geo.nuTauTargetDesign == 3:
EmuMagnet.SetCoilParameters(ship_geo.EmuMagnet.CoilX,
ship_geo.EmuMagnet.CoilY,
ship_geo.EmuMagnet.Height1,
ship_geo.EmuMagnet.Height2,
ship_geo.EmuMagnet.Thickness)
EmuMagnet.SetCutDimensions(ship_geo.EmuMagnet.CutLength,
ship_geo.EmuMagnet.CutHeight)
EmuMagnet.SetMagnetColumn(ship_geo.EmuMagnet.ColX,
ship_geo.EmuMagnet.ColY,
ship_geo.EmuMagnet.ColZ)
EmuMagnet.SetBaseDim(ship_geo.EmuMagnet.BaseX,
ship_geo.EmuMagnet.BaseY,
ship_geo.EmuMagnet.BaseZ)
EmuMagnet.SetPillarDimensions(ship_geo.EmuMagnet.PillarX,
ship_geo.EmuMagnet.PillarY,
ship_geo.EmuMagnet.PillarZ)
detectorList.append(EmuMagnet)
if ship_geo.nuTauTargetDesign == 2:
EmuMagnet = ROOT.EmulsionMagnet()
NuTauTarget = ROOT.Target("NuTauTarget",
ship_geo.NuTauTarget.Ydist, ROOT.kTRUE)
NuTauTarget.MakeNuTargetPassive(
ship_geo.NuTauTarget.nuTargetPassive)
NuTauTarget.MergeTopBot(ship_geo.NuTauTarget.SingleEmFilm)
NuTauTarget.SetDetectorDesign(ship_geo.NuTauTarget.Design)
if ship_geo.nuTauTargetDesign != 3:
NuTauTarget.SetCenterZ(ship_geo.NuTauTarget.zC)
if ship_geo.nuTauTargetDesign == 3:
NuTauTarget.SetCenterZ(
ship_geo.EmuMagnet.zC
) #now the centers of emumagnet and nutautarget are different (target does not include HPT)
NuTauTarget.SetNumberTargets(ship_geo.NuTauTarget.target)
NuTauTarget.SetHpTParam(ship_geo.tauHPT.nHPT,
ship_geo.tauHPT.distHPT,
ship_geo.tauHPT.DZ)
NuTauTarget.SetNumberBricks(ship_geo.NuTauTarget.col,
ship_geo.NuTauTarget.row,
ship_geo.NuTauTarget.wall)
NuTauTarget.SetDetectorDimension(ship_geo.NuTauTarget.xdim,
ship_geo.NuTauTarget.ydim,
ship_geo.NuTauTarget.zdim)
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)
NuTauTarget.SetBrickParam(ship_geo.NuTauTarget.BrX,
ship_geo.NuTauTarget.BrY,
ship_geo.NuTauTarget.BrZ,
ship_geo.NuTauTarget.BrPackX,
ship_geo.NuTauTarget.BrPackY,
ship_geo.NuTauTarget.BrPackZ)
NuTauTarget.SetCESParam(ship_geo.NuTauTarget.RohG,
ship_geo.NuTauTarget.LayerCESW,
ship_geo.NuTauTarget.CESW,
ship_geo.NuTauTarget.CESPack)
NuTauTarget.SetCellParam(ship_geo.NuTauTarget.CellW)
if ship_geo.nuTauTargetDesign == 0 or ship_geo.nuTauTargetDesign == 1:
NuTauTarget.SetMagnetHeight(ship_geo.EmuMagnet.Y)
NuTauTarget.SetColumnHeight(ship_geo.EmuMagnet.ColY)
NuTauTarget.SetBaseHeight(ship_geo.EmuMagnet.BaseY)
NuTauTarget.SetCoilUpHeight(ship_geo.EmuMagnet.Height1)
NuTauTarget.SetCoilDownHeight(ship_geo.EmuMagnet.Height2)
if ship_geo.nuTauTargetDesign != 2:
NuTauTarget.SetMagneticField(ship_geo.EmuMagnet.B)
if ship_geo.nuTauTargetDesign == 2:
NuTauTarget.SetPillarDimension(ship_geo.NuTauTarget.PillarX,
ship_geo.NuTauTarget.PillarY,
ship_geo.NuTauTarget.PillarZ)
NuTauTarget.SetBaseDimension(ship_geo.NuTauTarget.BaseX,
ship_geo.NuTauTarget.BaseY,
ship_geo.NuTauTarget.BaseZ)
NuTauTT = ROOT.TargetTracker("TargetTrackers", ROOT.kTRUE)
NuTauTT.SetDesign(ship_geo.NuTauTT.design)
NuTauTT.SetTargetTrackerParam(ship_geo.NuTauTT.TTX,
ship_geo.NuTauTT.TTY,
ship_geo.NuTauTT.TTZ)
NuTauTT.SetBrickParam(ship_geo.NuTauTarget.CellW)
NuTauTT.SetTotZDimension(ship_geo.NuTauTarget.zdim)
NuTauTT.SetNumberTT(ship_geo.NuTauTT.n)
#method of nutau target that must be called after TT parameter definition
NuTauTarget.SetTTzdimension(ship_geo.NuTauTT.TTZ)
detectorList.append(NuTauTarget)
detectorList.append(NuTauTT)
tauHpt = ROOT.Hpt("HighPrecisionTrackers", ship_geo.tauHPT.DX,
ship_geo.tauHPT.DY, ship_geo.tauHPT.DZ,
ROOT.kTRUE)
tauHpt.SetZsize(ship_geo.tauMudet.Ztot)
tauHpt.SetDesign(ship_geo.NuTauTarget.Design)
if ship_geo.nuTauTargetDesign < 3:
tauHpt.SetConcreteBaseDim(ship_geo.tauHPT.ConcreteX,
ship_geo.tauHPT.ConcreteY,
ship_geo.tauHPT.ConcreteZ)
if ship_geo.nuTauTargetDesign == 3:
tauHpt.SetHPTNumber(ship_geo.tauHPT.nHPT)
tauHpt.SetDistanceHPTs(ship_geo.tauHPT.distHPT)
tauHpt.SetSurroundingDetHeight(ship_geo.tauHPT.SRDY)
tauHpt.GetMagnetGeometry(ship_geo.EmuMagnet.zC,
ship_geo.EmuMagnet.Y)
tauHpt.GetNumberofTargets(ship_geo.NuTauTarget.target)
detectorList.append(tauHpt)
# for backward compatibility
if not hasattr(ship_geo.strawtubes, "YPlaneOffset"):
ship_geo.strawtubes.YLayerOffset = ship_geo.strawtubes.StrawPitch / 2.
ship_geo.strawtubes.YPlaneOffset = ship_geo.strawtubes.StrawPitch / 4.
if ship_geo.strawDesign > 1:
# for backward compatibility
if ship_geo.strawDesign == 10 and not hasattr(ship_geo.strawtubes,
"DeltazFrame"):
ship_geo.strawtubes.DeltazFrame = 2.5 * u.cm
ship_geo.strawtubes.FrameLateralWidth = 1.2 * u.m
ship_geo.strawtubes.FrameMaterial = "steel"
elif not hasattr(ship_geo.strawtubes, "DeltazFrame"):
ship_geo.strawtubes.DeltazFrame = 10. * u.cm
ship_geo.strawtubes.FrameLateralWidth = 1. * u.cm
ship_geo.strawtubes.FrameMaterial = "aluminium"
Strawtubes = ROOT.strawtubes("Strawtubes", ROOT.kTRUE)
Strawtubes.SetZpositions(ship_geo.vetoStation.z,
ship_geo.TrackStation1.z,
ship_geo.TrackStation2.z,
ship_geo.TrackStation3.z,
ship_geo.TrackStation4.z)
Strawtubes.SetDeltazFrame(ship_geo.strawtubes.DeltazFrame)
Strawtubes.SetFrameLateralWidth(ship_geo.strawtubes.FrameLateralWidth)
Strawtubes.SetFrameMaterial(ship_geo.strawtubes.FrameMaterial)
Strawtubes.SetDeltazView(ship_geo.strawtubes.DeltazView)
Strawtubes.SetInnerStrawDiameter(
ship_geo.strawtubes.InnerStrawDiameter)
Strawtubes.SetOuterStrawDiameter(
ship_geo.strawtubes.OuterStrawDiameter)
Strawtubes.SetStrawPitch(ship_geo.strawtubes.StrawPitch,
ship_geo.strawtubes.YLayerOffset,
ship_geo.strawtubes.YPlaneOffset)
Strawtubes.SetDeltazLayer(ship_geo.strawtubes.DeltazLayer)
Strawtubes.SetDeltazPlane(ship_geo.strawtubes.DeltazPlane)
Strawtubes.SetStrawsPerLayer(ship_geo.strawtubes.StrawsPerLayer)
Strawtubes.SetStereoAngle(ship_geo.strawtubes.ViewAngle)
Strawtubes.SetWireThickness(ship_geo.strawtubes.WireThickness)
Strawtubes.SetVacBox_x(ship_geo.strawtubes.VacBox_x)
Strawtubes.SetVacBox_y(ship_geo.strawtubes.VacBox_y)
Strawtubes.SetStrawLength(ship_geo.strawtubes.StrawLength)
if hasattr(ship_geo.strawtubes, "StrawLengthVeto"):
Strawtubes.SetStrawLengthVeto(ship_geo.strawtubes.StrawLengthVeto)
Strawtubes.SetStrawLength12(ship_geo.strawtubes.StrawLength12)
Strawtubes.SetVetoYDim(ship_geo.strawtubes.vetoydim)
Strawtubes.SetTr12YDim(ship_geo.strawtubes.tr12ydim)
Strawtubes.SetTr34YDim(ship_geo.strawtubes.tr34ydim)
else:
Strawtubes.SetStrawLengthVeto(ship_geo.strawtubes.StrawLength)
Strawtubes.SetStrawLength12(ship_geo.strawtubes.StrawLength)
Strawtubes.SetVetoYDim(ship_geo.Yheight / 2.)
Strawtubes.SetTr12YDim(ship_geo.Yheight / 2.)
Strawtubes.SetTr34YDim(ship_geo.Yheight / 2.)
# for the digitizing step
Strawtubes.SetStrawResolution(
getParameter("strawtubes.v_drift", ship_geo, latestShipGeo),
getParameter("strawtubes.sigma_spatial", ship_geo, latestShipGeo))
detectorList.append(Strawtubes)
if ship_geo.EcalOption == 1: # shashlik design TP
if ship_geo.preshowerOption > 0:
Preshower = ROOT.preshower("Preshower", ROOT.kTRUE)
Preshower.SetZStationPosition2(ship_geo.PreshowerStation0.z,
ship_geo.PreshowerStation1.z)
Preshower.SetZFilterPosition2(ship_geo.PreshowerFilter0.z,
ship_geo.PreshowerFilter1.z)
Preshower.SetXMax(ship_geo.Preshower.XMax)
Preshower.SetYMax(ship_geo.Preshower.YMax)
Preshower.SetActiveThickness(ship_geo.Preshower.ActiveThickness)
Preshower.SetFilterThickness2(ship_geo.Preshower.FilterThickness0,
ship_geo.Preshower.FilterThickness1)
detectorList.append(Preshower)
ecal, EcalZSize = posEcal(ship_geo.ecal.z, ship_geo.ecal.File)
detectorList.append(ecal)
if ship_geo.EcalOption == 2: # splitCal with pointing information
SplitCal = ROOT.splitcal("SplitCal", ROOT.kTRUE)
x = ship_geo.SplitCal
SplitCal.SetThickness(x.ActiveECALThickness, x.ActiveHCALThickness,
x.FilterECALThickness,
x.FilterECALThickness_first,
x.FilterHCALThickness,
x.ActiveECAL_gas_Thickness)
SplitCal.SetMaterial(x.ActiveECALMaterial, x.ActiveHCALMaterial,
x.FilterECALMaterial, x.FilterHCALMaterial)
SplitCal.SetNSamplings(x.nECALSamplings, x.nHCALSamplings,
x.ActiveHCAL)
SplitCal.SetZStart(x.ZStart)
SplitCal.SetXMax(x.XMax)
SplitCal.SetYMax(x.YMax)
SplitCal.SetEmpty(x.Empty, x.BigGap, x.ActiveECAL_gas_gap,
x.first_precision_layer, x.second_precision_layer,
x.third_precision_layer, x.num_precision_layers)
SplitCal.SetNModules(x.NModulesInX, x.NModulesInY)
SplitCal.SetNStrips(x.NStripsPerModule)
SplitCal.SetStripSize(x.StripHalfWidth, x.StripHalfLength)
detectorList.append(SplitCal)
if not ship_geo.HcalOption < 0:
hcal, HcalZSize = posHcal(ship_geo.hcal.z, ship_geo.hcal.File,
ship_geo.HcalOption)
if ship_geo.HcalOption != 2 and abs(ship_geo.hcal.hcalSpace -
HcalZSize) > 10 * u.cm:
print 'mismatch between hcalsize in geo file and python configuration'
print ship_geo.hcal.hcalSpace - HcalZSize, ship_geo.hcal.hcalSpace, HcalZSize
detectorList.append(hcal)
Muon = ROOT.muon("Muon", ROOT.kTRUE)
Muon.SetZStationPositions(ship_geo.MuonStation0.z, ship_geo.MuonStation1.z,
ship_geo.MuonStation2.z, ship_geo.MuonStation3.z)
Muon.SetZFilterPositions(ship_geo.MuonFilter0.z, ship_geo.MuonFilter1.z,
ship_geo.MuonFilter2.z)
Muon.SetXMax(ship_geo.Muon.XMax)
Muon.SetYMax(ship_geo.Muon.YMax)
Muon.SetActiveThickness(ship_geo.Muon.ActiveThickness)
Muon.SetFilterThickness(ship_geo.Muon.FilterThickness)
detectorList.append(Muon)
timeDet = ROOT.TimeDet("TimeDet", ROOT.kTRUE)
timeDet.SetZposition(ship_geo.TimeDet.z)
timeDet.SetBarZspacing(ship_geo.TimeDet.dzBarRow,
ship_geo.TimeDet.dzBarCol)
timeDet.SetBarZ(ship_geo.TimeDet.zBar)
timeDet.SetSizeX(2 * ship_geo.TimeDet.DX)
timeDet.SetSizeY(2 * ship_geo.TimeDet.DY)
detectorList.append(timeDet)
#----- Magnetic field -------------------------------------------
if not hasattr(ship_geo.Bfield, "fieldMap"):
if ship_geo.strawDesign == 4 or ship_geo.strawDesign == 10:
fMagField = ROOT.ShipBellField("wilfried", ship_geo.Bfield.max,
ship_geo.Bfield.z, 2,
ship_geo.Yheight / 2. * u.m)
else:
fMagField = ROOT.ShipBellField("wilfried", ship_geo.Bfield.max,
ship_geo.Bfield.z, 1,
ship_geo.Yheight / 2. * u.m)
if ship_geo.muShieldDesign == 6:
fMagField.IncludeTarget(ship_geo.target.xy, ship_geo.target.z0,
ship_geo.target.length)
run.SetField(fMagField)
#
exclusionList = []
#exclusionList = ["Muon","Ecal","Hcal","Strawtubes","TargetTrackers","NuTauTarget","HighPrecisionTrackers",\
# "Veto","Magnet","MuonShield","TargetStation","NuTauMudet","EmuMagnet", "TimeDet"]
for x in detectorList:
if x.GetName() in exclusionList: continue
run.AddModule(x)
# return list of detector elements
detElements = {}
for x in run.GetListOfModules():
detElements[x.GetName()] = x
return detElements
c.Yheight = Yheight * u.m
# decision by the SP
totalLength = 2.5 * c.Yheight + 35 * u.m
extraVesselLength = totalLength - 50 * u.m
windowBulge = 1 * u.m
if tankDesign > 5: windowBulge = 25 * u.cm
#
magnet_design = 2
if tankDesign == 5: magnet_design = 3
if tankDesign == 6: magnet_design = 4
#
c.strawDesign = strawDesign
c.tankDesign = tankDesign
c.magnetDesign = magnet_design
# cave parameters
c.cave = AttrDict(z=0 * u.cm)
c.cave.floorHeightMuonShield = 5 * u.m
c.cave.floorHeightTankA = 4.2 * u.m
if strawDesign == 10:
c.cave.floorHeightMuonShield = c.cave.floorHeightTankA # avoid the gap, for 2018 geometry
c.cave.floorHeightTankB = 2 * u.m
#
#neutrino detector
c.nuTauTargetDesign = nuTauTargetDesign
c.chambers = AttrDict(z=0 * u.cm)
magnetIncrease = 100. * u.cm
# make z coordinates for the decay volume and tracking stations relative to T4z
# eventually, the only parameter which needs to be changed when the active shielding lenght changes.
z4 = 2438. * u.cm + magnetIncrease + extraVesselLength
if strawDesign != 4 and strawDesign != 10:
def configure(run, ship_geo):
# ---- for backward compatibility ----
if not hasattr(ship_geo, "tankDesign"): ship_geo.tankDesign = 4
if not hasattr(ship_geo.hcal, "File"): ship_geo.hcal.File = "hcal.geo"
if not hasattr(ship_geo.Bfield, 'x'): ship_geo.Bfield.x = 3. * u.m
if not hasattr(ship_geo, 'cave'):
ship_geo.cave = AttrDict(z=0 * u.cm)
ship_geo.cave.floorHeightMuonShield = 5 * u.m
ship_geo.cave.floorHeightTankA = 4.5 * u.m
ship_geo.cave.floorHeightTankB = 2. * u.m
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)
# -----Create media-------------------------------------------------
run.SetMaterials("media.geo") # Materials
# ------------------------------------------------------------------------
# -----Create geometry----------------------------------------------
cave = ROOT.ShipCave("CAVE")
if ship_geo.tankDesign < 5: cave.SetGeometryFileName("cave.geo")
else: cave.SetGeometryFileName("caveWithAir.geo")
detectorList.append(cave)
if ship_geo.muShieldDesign == 6 or ship_geo.muShieldDesign == 7: # magnetized hadron absorber defined in ShipMuonShield
TargetStation = ROOT.ShipTargetStation("TargetStation",
ship_geo.target.length,
ship_geo.target.z,
ship_geo.targetOpt,
ship_geo.target.sl)
else:
TargetStation = ROOT.ShipTargetStation(
"TargetStation", ship_geo.target.length,
ship_geo.hadronAbsorber.length, ship_geo.target.z,
ship_geo.hadronAbsorber.z, ship_geo.targetOpt, ship_geo.target.sl)
if ship_geo.targetOpt > 10:
slices_length = ROOT.std.vector('float')()
slices_material = ROOT.std.vector('std::string')()
for i in range(1, ship_geo.targetOpt + 1):
slices_length.push_back(eval("ship_geo.target.L" + str(i)))
slices_material.push_back(eval("ship_geo.target.M" + str(i)))
TargetStation.SetLayerPosMat(ship_geo.target.xy, slices_length,
slices_material)
detectorList.append(TargetStation)
if ship_geo.muShieldDesign == 1:
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.length,\
ship_geo.muShield.LE)
elif ship_geo.muShieldDesign == 2:
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.dZ1,\
ship_geo.muShield.dZ2,ship_geo.muShield.dZ3,ship_geo.muShield.dZ4,ship_geo.muShield.dZ5,ship_geo.muShield.dZ6,ship_geo.muShield.LE)
elif ship_geo.muShieldDesign == 3 or ship_geo.muShieldDesign == 4 or ship_geo.muShieldDesign == 5 or ship_geo.muShieldDesign == 6 or ship_geo.muShieldDesign == 7:
if not hasattr(ship_geo.muShield, "Field"):
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.dZ1,\
ship_geo.muShield.dZ2,ship_geo.muShield.dZ3,ship_geo.muShield.dZ4,ship_geo.muShield.dZ5,ship_geo.muShield.dZ6,\
ship_geo.muShield.dZ7,ship_geo.muShield.dZ8,ship_geo.muShield.dXgap,ship_geo.muShield.LE,ship_geo.Yheight*4./10., ship_geo.cave.floorHeightMuonShield)
else:
MuonShield = ROOT.ShipMuonShield("MuonShield",ship_geo.muShieldDesign,"ShipMuonShield",ship_geo.muShield.z,ship_geo.muShield.dZ0,ship_geo.muShield.dZ1,\
ship_geo.muShield.dZ2,ship_geo.muShield.dZ3,ship_geo.muShield.dZ4,ship_geo.muShield.dZ5,ship_geo.muShield.dZ6,\
ship_geo.muShield.dZ7,ship_geo.muShield.dZ8,ship_geo.muShield.dXgap,ship_geo.muShield.LE,ship_geo.Yheight*4./10.,\
ship_geo.cave.floorHeightMuonShield,ship_geo.muShield.Field)
detectorList.append(MuonShield)
magnet_design = 2
if ship_geo.tankDesign == 5: magnet_design = 3
if ship_geo.strawDesign > 1:
magnet = ROOT.ShipMagnet("Magnet", "SHiP Magnet", ship_geo.Bfield.z,
magnet_design, ship_geo.Bfield.x,
ship_geo.Bfield.y,
ship_geo.cave.floorHeightTankB)
else:
magnet = ROOT.ShipMagnet("Magnet", "SHiP Magnet", ship_geo.Bfield.z)
detectorList.append(magnet)
Veto = ROOT.veto("Veto", ROOT.kTRUE) # vacuum tank
Veto.SetLiquidVeto(1) # liquid scintillator
Veto.SetPlasticVeto(1) # plastic scintillator
Veto.SetZpositions(ship_geo.vetoStation.z, ship_geo.TrackStation1.z, ship_geo.TrackStation2.z, \
ship_geo.TrackStation3.z, ship_geo.TrackStation4.z,ship_geo.tankDesign)
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)
Veto.SetTublengths(ship_geo.chambers.Tub1length,ship_geo.chambers.Tub2length,ship_geo.chambers.Tub3length, \
ship_geo.chambers.Tub4length,ship_geo.chambers.Tub5length,ship_geo.chambers.Tub6length)
Veto.SetB(ship_geo.Yheight / 2.)
Veto.SetFloorHeight(ship_geo.cave.floorHeightTankA,
ship_geo.cave.floorHeightTankB)
if ship_geo.tankDesign == 5:
dzX = ship_geo.zFocusX + ship_geo.target.z0
x1 = ship_geo.xMax / (ship_geo.Chamber1.z -
ship_geo.chambers.Tub1length -
dzX) * (ship_geo.TrackStation4.z - dzX)
dzY = ship_geo.zFocusY + ship_geo.target.z0
y1 = ship_geo.Yheight / (ship_geo.Chamber1.z -
ship_geo.chambers.Tub1length -
dzY) * (ship_geo.TrackStation4.z - dzY)
Veto.SetXYstart(x1, dzX, y1, dzY)
Veto.SetVesselStructure(ship_geo.Veto.innerSupport,ship_geo.Veto.sensitiveThickness,ship_geo.Veto.outerSupport,\
ship_geo.Veto.innerSupportMed,ship_geo.Veto.lidThickness,ship_geo.Veto.sensitiveMed,\
ship_geo.Veto.outerSupportMed,ship_geo.Veto.decayMed,\
ship_geo.Veto.rib,ship_geo.Veto.ribMed)
detectorList.append(Veto)
if ship_geo.muShieldDesign not in [2, 3, 4] and hasattr(
ship_geo.tauMS, 'Xtot'):
taumagneticspectrometer = ROOT.MagneticSpectrometer(
"MagneticSpectrometer", ship_geo.tauMS.zMSC, ROOT.kTRUE)
taumagneticspectrometer.SetTotDimensions(ship_geo.tauMS.Xtot,
ship_geo.tauMS.Ytot,
ship_geo.tauMS.Ztot)
taumagneticspectrometer.SetFeDimensions(ship_geo.tauMS.XFe,
ship_geo.tauMS.YFe,
ship_geo.tauMS.ZFe)
taumagneticspectrometer.SetRpcDimensions(ship_geo.tauMS.XRpc,
ship_geo.tauMS.YRpc,
ship_geo.tauMS.ZRpc)
taumagneticspectrometer.SetRpcGasDimensions(ship_geo.tauMS.XGas,
ship_geo.tauMS.YGas,
ship_geo.tauMS.ZGas)
taumagneticspectrometer.SetRpcStripDimensions(ship_geo.tauMS.XStrip,
ship_geo.tauMS.YStrip,
ship_geo.tauMS.ZStrip)
taumagneticspectrometer.SetRpcElectrodeDimensions(
ship_geo.tauMS.XEle, ship_geo.tauMS.YEle, ship_geo.tauMS.ZEle)
taumagneticspectrometer.SetRpcPETDimensions(ship_geo.tauMS.XPet,
ship_geo.tauMS.YPet,
ship_geo.tauMS.ZPet)
taumagneticspectrometer.SetReturnYokeDimensions(
ship_geo.tauMS.XRyoke, ship_geo.tauMS.YRyoke,
ship_geo.tauMS.ZRyoke)
taumagneticspectrometer.SetSmallerYokeDimensions(
ship_geo.tauMS.XRyoke_s, ship_geo.tauMS.YRyoke_s,
ship_geo.tauMS.ZRyoke_s)
taumagneticspectrometer.SetZDimensionArm(ship_geo.tauMS.ZArm)
taumagneticspectrometer.SetGapDownstream(ship_geo.tauMS.GapD)
taumagneticspectrometer.SetGapMiddle(ship_geo.tauMS.GapM)
taumagneticspectrometer.SetNFeInArm(ship_geo.tauMS.NFe)
taumagneticspectrometer.SetNRpcInArm(ship_geo.tauMS.NRpc)
taumagneticspectrometer.SetMagneticField(ship_geo.tauMS.B)
taumagneticspectrometer.SetCoilParameters(ship_geo.tauMS.CoilH,
ship_geo.tauMS.CoilW,
ship_geo.tauMS.N,
ship_geo.tauMS.CoilG)
taumagneticspectrometer.SetPillarDimensions(ship_geo.tauMS.PillarX,
ship_geo.tauMS.PillarY,
ship_geo.tauMS.PillarZ)
detectorList.append(taumagneticspectrometer)
tauHpt = ROOT.Hpt("HighPrecisionTrackers", ship_geo.tauHPT.DX,
ship_geo.tauHPT.DY, ship_geo.tauHPT.DZ, ROOT.kTRUE)
tauHpt.SetZsize(ship_geo.tauMS.Ztot)
tauHpt.SetConcreteBaseDim(ship_geo.tauHPT.ConcreteX,
ship_geo.tauHPT.ConcreteY,
ship_geo.tauHPT.ConcreteZ)
detectorList.append(tauHpt)
if ship_geo.nuTauTargetDesign == 0 or ship_geo.nuTauTargetDesign == 1:
EmuMagnet = ROOT.EmulsionMagnet("EmuMagnet", ship_geo.EmuMagnet.zC,
"EmulsionMagnet")
EmuMagnet.SetDesign(ship_geo.EmuMagnet.Design)
EmuMagnet.SetGaps(ship_geo.EmuMagnet.GapUp,
ship_geo.EmuMagnet.GapDown)
EmuMagnet.SetMagneticField(ship_geo.EmuMagnet.B)
EmuMagnet.SetMagnetSizes(ship_geo.EmuMagnet.X,
ship_geo.EmuMagnet.Y,
ship_geo.EmuMagnet.Z)
EmuMagnet.SetCoilParameters(ship_geo.EmuMagnet.Radius,
ship_geo.EmuMagnet.Height1,
ship_geo.EmuMagnet.Height2,
ship_geo.EmuMagnet.Distance)
EmuMagnet.SetMagnetColumn(ship_geo.EmuMagnet.ColX,
ship_geo.EmuMagnet.ColY,
ship_geo.EmuMagnet.ColZ)
EmuMagnet.SetBaseDim(ship_geo.EmuMagnet.BaseX,
ship_geo.EmuMagnet.BaseY,
ship_geo.EmuMagnet.BaseZ)
EmuMagnet.SetPillarDimensions(ship_geo.EmuMagnet.PillarX,
ship_geo.EmuMagnet.PillarY,
ship_geo.EmuMagnet.PillarZ)
detectorList.append(EmuMagnet)
if ship_geo.nuTauTargetDesign == 2:
EmuMagnet = ROOT.EmulsionMagnet()
NuTauTarget = ROOT.Target("NuTauTarget", ship_geo.NuTauTarget.Ydist,
ROOT.kTRUE)
NuTauTarget.MakeNuTargetPassive(ship_geo.NuTauTarget.nuTargetPassive)
NuTauTarget.SetDetectorDesign(ship_geo.NuTauTarget.Design)
NuTauTarget.SetCenterZ(ship_geo.NuTauTarget.zC)
NuTauTarget.SetNumberBricks(ship_geo.NuTauTarget.col,
ship_geo.NuTauTarget.row,
ship_geo.NuTauTarget.wall)
NuTauTarget.SetDetectorDimension(ship_geo.NuTauTarget.xdim,
ship_geo.NuTauTarget.ydim,
ship_geo.NuTauTarget.zdim)
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)
NuTauTarget.SetBrickParam(ship_geo.NuTauTarget.BrX,
ship_geo.NuTauTarget.BrY,
ship_geo.NuTauTarget.BrZ,
ship_geo.NuTauTarget.BrPackX,
ship_geo.NuTauTarget.BrPackY,
ship_geo.NuTauTarget.BrPackZ)
NuTauTarget.SetCESParam(ship_geo.NuTauTarget.RohG,
ship_geo.NuTauTarget.LayerCESW,
ship_geo.NuTauTarget.CESW,
ship_geo.NuTauTarget.CESPack)
NuTauTarget.SetCellParam(ship_geo.NuTauTarget.CellW)
if ship_geo.nuTauTargetDesign == 0 or ship_geo.nuTauTargetDesign == 1:
NuTauTarget.SetMagneticField(ship_geo.EmuMagnet.B)
NuTauTarget.SetMagnetHeight(ship_geo.EmuMagnet.Y)
NuTauTarget.SetColumnHeight(ship_geo.EmuMagnet.ColY)
NuTauTarget.SetBaseHeight(ship_geo.EmuMagnet.BaseY)
NuTauTarget.SetCoilUpHeight(ship_geo.EmuMagnet.Height1)
NuTauTarget.SetCoilDownHeight(ship_geo.EmuMagnet.Height2)
if ship_geo.nuTauTargetDesign == 2:
NuTauTarget.SetPillarDimension(ship_geo.NuTauTarget.PillarX,
ship_geo.NuTauTarget.PillarY,
ship_geo.NuTauTarget.PillarZ)
NuTauTarget.SetBaseDimension(ship_geo.NuTauTarget.BaseX,
ship_geo.NuTauTarget.BaseY,
ship_geo.NuTauTarget.BaseZ)
NuTauTT = ROOT.TargetTracker("TargetTrackers", ROOT.kTRUE)
NuTauTT.SetNumberTT(ship_geo.NuTauTT.n)
NuTauTT.SetTargetTrackerParam(ship_geo.NuTauTT.TTX,
ship_geo.NuTauTT.TTY,
ship_geo.NuTauTT.TTZ)
NuTauTT.SetBrickParam(ship_geo.NuTauTarget.CellW)
NuTauTT.SetTotZDimension(ship_geo.NuTauTarget.zdim)
#method of nutau target that must be called after TT parameter definition
NuTauTarget.SetTTzdimension(ship_geo.NuTauTT.TTZ)
detectorList.append(NuTauTarget)
detectorList.append(NuTauTT)
if ship_geo.strawDesign > 1:
Strawtubes = ROOT.strawtubes("Strawtubes", ROOT.kTRUE)
Strawtubes.SetZpositions(ship_geo.vetoStation.z,
ship_geo.TrackStation1.z,
ship_geo.TrackStation2.z,
ship_geo.TrackStation3.z,
ship_geo.TrackStation4.z)
Strawtubes.SetDeltazView(ship_geo.strawtubes.DeltazView)
Strawtubes.SetInnerStrawDiameter(
ship_geo.strawtubes.InnerStrawDiameter)
Strawtubes.SetOuterStrawDiameter(
ship_geo.strawtubes.OuterStrawDiameter)
Strawtubes.SetStrawPitch(ship_geo.strawtubes.StrawPitch)
Strawtubes.SetDeltazLayer(ship_geo.strawtubes.DeltazLayer)
Strawtubes.SetDeltazPlane(ship_geo.strawtubes.DeltazPlane)
Strawtubes.SetStrawsPerLayer(ship_geo.strawtubes.StrawsPerLayer)
Strawtubes.SetStereoAngle(ship_geo.strawtubes.ViewAngle)
Strawtubes.SetWireThickness(ship_geo.strawtubes.WireThickness)
Strawtubes.SetVacBox_x(ship_geo.strawtubes.VacBox_x)
Strawtubes.SetVacBox_y(ship_geo.strawtubes.VacBox_y)
Strawtubes.SetStrawLength(ship_geo.strawtubes.StrawLength)
if hasattr(ship_geo.strawtubes, "StrawLengthVeto"):
Strawtubes.SetStrawLengthVeto(ship_geo.strawtubes.StrawLengthVeto)
Strawtubes.SetStrawLength12(ship_geo.strawtubes.StrawLength12)
Strawtubes.SetVetoYDim(ship_geo.strawtubes.vetoydim)
Strawtubes.SetTr12YDim(ship_geo.strawtubes.tr12ydim)
Strawtubes.SetTr34YDim(ship_geo.strawtubes.tr34ydim)
else:
Strawtubes.SetStrawLengthVeto(ship_geo.strawtubes.StrawLength)
Strawtubes.SetStrawLength12(ship_geo.strawtubes.StrawLength)
Strawtubes.SetVetoYDim(ship_geo.Yheight / 2.)
Strawtubes.SetTr12YDim(ship_geo.Yheight / 2.)
Strawtubes.SetTr34YDim(ship_geo.Yheight / 2.)
# for the digitizing step
Strawtubes.SetStrawResolution(
getParameter("strawtubes.v_drift", ship_geo, latestShipGeo),
getParameter("strawtubes.sigma_spatial", ship_geo, latestShipGeo))
detectorList.append(Strawtubes)
if ship_geo.preshowerOption > 0:
Preshower = ROOT.preshower("Preshower", ROOT.kTRUE)
Preshower.SetZStationPosition2(ship_geo.PreshowerStation0.z,
ship_geo.PreshowerStation1.z)
Preshower.SetZFilterPosition2(ship_geo.PreshowerFilter0.z,
ship_geo.PreshowerFilter1.z)
Preshower.SetXMax(ship_geo.Preshower.XMax)
Preshower.SetYMax(ship_geo.Preshower.YMax)
Preshower.SetActiveThickness(ship_geo.Preshower.ActiveThickness)
Preshower.SetFilterThickness2(ship_geo.Preshower.FilterThickness0,
ship_geo.Preshower.FilterThickness1)
detectorList.append(Preshower)
ecal, EcalZSize = posEcal(ship_geo.ecal.z, ship_geo.ecal.File)
detectorList.append(ecal)
if not ship_geo.HcalOption < 0:
hcal, HcalZSize = posHcal(ship_geo.hcal.z, ship_geo.hcal.File)
if abs(ship_geo.hcal.hcalSpace - HcalZSize) > 10 * u.cm:
print 'mismatch between hcalsize in geo file and python configuration'
print ship_geo.hcal.hcalSpace - HcalZSize, ship_geo.hcal.hcalSpace, HcalZSize
detectorList.append(hcal)
Muon = ROOT.muon("Muon", ROOT.kTRUE)
Muon.SetZStationPositions(ship_geo.MuonStation0.z, ship_geo.MuonStation1.z,
ship_geo.MuonStation2.z, ship_geo.MuonStation3.z)
Muon.SetZFilterPositions(ship_geo.MuonFilter0.z, ship_geo.MuonFilter1.z,
ship_geo.MuonFilter2.z)
Muon.SetXMax(ship_geo.Muon.XMax)
Muon.SetYMax(ship_geo.Muon.YMax)
Muon.SetActiveThickness(ship_geo.Muon.ActiveThickness)
Muon.SetFilterThickness(ship_geo.Muon.FilterThickness)
detectorList.append(Muon)
#----- Magnetic field -------------------------------------------
if ship_geo.strawDesign == 4:
fMagField = ROOT.ShipBellField("wilfried", ship_geo.Bfield.max,
ship_geo.Bfield.z, 2,
ship_geo.Yheight / 2. * u.m)
else:
fMagField = ROOT.ShipBellField("wilfried", ship_geo.Bfield.max,
ship_geo.Bfield.z, 1,
ship_geo.Yheight / 2. * u.m)
if ship_geo.muShieldDesign == 6:
fMagField.IncludeTarget(ship_geo.target.xy, ship_geo.target.z0,
ship_geo.target.length)
run.SetField(fMagField)
#
exclusionList = []
#exclusionList = ["Muon","Ecal","Hcal","Strawtubes","TargetTrackers","NuTauTarget","HighPrecisionTrackers",\
# "Veto","Magnet","MuonShield","TargetStation","MagneticSpectrometer","EmuMagnet"]
for x in detectorList:
if x.GetName() in exclusionList: continue
run.AddModule(x)
# return list of detector elements
detElements = {}
for x in run.GetListOfModules():
detElements[x.GetName()] = x
return detElements
HcalGeoFile = "hcal.geo"
if "emdesign" not in globals():
emdesign = 0
with ConfigRegistry.register_config("basic") as c:
# global muShieldDesign, targetOpt, strawDesign, Yheight
c.Yheight = Yheight*u.m
# decision by the SP
totalLength = 2.5*c.Yheight + 35*u.m
extraVesselLength = totalLength - 50*u.m
windowBulge = 1*u.m
if tankDesign > 5: windowBulge = 25*u.cm
c.strawDesign = strawDesign
c.tankDesign = tankDesign
# cave parameters
c.cave = AttrDict(z=0*u.cm)
c.cave.floorHeightMuonShield = 5*u.m
c.cave.floorHeightTankA = 4.5*u.m
c.cave.floorHeightTankB = 2*u.m
#
#neutrino detector
c.nuTauTargetDesign=nuTauTargetDesign
c.chambers = AttrDict(z=0*u.cm)
magnetIncrease = 100.*u.cm
# make z coordinates for the decay volume and tracking stations relative to T4z
# eventually, the only parameter which needs to be changed when the active shielding lenght changes.
z4=2438.*u.cm+magnetIncrease+extraVesselLength
if strawDesign != 4 and strawDesign != 10 :
print "this design ",strawDesign," is not supported, use strawDesign = 4 or 10"
1/0
if "strawDesign" not in globals():
strawDesign = 4
if "HcalOption" not in globals():
HcalOption = 1
if "Yheight" not in globals():
Yheight = 10.
with ConfigRegistry.register_config("basic") as c:
# global muShieldDesign, targetOpt, strawDesign, Yheight
c.Yheight = Yheight * u.m
# decision by the SP
totalLength = 2.5 * c.Yheight + 35 * u.m
extraVesselLength = totalLength - 50 * u.m
windowBulge = 1 * u.m
c.strawDesign = strawDesign
c.chambers = AttrDict(z=0 * u.cm)
if strawDesign != 4:
print "this design is not supported, use strawDesign = 4"
1 / 0
else:
c.chambers.Length = totalLength
magnetIncrease = 100. * u.cm
c.chambers.Tub1length = 2.5 * u.m
c.chambers.Tub2length = 17.68 * u.m + extraVesselLength / 2.
c.chambers.Tub3length = 0.8 * u.m
c.chambers.Tub4length = 2. * u.m + magnetIncrease / 2.
c.chambers.Tub5length = 0.8 * u.m
c.chambers.Tub6length = 0.1 * u.m + windowBulge / 2.
c.chambers.Rmin = 245. * u.cm
c.chambers.Rmax = 250. * u.cm
# positions and lenghts of vacuum tube segments
import shipunit as u
from ShipGeoConfig import AttrDict, ConfigRegistry
# the following params should be passed through 'ConfigRegistry.loadpy' method
# none for the moment
with ConfigRegistry.register_config("basic") as c:
c.MufluxSpectrometer = AttrDict(z=0 * u.cm)
# False = charm cross-section; True = muon flux measurement
if "targetOpt" not in globals():
targetOpt = 18 # add extra 20cm of tungsten as per 13/06/2017
if "Setup" not in globals(): #muon flux or charm xsec measurement
Setup = 0
if "cTarget" not in globals():
cTarget = 3
if Setup == 0:
c.MufluxSpectrometer.muflux = True
else:
c.MufluxSpectrometer.muflux = False
c.target = AttrDict(z0=0 * u.cm)
c.MufluxTargetStation = AttrDict(z0=0 * u.cm)
c.MufluxTargetStation.absorber_x = 120 * u.cm
c.MufluxTargetStation.absorber_y = 97.5 * u.cm
c.MufluxTargetStation.absorbercutout_x = 102 * u.cm
c.MufluxTargetStation.absorbercutout_y = 27.5 * u.cm
c.MufluxTargetStation.ironshield_x = 20. * u.cm
HcalGeoFile = "hcal_rect.geo"
else:
HcalGeoFile = "hcal.geo"
if "preshowerOption" not in globals():
preshowerOption = 0
with ConfigRegistry.register_config("basic") as c:
# global muShieldDesign, targetOpt, strawDesign, Yheight
c.Yheight = Yheight*u.m
# decision by the SP
totalLength = 2.5*c.Yheight + 35*u.m
extraVesselLength = totalLength - 50*u.m
windowBulge = 1*u.m
c.strawDesign = strawDesign
c.tankDesign = tankDesign
c.chambers = AttrDict(z=0*u.cm)
magnetIncrease = 100.*u.cm
# make z coordinates for the decay volume and tracking stations relative to T4z
# eventually, the only parameter which needs to be changed when the active shielding lenght changes.
z4=2438.*u.cm+magnetIncrease+extraVesselLength
if strawDesign != 4:
print "this design is not supported, use strawDesign = 4"
1/0
else:
c.chambers.Length = totalLength
c.chambers.Tub1length = 2.5*u.m
c.chambers.Tub2length = 17.68*u.m+extraVesselLength/2.
c.chambers.Tub3length = 0.8*u.m
c.chambers.Tub4length = 2.*u.m+magnetIncrease/2.
c.chambers.Tub5length = 0.8*u.m
c.chambers.Tub6length = 0.1*u.m+windowBulge/2.
import shipunit as u
from ShipGeoConfig import AttrDict, ConfigRegistry
# the following params should be passed through 'ConfigRegistry.loadpy' method
# none for the moment
with ConfigRegistry.register_config("basic") as c:
c.target = AttrDict(z0=0*u.cm)
c.Bfield = AttrDict(z=0*u.cm)
c.Bfield.max = 0 # 1.4361*u.kilogauss for SHiP
c.Bfield.y = 1.*u.m # dummy value
c.Bfield.x = 3.*u.m # dummy value
#BOX (Brick!)
c.Box = AttrDict(z=0*u.cm)
c.Box.BX = 13*u.cm
c.Box.BY = 11*u.cm
c.Box.BZ = 20*u.cm
c.Box.zBox = 0 * u.cm
c.Box.EmTh = 0.0045 * u.cm
c.Box.EmX = 10 * u.cm #for the moment, replace the previous values for normal simulations
c.Box.EmY = 10 * u.cm
c.Box.PBTh = 0.0205 * u.cm
c.Box.MolybdenumTh = 0.3 * u.cm
c.Box.EPlW = 2* c.Box.EmTh + c.Box.PBTh
c.Box.AllPW = c.Box.MolybdenumTh + c.Box.EPlW
c.Box.BrX = 12.9 *u.cm
c.Box.BrY = 10.5 *u.cm
c.Box.BrPackZ = 0.1 * u.cm
c.Box.BrPackX = c.Box.BrX - c.Box.EmX
c.Box.BrPackY = c.Box.BrY - c.Box.EmY
c.Box.BrZ = 54 * c.Box.AllPW + c.Box.EPlW +c.Box.BrPackZ
c.Box.PX = 0*u.cm
c.Box.PY = 0*u.cm
import shipunit as u
from ShipGeoConfig import AttrDict, ConfigRegistry
# the following params should be passed through 'ConfigRegistry.loadpy' method
# muShieldDesign = 2 # 1=passive 2=active
# targetOpt = 5 # 0=solid >0 sliced, 5 pieces of tungsten, 4 air slits
if "muShieldDesign" not in globals():
muShieldDesign = 2
if "targetOpt" not in globals():
targetOpt = 5
with ConfigRegistry.register_config("basic") as c:
# global muShieldDesign, targetOpt
c.vetoStation = AttrDict(z=-2390. * u.cm)
c.TrackStation1 = AttrDict(z=1510. * u.cm)
c.TrackStation2 = AttrDict(z=1710. * u.cm)
c.TrackStation3 = AttrDict(z=2150. * u.cm)
c.TrackStation4 = AttrDict(z=2370. * u.cm)
c.z = c.TrackStation2.z + 0.5 * (c.TrackStation3.z - c.TrackStation2.z)
c.Bfield = AttrDict(z=c.z)
c.Bfield.max = 1.5 * u.kilogauss # was 1.15 in EOI
# target absorber muon shield setup
c.decayVolume = AttrDict(z=0 * u.cm)
c.decayVolume.length = 50 * u.m
c.muShield = AttrDict(z=0 * u.cm)
c.muShield.dZ1 = 2.5 * u.m
targetOpt = 5
if "strawDesign" not in globals():
strawDesign = 4
if "HcalOption" not in globals():
HcalOption = -1
if "Yheight" not in globals():
Yheight = 10.
with ConfigRegistry.register_config("basic") as c:
# global muShieldDesign, targetOpt, strawDesign, Yheight
c.Yheight = Yheight * u.m
# decision by the SP
totalLength = 2.5 * c.Yheight + 35 * u.m
extraVesselLength = totalLength - 50 * u.m
c.strawDesign = strawDesign
c.chambers = AttrDict(z=0 * u.cm)
if strawDesign != 4:
print "this design is not supported, use strawDesign = 4"
1 / 0
else:
c.chambers.Length = totalLength
c.chambers.Tub1length = 2.5 * u.m
c.chambers.Tub2length = 17.68 * u.m + extraVesselLength / 2.
c.chambers.Tub3length = 0.8 * u.m
c.chambers.Tub4length = 2. * u.m
c.chambers.Tub5length = 0.8 * u.m
c.chambers.Tub6length = 0.1 * u.m
c.chambers.Rmin = 245. * u.cm
c.chambers.Rmax = 250. * u.cm
# positions and lenghts of vacuum tube segments
c.Chamber1 = AttrDict(z=-22.28 * u.m)
import ROOT as r
import shipunit as u
from ShipGeoConfig import AttrDict, ConfigRegistry
with ConfigRegistry.register_config("basic") as c:
# cave parameters
c.cave = AttrDict(z=0 * u.cm)
# Antonia, 482000mm (FASER+2, P3) + 1017mm (DZ) + 245mm (centre emulsion),z=483262./10.*u.cm
# centre emulsion now 326.2cm downstream from origin.
c.EmulsionDet = AttrDict(z=326.2 * u.cm)
c.EmulsionDet.PassiveOption = 1 #0 makes emulsion volumes active, 1 makes all emulsion volumes passive
c.EmulsionDet.row = 2
c.EmulsionDet.col = 2
c.EmulsionDet.wall = 5
c.EmulsionDet.target = 1 #number of neutrino target volumes
c.EmulsionDet.n_plates = 59
c.EmulsionDet.EmTh = 0.0070 * u.cm
c.EmulsionDet.EmX = 19.2 * u.cm
c.EmulsionDet.EmY = 19.2 * u.cm
c.EmulsionDet.PBTh = 0.0175 * u.cm
c.EmulsionDet.PassiveTh = 0.1 * u.cm
c.EmulsionDet.EPlW = 2 * c.EmulsionDet.EmTh + c.EmulsionDet.PBTh
c.EmulsionDet.AllPW = c.EmulsionDet.PassiveTh + c.EmulsionDet.EPlW
c.EmulsionDet.BrPackZ = 0. * u.cm
c.EmulsionDet.BrPackX = 2 * 0.05 * u.cm
c.EmulsionDet.BrPackY = 2 * 0.05 * u.cm
c.EmulsionDet.BrX = c.EmulsionDet.EmX + c.EmulsionDet.BrPackX
c.EmulsionDet.BrY = c.EmulsionDet.EmY + c.EmulsionDet.BrPackY