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