def construct(self, geom):
# container
head_shape = geom.shapes.Tubs(self.name + 'Head',
rmin=self.rmin1,
rmax=self.rmax1,
dz=self.dz1)
neck_shape = geom.shapes.Tubs(self.name + 'Neck',
rmin=self.rmin2,
rmax=self.rmax2,
dz=self.dz2)
relpos = geom.structure.Position(self.name + 'FTRel_pos', Q('0m'),
Q('0m'),
neck_shape.dz + head_shape.dz)
# union
boolean_shape = geom.shapes.Boolean(self.name,
type='union',
first=neck_shape,
second=head_shape,
pos=relpos)
boolean_lv = geom.structure.Volume('vol' + boolean_shape.name,
material=self.material,
shape=boolean_shape)
self.add_volume(boolean_lv)
def build_ecal(self, main_lv, geom):
# build the ecalbarrel
ibb = self.get_builder('ECALBarrelBuilder')
if ibb == None:
return
ib_vol = ibb.get_volume()
# Add the magnetic field to the volume
ib_vol.params.append(("BField", self.innerBField))
ecal_shape = geom.store.shapes.get(ib_vol.shape)
nsides = ecal_shape.numsides
rot_z = Q("90.0deg")-Q("180.0deg")/nsides
ib_rot = geom.structure.Rotation(ibb.name+"_rot", z=rot_z)
ib_pla = geom.structure.Placement(ibb.name+"_pla", volume=ib_vol, rot=ib_rot)
# Place it in the main lv
main_lv.placements.append(ib_pla.name)
# build the ecal endcap
iecb = self.get_builder("ECALEndcapBuilder")
if iecb == None:
return
iec_vol = iecb.get_volume()
# Add the magnetic field to the volume
iec_vol.params.append(("BField", self.innerBField))
iec_rot = geom.structure.Rotation(iecb.name+"_rot", z=rot_z)
iec_pla = geom.structure.Placement(iecb.name+"_pla", volume=iec_vol, rot=iec_rot)
# Place it in the main lv
main_lv.placements.append(iec_pla.name)
def construct( self, geom ):
main_lv, main_hDim = ltools.main_lv( self, geom, "Box")
self.add_volume( main_lv )
# definition local rotation
rotation = ltools.getRotation( self, geom )
InsideGap = ltools.getInsideGap( self )
if self.NElements != None:
# get sub-builders and its logic volume
sb = self.get_builder()
sb_lv = sb.get_volume()
sb_dim = ltools.getShapeDimensions( sb_lv, geom )
# TranspV = [1,0,0] #MAK: not used
# initial position, particular case
pos = [-main_hDim[0]+sb_dim[0]*0.5, Q('0m'), Q('0m')]
print( "STTPlane sb_dim[]= "+str(sb_dim))
for elem in range(self.NElements):
pos = [ sb_dim[0]*0.5+pos[0], pos[1]-math.pow(-1,elem+1)*sb_dim[0]*math.sqrt(3)*0.5, pos[2] ]
sb_pos = geom.structure.Position(self.name+sb_lv.name+str(elem)+'_pos',
pos[0], pos[1], pos[2])
sb_pla = geom.structure.Placement(self.name+sb_lv.name+str(elem)+'_pla',
volume=sb_lv, pos=sb_pos, rot =rotation)
main_lv.placements.append(sb_pla.name)
pos = [ sb_dim[0]*0.5+pos[0], pos[1]+math.pow(-1,elem+1)*sb_dim[0]*math.sqrt(3)*0.5, pos[2] ]
def build_yoke(self, main_lv, geom):
#### build the barrel ####
yokeb_builder = self.get_builder('YokeBarrelBuilder')
yokeb_vol = yokeb_builder.get_volume()
yoke_shape = geom.store.shapes.get(yokeb_vol.shape)
nsides = yoke_shape.numsides
rot_z = Q("90.0deg") - Q("180.0deg") / nsides
yokeb_rot = geom.structure.Rotation(yokeb_builder.name + "_rot",
z=rot_z)
yokeb_pla = geom.structure.Placement(yokeb_builder.name + "_pla",
volume=yokeb_vol,
rot=yokeb_rot)
# Place it in the main lv
main_lv.placements.append(yokeb_pla.name)
#### build the endcap ####
yokeec_builder = self.get_builder('YokeEndcapBuilder')
yokeec_vol = yokeec_builder.get_volume()
yokeec_rot = geom.structure.Rotation(yokeec_builder.name + "_rot",
z=rot_z)
yokeec_pla = geom.structure.Placement(yokeec_builder.name + "_pla",
volume=yokeec_vol,
rot=yokeec_rot)
# Place it in the main lv
main_lv.placements.append(yokeec_pla.name)
return
def construct_cylinder_layers(self, geom):
strip_builder = self.get_builder(self.strip_builder_name)
strip_lv = strip_builder.get_volume()
ggd_shape = geom.store.shapes.get(strip_lv.shape)
dr_layer = ggd_shape.dz * 2.0
layer_lvs = []
rinner = self.r
router = rinner
phi_start = Q("360deg")
actual_phi_coverage = Q("0deg")
strip_length = Q("10cm")
radd = Q("0mm")
for ilayer in range(self.nlayers):
# rlayer = self.r + ilayer*(dr_layer+self.layer_gap)
rlayer = rinner + radd
lname = self.output_name + "_L%i" % (ilayer)
# bubble up layer information so we can set an
# overall logical volume
layer_lv, temp_phi_start, temp_actual_phi_coverage, strip_length, dr_layer = self.construct_cylinder(
geom, rlayer, lname)
# add up the additional radial distance needed for
# successive layers
radd = radd + dr_layer + self.layer_gap
# phi start and phi end can vary by layers because
# the number of strips that can be fit in depends on the
# radius. Here we try to find the largest phi coverage
# needed to enclose all of the layers
if temp_phi_start < phi_start:
phi_start = temp_phi_start
if temp_actual_phi_coverage > actual_phi_coverage:
actual_phi_coverage = temp_actual_phi_coverage
layer_lvs.append(layer_lv)
router = rinner + radd
barrel_shape = geom.shapes.Tubs(self.output_name,
rmin=rinner,
rmax=router,
sphi=phi_start,
dphi=actual_phi_coverage,
dz=strip_length / 2.0)
barrel_lv = geom.structure.Volume(self.output_name + "_vol",
shape=barrel_shape,
material=self.material)
for layer_lv in layer_lvs:
pos = geom.structure.Position(layer_lv.name + "_pos",
x=Q("0mm"),
y=Q("0mm"),
z=Q("0mm"))
rot = geom.structure.Rotation(layer_lv.name + "_rot",
x=Q("0deg"),
y=Q("0deg"),
z=Q("0deg"))
pla = geom.structure.Placement(layer_lv.name + "_pla",
volume=layer_lv,
pos=pos,
rot=rot)
barrel_lv.placements.append(pla.name)
self.add_volume(barrel_lv)
class Cage(gegede.builder.Builder):
'''
Build a field cage.
'''
defaults = dict(
thickness=Q('0.006 inch'), # from doc9176
length=Q('254 mm'), # from Bo/Rohul's drift direction dimensions
height=Q('2002.1 mm'), # doc 7550 / Rahul's model
width=Q('1588.5 mm'), # doc 7550 / Rahul's model
material='FieldCage',
)
def construct(self, geom):
inner = geom.shapes.Box(
None,
0.5 * self.length +
self.thickness, # add a bit to punch out the hole
0.5 * self.height - self.thickness,
0.5 * self.width - self.thickness)
outer = geom.shapes.Box(None, 0.5 * self.length, 0.5 * self.height,
0.5 * self.width)
shape = geom.shapes.Boolean(None,
'subtraction',
first=outer,
second=inner)
vol = geom.structure.Volume('vol' + self.name,
material=self.material,
shape=shape)
self.add_volume(vol)
def construct(self, geom):
# construct the plate, subtract out insertion plate
leg_shape = geom.shapes.Tubs(self.name + 'Component1',
rmin=self.rmin,
rmax=self.rmax1,
dz=self.dz1)
foot_shape = geom.shapes.Tubs(self.name + 'Component2',
rmin=self.rmin,
rmax=self.rmax2,
dz=self.dz2)
relpos = geom.structure.Position(self.name + 'Component2Rel_pos',
Q('0m'), Q('0m'),
-1 * leg_shape.dz - foot_shape.dz)
# union
boolean_shape = geom.shapes.Boolean(self.name,
type='union',
first=leg_shape,
second=foot_shape,
pos=relpos)
boolean_lv = geom.structure.Volume('vol' + boolean_shape.name,
material=self.material,
shape=boolean_shape)
self.add_volume(boolean_lv)
def construct(self, geom):
# construct box shape
main_shape = geom.shapes.Box(self.name,
dx=self.dx,
dy=self.dy,
dz=self.dz)
# subtract out feedthroughs
boolean_shapes = [main_shape]
boolean_lv = []
assert (len(self.positions) == len(self.subtractions))
for i, (sub, pos) in enumerate(zip(self.subtractions, self.positions)):
# feedthrough shape
ftsub_shape = geom.shapes.Tubs(self.name + 'FTSubtractionTub' +
str(i),
rmin=Q('0m'),
rmax=sub,
dz=Q('1m'))
relpos = geom.structure.Position(
self.name + 'FTSubtractionTub' + str(i) + '_pos', pos[0],
pos[1], Q('0m'))
# subtract
boolean_shape = geom.shapes.Boolean(self.name + 'FTSubtraction' +
str(i),
type='subtraction',
first=boolean_shapes[i],
second=ftsub_shape,
pos=relpos)
boolean_shapes.append(boolean_shape)
boolean_lv = geom.structure.Volume('vol' + boolean_shape.name,
material=self.material,
shape=boolean_shape)
self.add_volume(boolean_lv)
def build_frontSTT(self, geom, main_lv):
# first start 25cm
UpstreamEmpty = Q("25cm")
c2seg = self.kloeTrkRegRadius - UpstreamEmpty
costh = c2seg / self.kloeTrkRegRadius
height = self.kloeTrkRegRadius * math.sqrt(1 - costh * costh)
name = "front1ST"
mod_lv = self.construct_doubleST(geom, name, height, "reg")
x = -self.kloeTrkRegRadius + UpstreamEmpty + (self.pureSTModThickness +
self.pureSTModGap) / 2.
mod_pos = geom.structure.Position("pos_" + name, x, Q("0cm"), Q("0cm"))
mod_pla = geom.structure.Placement("pla_" + name,
volume=mod_lv,
pos=mod_pos)
main_lv.placements.append(mod_pla.name)
c2seg = self.offset3DSTcenter + self.Depth3DST / 2 + (
self.pureSTModThickness + self.pureSTModGap)
costh = c2seg / self.kloeTrkRegRadius
height = self.kloeTrkRegRadius * math.sqrt(1 - costh * costh)
name2 = "front2ST"
mod_lv2 = self.construct_doubleST(geom, name2, height, "reg")
x2 = -self.offset3DSTcenter - self.Depth3DST / 2 - (
self.pureSTModThickness + self.pureSTModGap) / 2.
mod_pos2 = geom.structure.Position("pos_" + name2, x2, Q("0cm"),
Q("0cm"))
mod_pla2 = geom.structure.Placement("pla_" + name2,
volume=mod_lv2,
pos=mod_pos2)
main_lv.placements.append(mod_pla2.name)
def configure(self,
foilThickness=Q('25um'),
spacerThickness=Q('125um'),
nFoilsPerRadiator=60,
radFoilDim=None,
spacerDim=None,
radFoilMat='C3H6',
spacerMat='Air',
onlyOneBlock=False,
**kwds):
if radFoilDim is None:
raise ValueError("No value given for radFoilDim")
if spacerDim is None:
raise ValueError("No value given for spacerDim")
self.radFoilMat = radFoilMat
self.spacerMat = spacerMat
self.defaultMat = 'RadiatorBlend'
self.onlyOneBlock = onlyOneBlock
self.foilThickness = foilThickness
self.spacerThickness = spacerThickness
self.nFoilsPerRadiator = nFoilsPerRadiator
self.radFoilDim = radFoilDim
self.spacerDim = spacerDim
def construct_Foils(self, geom, name, halfheight, halflength):
main_shape = geom.shapes.Box(name,
dx=self.totFoilsThickness / 2.0,
dy=halfheight,
dz=halflength)
main_lv = geom.structure.Volume("vol" + name,
material="Air35C",
shape=main_shape)
print("STTModuleFULL::construct()")
print(" main_lv = " + main_lv.name)
foil_shape = geom.shapes.Box(name + "_foil_shape",
dx=self.foilThickness / 2.0,
dy=halfheight,
dz=halflength)
foil_lv = geom.structure.Volume(name + "_foil_vol",
material="C3H6",
shape=foil_shape)
for i in range(self.nfoil):
foil_pos = geom.structure.Position(
name + "_pos_foil_" + str(i),
-self.totFoilsThickness / 2.0 + self.foilThickness / 2.0 + i *
(self.foilThickness + self.foilGap), Q('0m'), Q('0m'))
foil_pla = geom.structure.Placement("pla_" + name + "_foil_" +
str(i),
volume=foil_lv,
pos=foil_pos)
main_lv.placements.append(foil_pla.name)
return main_lv
def construct_XYSTPlane(self, geom, name, halfheight, halflength,
gasMaterial):
main_shape = geom.shapes.Box(name,
dx=self.planeXXThickness,
dy=halfheight,
dz=halflength)
main_lv = geom.structure.Volume("vol" + name,
material="Air35C",
shape=main_shape)
pos_hh_in_ST = geom.structure.Position(name + "pos_hh_in_ST",
-self.planeXXThickness / 2.0,
Q('0cm'), Q('0cm'))
pos_vv_in_ST = geom.structure.Position(name + "pos_vv_in_ST",
self.planeXXThickness / 2.0,
Q('0cm'), Q('0cm'))
hh_lv = self.construct_STPlane(geom, name + "_hor", halfheight,
halflength, gasMaterial)
vv_lv = self.construct_STPlane(geom, name + "_ver", halflength,
halfheight, gasMaterial)
hh_pla = geom.structure.Placement("pla_" + name + "_hh",
volume=hh_lv,
pos=pos_hh_in_ST)
vv_pla = geom.structure.Placement("pla_" + name + "_vv",
volume=vv_lv,
pos=pos_vv_in_ST,
rot="r90aboutX")
main_lv.placements.append(hh_pla.name)
main_lv.placements.append(vv_pla.name)
return main_lv
def configure(
self,
config='cdr',
nRadiatorModules=75,
FeTar_z=('1mm'),
CaTar_z=('7mm'),
CTar_z=('4mm'), # this default bogus
radiatorMod_z=Q('76mm'),
stt_z=Q('6.4m'),
xxyyMod_z=Q('62mm'),
sttMat='Air',
**kwds):
self.config = config
self.sttMat = sttMat
self.stPlaneTarBldr = self.get_builder('STPlaneTarget')
self.stPlaneRadBldr = self.get_builder('STPlaneRadiator')
self.argonTargetBldr = self.get_builder('TargetPlaneArgon')
self.emptyArTargetBldr = self.get_builder('EmptyTargetPlaneArgon')
self.radiatorBldr = self.get_builder('Radiator')
self.nRadiatorModules = nRadiatorModules
# 4 radiators and 2 st planes per radiator module
self.radiatorMod_z = radiatorMod_z
self.xxyyMod_z = xxyyMod_z
self.stt_z = stt_z
self.FeTar_z = FeTar_z
self.CaTar_z = CaTar_z
self.CTar_z = CTar_z
self.printZpos = False
def construct(self, geom):
main_lv, main_hDim = ltools.main_lv( self, geom, "Box")
if self.AuxParams != None:
ltools.addAuxParams( self, main_lv )
self.add_volume( main_lv )
TranspV = [0,0,1]
begingap = ltools.getBeginGap( self )
# initial position, based on the dimension projected on transportation vector
pos = [Q('0m'),Q('0m'),-main_hDim[2]+begingap]
for i,sb in enumerate(self.get_builders()):
sb_lv = sb.get_volume()
sb_dim = ltools.getShapeDimensions( sb_lv, geom )
step = [Q('0cm'),Q('0cm'),Q('0cm')]
#assert ( sb_dim != None ), " fail"
if sb_dim != None:
step[2] = sb_dim[2]
else:
assert( sb.halfDimension != None ), " No volumen defined on %s " % sb
step[2] = sb.halfDimension['dz']
pos[2] = pos[2] + step[2] + self.InsideGap[i]
# defining position, placement, and finally insert into main logic volume.
sb_pos = geom.structure.Position(self.name+sb_lv.name+'_pos_'+str(i),
pos[0], pos[1], pos[2])
sb_pla = geom.structure.Placement(self.name+sb_lv.name+'_pla_'+str(i),
volume=sb_lv, pos=sb_pos )
main_lv.placements.append(sb_pla.name)
pos[2] = pos[2] + step[2]
def configure(self, **kwds):
self.NCaloModBarrel = 24
self.caloThickness = Q('23cm')
self.EndcapZ = Q('1.69m')
self.EndcapRmin = Q('20.8cm')
self.BarrelRmin = Q('2m')
self.BarrelDZ = Q('2.15m')
def construct_cplane_layers(self, geom):
''' construct a set of cplane layers '''
# get layer thickness
endcap_layer_builder = self.get_builder(self.endcap_layer_builder_name)
endcap_layer_lv = endcap_layer_builder.get_volume()
dz_layer = endcap_layer_builder.depth()
# get total z depth of all layers
total_z=(dz_layer+self.layer_gap)*self.nlayers
# make the mother volume first since we can
mother_shape = geom.shapes.Tubs(self.output_name,
rmin=Q('0mm'), rmax=self.r + self.extra_space,
sphi=Q("0deg"), dphi=Q("360deg"),
dz=total_z/2.0)
mother_lv = geom.structure.Volume(self.output_name+"_vol",
shape=mother_shape,
material=self.material)
# now loop over layers and construct and position them
zstart = -total_z/2.0 # edge of first layer here
zstart = zstart + dz_layer/2.0 # center of first layer here
# cplane_lv = self.construct_cplane(geom, self.output_name+"_basevol")
for ilayer in range(self.nlayers):
zlayer = zstart + (dz_layer + self.layer_gap)*ilayer
lname = self.output_name + "_L%i" % (ilayer)
print zlayer, lname
pos = geom.structure.Position(lname+'_pos',
x=Q('0mm'), y=Q('0mm'),
z=zlayer)
pla = geom.structure.Placement(lname+'_pla',
volume=endcap_layer_lv, pos=pos)
mother_lv.placements.append(pla.name)
self.add_volume(mother_lv)
def buildMagnetizedVolume(self, main_lv, geom):
'''Magnetized volume (fake volume) for G4 that includes the TPC + ECAL only'''
print "Making fake magnetized volume and adding to main volume"
eECal_shape = geom.get_shape("ECALEndcap_max")
fake_shape = geom.shapes.PolyhedraRegular(
'NDHPgTPC',
numsides=eECal_shape.numsides,
rmin=Q("0m"),
rmax=eECal_shape.rmax,
dz=eECal_shape.dz)
fake_lv = geom.structure.Volume('vol' + fake_shape.name,
material='Air',
shape=fake_shape)
fake_lv.params.append(("BField", self.innerBField))
rot_z = Q("90.0deg") - Q("180.0deg") / eECal_shape.numsides
fake_lv_rot = geom.structure.Rotation(fake_lv.name + "_rot", z=rot_z)
fake_pla = geom.structure.Placement("NDHPgTPC" + "_pla",
volume=fake_lv,
rot=fake_lv_rot)
# Place it in the main lv
main_lv.placements.append(fake_pla.name)
return fake_lv
def construct(self, geom):
main_lv, main_hDim = ltools.main_lv(self, geom, "Tubs")
if self.auxParams != None:
ltools.addAuxParams(self, main_lv)
self.add_volume(main_lv)
# sub-detectors
rot = [Q("0deg"), Q("0deg"), Q("0deg")]
for pos, sb in zip(self.positions, self.get_builders()):
sb_lv = sb.get_volume()
p = pos
p[1] = -1 * self.halfDimension['dz'] + pos[1]
print "NAME = ", sb_lv.name
print "pos = ", p
sb_pos = geom.structure.Position(sb_lv.name + '_pos', p[0], p[1],
p[2])
sb_rot = geom.structure.Rotation(sb_lv.name + '_rot',
self.Rotation[0],
self.Rotation[1],
self.Rotation[2])
sb_pla = geom.structure.Placement(sb_lv.name + '_pla',
volume=sb_lv,
pos=sb_pos,
rot=sb_rot)
main_lv.placements.append(sb_pla.name)
def configure(self, ScintBarDim = [Q('2.5cm'), Q('3.2m'), Q('1cm')],
SBPlaneMat = "epoxy_resin",
nScintBars = 128,
ScintBarMat = "Scintillator", **kwds):
self.SBPlaneMat = SBPlaneMat
self.ScintBarMat = ScintBarMat
self.ScintBarDim = ScintBarDim
self.nScintBars = nScintBars
def construct(self, geom):
# Get subsystem dimensions,
# one has to go to the builders to see/understand these
ecalDownDim = list(self.ecalDownBldr.ecalModDim)
# dimensions of the outside of the magnet yoke
# includes gaps between yoke segments
magBoxOutDim = list(self.MagnetBldr.MagnetSystemOuterDimension)
print "IronDipoleBuilder::construct(): magBoxOutDim = ",magBoxOutDim
# ecalBarPos = list(self.ecalBaPos)
############# build the top level lv ###################
main_shape = geom.shapes.Box('IronDipole', dx=0.5*magBoxOutDim[0],
dy=0.5*magBoxOutDim[1], dz=0.5*magBoxOutDim[2])
main_lv = geom.structure.Volume('vol'+self.name, material=self.defMat, shape=main_shape)
self.add_volume(main_lv)
######### magnet yoke ##################################
### build the magnet yoke and coils and place inside the main lv
self.build_magnet(main_lv,geom)
######### inner detector region ########################
### then build a lv to contain detectors, it will be located in the main_lv
### but sized and oriented to fit inside the magnet coils
### this is the region with a simple dipole field
### this is the main reason to build the detector nested like this
# MagnetBuilder.MagnetInn --> need to read that code
# dimensions of the inside of the magnet coils
# includes gaps between coil segments
innerDet_dim=self.MagnetBldr.MagnetInn
innerDet_shape = geom.shapes.Box('innerDet', dx=0.5*innerDet_dim[0],
dy=0.5*innerDet_dim[1],dz=0.5*innerDet_dim[2])
innerDet_lv= geom.structure.Volume('innerDet_volume',material='Air',shape=innerDet_shape)
print "Setting IronDipole inner detector field to ",self.innerDetBField
innerDet_lv.params.append(("BField",self.innerDetBField))
######### ecal and trackers inside inner detector ######
self.build_ecal(innerDet_lv,geom)
if self.buildSTT:
self.build_stt(innerDet_lv,geom)
if self.buildA3DST:
self.build_a3dst(innerDet_lv,geom)
if self.buildGArTPC:
self.build_gartpc(innerDet_lv,geom)
######### finally, place the inner detector volume #####
pos = [Q('0m'),Q('0m'),Q('0m')]
innerDet_pos=geom.structure.Position("innerDet_pos",
pos[0],pos[1], pos[2])
innerDet_pla=geom.structure.Placement("innerDet_pla",
volume=innerDet_lv,
pos=innerDet_pos)
print "appending ",innerDet_pla.name, " to ", main_lv.name
main_lv.placements.append(innerDet_pla.name)
def construct_XXST(self, geom, tubeDirection, name, halflength,
halfCrosslength, modtype):
main_shape = geom.shapes.Box("shape_" + name,
dx=self.planeXXThickness / 2.0,
dy=halfCrosslength,
dz=halflength)
main_lv = geom.structure.Volume(name,
material="Air35C",
shape=main_shape)
if tubeDirection == "hh":
if modtype == "CMod":
straw_lv = self.horizontalST_Ar
else:
straw_lv = self.horizontalST_Xe
else:
straw_lv = self.construct_strawtube(geom, name + "_ST", halflength,
modtype)
Nstraw = int(
(2 * halfCrosslength - self.strawRadius) / self.strawRadius / 2.0)
straw_shape = geom.shapes.Tubs("shape_" + name + "_1st",
rmin=Q("0m"),
rmax=self.strawRadius,
dz=halflength)
twoStraw_shape = geom.shapes.Boolean("shape_" + name + "_2straw",
type='union',
first=straw_shape,
second=straw_shape,
rot='noRotate',
pos="pos_straw2relative")
twoStraw_lv = geom.structure.Volume(name + "_2straw",
material="Air35C",
shape=twoStraw_shape)
straw1_pla = geom.structure.Placement("pla_" + name + "_s1",
volume=straw_lv)
twoStraw_lv.placements.append(straw1_pla.name)
straw2_pla = geom.structure.Placement("pla_" + name + "_s2",
volume=straw_lv,
pos="pos_straw2relative")
twoStraw_lv.placements.append(straw2_pla.name)
print("Nstraw", Nstraw)
for i in range(Nstraw):
pos1 = geom.structure.Position(
"pos_" + name + "_" + str(i),
-self.planeXXThickness / 2.0 + self.strawRadius,
halfCrosslength - (2 * i + 2) * self.strawRadius, Q('0m'))
twoStraw_pla1 = geom.structure.Placement("pla_" + name + "_" +
str(i),
volume=twoStraw_lv,
pos=pos1)
main_lv.placements.append(twoStraw_pla1.name)
return main_lv
def buildECALBarrel(self, main_lv, geom):
# References
# M. Adinolfi et al., NIM A 482 (2002) 364-386
# and a talk at the June 2017 ND workshop
#
# ECAL is a Pb/SciFi/epoxy sandwich in the volume ratio 42:48:10
# with an average density of 5.3g/cc
#
# fibers are coupled to lightguides at both ends and readout by PMTs
#
# BARREL
# there is a barrel section that is nearly cylindrical, with 24 modules
# each covering 15 degrees. The modules are 4.3m long, 23cm thick,
# trapezoids with bases of 52 and 59 cm.
if self.get_builder("KLOEEMCALOBARRELMOD") == None:
print "KLOEEMCALOBARRELMOD builder not found"
return
emcalo_module_builder = self.get_builder("KLOEEMCALOBARRELMOD")
emcalo_module_lv = emcalo_module_builder.get_volume()
for j in range(self.NCaloModBarrel):
axisy = (0, 1, 0)
axisz = (1, 0, 0)
ang = 360 / self.NCaloModBarrel
theta = j * ang + ang / 2.
ModPosition = [
Q('0mm'),
Q('0mm'), self.BarrelRmin + 0.5 * self.caloThickness
]
ModPositionNew = ltools.rotation(
axisy, theta, ModPosition
) #Rotating the position vector (the slabs will be rotated automatically after append)
ModPositionNew = ltools.rotation(axisz, -90, ModPositionNew)
ECAL_position = geom.structure.Position(
'ECAL_position' + '_' + str(j), ModPositionNew[0],
ModPositionNew[1], ModPositionNew[2])
ECAL_rotation = geom.structure.Rotation(
'ECAL_rotation' + '_' + str(j), Q('90deg'), -theta * Q('1deg'),
Q('0deg')) #Rotating the module on its axis accordingly
print("Building Kloe ECAL module " + str(j)) # keep compatibility with Python3 pylint: disable=superfluous-parens
####Placing and appending the j ECAL Module#####
ECAL_place = geom.structure.Placement('ECAL_place' + '_' + str(j),
volume=emcalo_module_lv,
pos=ECAL_position,
rot=ECAL_rotation)
main_lv.placements.append(ECAL_place.name)
class WireFrame(gegede.builder.Builder):
'''Assemble the individual wire frames into one big frame.
Three sub-builders are expected in order: small, medium and large.
'''
defaults = dict(
small_center=0.5 * Q('730.0mm') - Q('4 inch') - 0.5 * Q('2002.1mm'),
medium_center=0.5 * Q('2002.1mm') - 0.5 * Q('1196.2mm'),
large_center=0.5 * Q('2002.1mm') - 0.5 * Q('2036.2mm'),
large_offset=Q('505 mm') + Q('1 inch'),
material='LiquidArgon',
)
def construct(self, geom):
children = list()
maxyext = Q('0 m')
# small
s_volume = self.get_builder(0).get_volume(0)
s_shape = geom.get_shape(s_volume.shape)
pos = geom.structure.Position(None, y=self.small_center)
place = geom.structure.Placement(None, volume=s_volume, pos=pos)
children.append(place)
maxyext = max(maxyext, abs(self.small_center - s_shape.dy))
# medium
m_volume = self.get_builder(1).get_volume(0)
m_shape = geom.get_shape(m_volume.shape)
pos = geom.structure.Position(None, y=self.medium_center)
place = geom.structure.Placement(None, volume=m_volume, pos=pos)
children.append(place)
maxyext = max(maxyext, self.medium_center + m_shape.dy)
# large
l_volume = self.get_builder(2).get_volume(0)
l_shape = geom.get_shape(l_volume.shape)
posm = geom.structure.Position(None,
z=-1 * self.large_offset,
y=self.large_center)
posp = geom.structure.Position(None,
z=+1 * self.large_offset,
y=self.large_center)
children += [
geom.structure.Placement(None, volume=l_volume, pos=posm),
geom.structure.Placement(None, volume=l_volume, pos=posp)
]
maxyext = max(maxyext, self.large_center + l_shape.dy)
# envelope
env_shape = geom.shapes.Box(None,
dx=l_shape.dx,
dy=maxyext,
dz=self.large_offset + l_shape.dz)
env_vol = geom.structure.Volume('vol' + self.name,
material=self.material,
shape=env_shape,
placements=children)
self.add_volume(env_vol)
def is_tile_inside(self, x, y, w, r):
'''Is the square tile with width w and centered on x,y
contained inside a circle of radius r?'''
# it is sufficient to check that the 4 corners are inside the circle
corners = [(x + w, y + w), (x + w, y - w), (x - w, y + w),
(x - w, y - w)]
for xx, yy in corners:
rc2 = (xx**2 + yy**2) / Q('1mm**2')
rc = sqrt(rc2) * Q('1mm')
if rc > r:
return False
return True
def construct( self, geom ):
neck_shape = geom.shapes.Tubs( self.name+'Component2', rmin=self.rmin2, rmax=self.rmax2, dz=self.dz2 )
foot_shape = geom.shapes.Tubs( self.name+'Component1', rmin=self.rmin1, rmax=self.rmax1, dz=self.dz1 )
relpos1 = geom.structure.Position(self.name+'Component1Rel_pos', Q('0m'), Q('0m'), neck_shape.dz+foot_shape.dz)
relpos2 = geom.structure.Position(self.name+'Component2Rel_pos', Q('0m'), Q('0m'), neck_shape.dz-self.shift-foot_shape.dz)
# union
boolean_shape1 = geom.shapes.Boolean( self.name+'Union1', type='union', first=neck_shape, second=foot_shape, pos=relpos1)
boolean_shape2 = geom.shapes.Boolean( self.name, type='union', first=boolean_shape1, second=foot_shape, pos=relpos2)
boolean_lv = geom.structure.Volume('vol'+boolean_shape2.name, material=self.material, shape=boolean_shape2)
self.add_volume( boolean_lv )
def getInitialPos(slf, ggd_dim, transpV):
"""
Return the initial postion for the builder based on the TranspV
"""
begingap = getBeginGap(slf)
if slf.NElements == 0:
if slf.SubBPos != None:
return slf.SubBPos
else:
return [Q('0m'), Q('0m'), Q('0m')]
else:
return [-t * (d - begingap) for t, d in zip(transpV, ggd_dim)]
def construct(self, geom):
children = list()
maxyext = Q('0 m')
s_volume = self.get_builder(0).get_volume(0)
s_shape = geom.get_shape(s_volume)
m_volume = self.get_builder(1).get_volume(0)
m_shape = geom.get_shape(m_volume)
l_volume = self.get_builder(2).get_volume(0)
l_shape = geom.get_shape(l_volume)
# small
small_center = -0.5 * self.y_gap - m_shape.dy + self.y_offset_sm
pos = geom.structure.Position(None, y=small_center)
place = geom.structure.Placement(None, volume=s_volume, pos=pos)
children.append(place)
maxyext = max(maxyext, abs(small_center - s_shape.dy))
# medium
medium_center = 0.5 * self.y_gap + s_shape.dy + self.y_offset_sm
pos = geom.structure.Position(None, y=medium_center)
place = geom.structure.Placement(None, volume=m_volume, pos=pos)
children.append(place)
maxyext = max(maxyext, medium_center + m_shape.dy)
# large
large_center = Q('0 m') + self.y_offset_ll
large_offset = s_shape.dz + l_shape.dz + self.z_gap
posm = geom.structure.Position(None,
z=-1 * large_offset,
y=large_center)
posp = geom.structure.Position(None,
z=+1 * large_offset,
y=large_center)
children += [
geom.structure.Placement(None, volume=l_volume, pos=posm),
geom.structure.Placement(None, volume=l_volume, pos=posp)
]
maxyext = max(maxyext, large_center + l_shape.dy)
# envelope
# fixme: maybe want to add 0.5*self.z_gap to dz
env_shape = geom.shapes.Box(None,
dx=l_shape.dx,
dy=maxyext,
dz=large_offset + l_shape.dz)
env_vol = geom.structure.Volume('vol' + self.name,
material=self.material,
shape=env_shape,
placements=children)
self.add_volume(env_vol)
def construct(self, geom):
dzm = self.depth()
dzm = dzm/2.0 # Box() requires half dimensions
# make the mother volume
name = self.output_name
if self.type == "Box":
layer_shape = geom.shapes.Box(name, dx=(self.dx)/ 2.0, dy=(self.dy)/2.0, dz=(self.depth()) /2.0)
layer_lv = geom.structure.Volume(name + "_vol", shape=layer_shape, material=self.material)
elif self.type == "Intersection":
layer_shape_full = geom.shapes.PolyhedraRegular(name+"_full", numsides=self.nsides, sphi=pi/8, rmin=self.rmin, rmax=self.rmax, dz=(self.depth()))
layer_quadrant = geom.shapes.Box(name+"_quadrant", dx=self.quadr, dy=self.quadr, dz=(self.depth()) /2.0)
layer_quad_pos = geom.structure.Position(name+"_quadrant_pos", x=self.quadr, y=self.quadr)
layer_shape = geom.shapes.Boolean(name, type='intersection', first=layer_shape_full, second=layer_quadrant, pos=layer_quad_pos)
layer_lv = geom.structure.Volume(name +"_vol", shape=layer_shape, material=self.material)
# no skipped space before the first layer
skip = Q("0mm")
cntr = 1
zloc = Q("0mm")
for dz, lspace, mat, active in zip(self.dz, self.lspacing, self.mat, self.active):
sname = (layer_shape.name + "_slice%i" % cntr)
zloc = zloc + skip + dz / 2.0
if self.type == "Box":
slice_shape = geom.shapes.Box(sname, self.dx/2.0, self.dy/2.0, dz / 2.0)
slice_lv = geom.structure.Volume(sname + "_vol", material=mat, shape=slice_shape)
elif self.type == "Intersection":
slice_shape_full = geom.shapes.PolyhedraRegular(sname+"_full", numsides=self.nsides, sphi=pi/8, rmin=self.rmin, rmax=self.rmax, dz=dz)
slice_quadrant = geom.shapes.Box(sname+"_quadrant", dx=self.quadr, dy=self.quadr, dz=dz/2.0)
slice_quad_pos = geom.structure.Position(sname+"_quadrant_pos", x=self.quadr, y=self.quadr)
slice_shape = geom.shapes.Boolean(sname, type='intersection', first=slice_shape_full, second=slice_quadrant, pos=slice_quad_pos)
slice_lv = geom.structure.Volume(sname + "_vol", material=mat, shape=slice_shape)
if active:
#slice_lv.params.append(("SensDet", name))
slice_lv.params.append(("SensDet", self.sensdet_name))
# dzm is the half depth of the mother volume
# we need to subtract it off to position layers
# relative to the center of the mother
slice_pos = geom.structure.Position(sname + "_pos", x='0mm', y='0mm', z=zloc - dzm)
slice_pla = geom.structure.Placement(sname + "_pla", volume=slice_lv, pos=slice_pos)
layer_lv.placements.append(slice_pla.name)
skip = dz / 2.0 + lspace # set the skipped space before the next layer
cntr += 1
self.add_volume(layer_lv)
def construct_XXST(self, geom, tubeDirection, name, halflength,
halfCrosslength, modtype):
main_shape = geom.shapes.Box(name,
dx=self.planeXXThickness / 2.0,
dy=halfCrosslength,
dz=halflength)
main_lv = geom.structure.Volume("vol" + name,
material="Air35C",
shape=main_shape)
if tubeDirection == "hh" and halflength == self.kloeTrkRegHalfDx:
if modtype == "gra":
straw_lv = self.horizontalST_Ar
else:
straw_lv = self.horizontalST_Xe
else:
straw_lv = self.construct_strawtube(geom, name + "_ST", halflength,
modtype)
Nstraw = int(
(2 * halfCrosslength - self.strawRadius) / self.strawRadius / 2.0)
# print "name",name,"Nstraw ",Nstraw*2," length ",halflength*2
# return main_lv
# self.Nstraw_list.append(Nstraw*2)
for i in range(Nstraw):
pos1 = [
-self.planeXXThickness / 2.0 + self.strawRadius,
halfCrosslength - (2 * i + 1) * self.strawRadius,
Q('0m')
]
straw_pos1 = geom.structure.Position("pos_" + name + "_" + str(i),
pos1[0], pos1[1], pos1[2])
straw_pla1 = geom.structure.Placement("pla_" + name + "_" + str(i),
volume=straw_lv,
pos=straw_pos1)
main_lv.placements.append(straw_pla1.name)
pos2 = [
self.planeXXThickness / 2.0 - self.strawRadius,
halfCrosslength - (2 * i + 2) * self.strawRadius,
Q('0m')
]
straw_pos2 = geom.structure.Position(
"pos_" + name + "_" + str(i + Nstraw), pos2[0], pos2[1],
pos2[2])
straw_pla2 = geom.structure.Placement("pla_" + name + "_" +
str(i + Nstraw),
volume=straw_lv,
pos=straw_pos2)
main_lv.placements.append(straw_pla2.name)
return main_lv
def configure(self,
material="Air",
dx=Q("50cm"),
dy=Q("50cm"),
dz=Q("1cm"),
**kwds):
print("Configuring a detector layer " + self.name)
self.material = material
self.dx = dx
self.dy = dy
self.dz = dz
self.otherKeywords = kwds
pass