def construct(self, geom): ########################### Above is math, below is GGD ########################### materials.define_materials(geom) noRotate = geom.structure.Rotation( 'noRotate', '0deg', '0deg', '0deg' ) r90aboutX = geom.structure.Rotation( 'r90aboutX', '90deg', '0deg', '0deg' ) rminus90aboutX = geom.structure.Rotation( 'rminus90aboutX', '-90deg', '0deg', '0deg' ) r90aboutY = geom.structure.Rotation( 'r90aboutY', '0deg', '90deg', '0deg' ) r180aboutY = geom.structure.Rotation( 'r180aboutY', '0deg', '180deg','0deg' ) rminus90aboutY = geom.structure.Rotation( 'rminus90aboutY', '0deg', '-90deg', '0deg' ) r90aboutZ = geom.structure.Rotation( 'r90aboutZ', '0deg', '0deg', '90deg' ) r90aboutXZ = geom.structure.Rotation( 'r90aboutXZ', '90deg', '0deg', '90deg' ) r90aboutYZ = geom.structure.Rotation( 'r90aboutYZ', '0deg', '90deg', '90deg' ) r90aboutXminusZ = geom.structure.Rotation( 'r90aboutXminusZ', '-90deg', '0deg', '90deg' ) r90aboutYminusZ = geom.structure.Rotation( 'r90aboutYminusZ', '0deg', '-90deg', '90deg' ) main_lv, main_hDim = ltools.main_lv( self, geom, "Box") self.add_volume(main_lv) # get Detector Enclosure and its logic volume de_sb = self.get_builder() de_lv = de_sb.get_volume() postemp = [Q('0m'),Q('0m'),Q('0m')] if self.DetEncPosition!=None: postemp=self.DetEncPosition detEnc_pos = geom.structure.Position(de_lv.name+'_pos', postemp[0], postemp[1], postemp[2]) rot=[Q("0deg"),Q("0deg"),Q("0deg")] if self.DetEncRotation!=None: rot=self.DetEncRotation detEnc_rot = geom.structure.Rotation(de_lv.name+'_rot', rot[0], rot[1], rot[2]) detEnc_pla = geom.structure.Placement(de_lv.name+'_pla', volume=de_lv, pos=detEnc_pos,rot=detEnc_rot) main_lv.placements.append(detEnc_pla.name)
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) builders = self.get_builders() second_lv = builders[0].get_volume() second_loc = self.Positions[0] third_lv = builders[1].get_volume() third_loc = self.Positions[1] third_pos = geom.structure.Position(third_lv.name + '_pos', third_loc[0], third_loc[1], third_loc[2]) third_pla = geom.structure.Placement(third_lv.name + '_pla', volume=third_lv, pos=third_pos) second_lv.placements.append(third_pla.name) second_pos = geom.structure.Position(second_lv.name + '_pos', second_loc[0], second_loc[1], second_loc[2]) second_pla = geom.structure.Placement(second_lv.name + '_pla', volume=second_lv, pos=second_pos) main_lv.placements.append(second_pla.name)
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") self.add_volume(main_lv) # definition local rotation rotation1 = geom.structure.Rotation(self.name + '_rot1', str(self.Rotation1[0]), str(self.Rotation1[1]), str(self.Rotation1[2])) # get sub-builders and its logic volume sb = self.get_builder() el_lv = sb.get_volume() # get the sub-builder dimension, using its shape el_shape = geom.store.shapes.get(el_lv.shape) el_dim = [el_shape.dx, el_shape.dy, el_shape.dz] # calculate half dimension of element plus the gap projected to the transportation vector sb_dim_v1 = [ t * (d + 0.5 * self.InsideGap1) for t, d in zip(self.TranspV1, el_dim) ] sb_dim_v2 = [ t * (d + 0.5 * self.InsideGap2) for t, d in zip(self.TranspV2, el_dim) ] # lower edge, the ule dimension projected on transportation vector low_end_v1 = [ -t * d + ed for t, d, ed in zip(self.TranspV1, main_hDim, sb_dim_v1) ] low_end_v2 = [ -t * d + ed for t, d, ed in zip(self.TranspV2, main_hDim, sb_dim_v2) ] for elem2 in xrange(self.NElements2): for elem1 in xrange(self.NElements1): # calculate the distance for n elements = i*2*halfdinemsion temp_v = [ elem1 * 2 * d1 + elem2 * 2 * d2 for d1, d2 in zip(sb_dim_v1, sb_dim_v2) ] # define the position for the element based on edge temp_v = [ te + l1 + l2 for te, l1, l2 in zip(temp_v, low_end_v1, low_end_v2) ] # defining position, placement, and finally insert into the ule. el_pos = geom.structure.Position( self.name + "_el" + str(elem1) + '_' + str(elem2) + '_pos', temp_v[0], temp_v[1], temp_v[2]) el_pla = geom.structure.Placement( self.name + "_el" + str(elem1) + '_' + str(elem2) + '_pla', volume=el_lv, pos=el_pos, rot=rotation1) main_lv.placements.append(el_pla.name)
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) for i, sb in enumerate(self.get_builders()): Pos = [Q("0m"), Q("0m"), Q("0m")] Rot = [Q("0deg"), Q("0deg"), Q("0deg")] if self.Positions != None: Pos = self.Positions[i] if self.Rotations != None: Rot = self.Rotations[i] sb_lv = sb.get_volume() sb_pos = geom.structure.Position(sb_lv.name + '_pos', Pos[0], Pos[1], Pos[2]) sb_rot = geom.structure.Rotation(sb_lv.name + '_rot', Rot[0], Rot[1], Rot[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 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 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 construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") TranspV = [0, 0, 1] if self.TranspV != None: TranspV = self.TranspV ltools.placeBooleanBuilders(self, geom, main_lv, TranspV)
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") self.add_volume(main_lv) builders = self.get_builders() sb_central = builders[0] sb_surr = builders[1] ltools.placeSurroundBuilders(main_lv, sb_central, sb_surr, self.InsideGap, geom)
def construct(self, geom): """ Construct the geometry for Generic Shape. :returns: None """ main_lv, main_hDim = ltools.main_lv(self, geom, self.Shape) if self.AuxParams != None: ltools.addAuxParams(self, main_lv) self.add_volume(main_lv)
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") self.add_volume(main_lv) if self.NElements != None: TranspV = [1, 0, 0] if self.TranspV != None: TranspV = self.TranspV ltools.placeBuilders(self, geom, main_lv, TranspV) else: print("**Warning, no Elements to place inside " + self.name)
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") self.add_volume(main_lv) # definition local rotation rotation = geom.structure.Rotation(self.name + '_rot', str(self.Rotation[0]), str(self.Rotation[1]), str(self.Rotation[2])) # get sub-builders and its logic volume sb = self.get_builder() sb_lv = sb.get_volume() #top sbtop_pos = geom.structure.Position( self.name + sb_lv.name + '_top_pos', Q('0m'), Q('4m'), Q('5.2m')) sbtop_pla = geom.structure.Placement(self.name + sb_lv.name + '_top_pla', volume=sb_lv, pos=sbtop_pos, rot=rotation) main_lv.placements.append(sbtop_pla.name) #bottom sbbot_pos = geom.structure.Position( self.name + sb_lv.name + '_bot_pos', Q('0m'), Q('-4m'), Q('5.2m')) sbbot_pla = geom.structure.Placement(self.name + sb_lv.name + '_bot_pla', volume=sb_lv, pos=sbbot_pos, rot=rotation) main_lv.placements.append(sbbot_pla.name) #left sbleft_pos = geom.structure.Position( self.name + sb_lv.name + '_left_pos', Q('4m'), Q('0m'), Q('5.2m')) sbleft_pla = geom.structure.Placement(self.name + sb_lv.name + '_left_pla', volume=sb_lv, pos=sbleft_pos, rot=rotation) main_lv.placements.append(sbleft_pla.name) #right sbright_pos = geom.structure.Position( self.name + sb_lv.name + '_right_pos', Q('-4m'), Q('0m'), Q('5.2m')) sbright_pla = geom.structure.Placement(self.name + sb_lv.name + '_right_pla', volume=sb_lv, pos=sbright_pos, rot=rotation) main_lv.placements.append(sbright_pla.name)
def construct(self, geom): """ Construct the geometry for Rectangular Bar. :returns: None """ main_lv, main_hDim = ltools.main_lv(self, geom, "Tubs") if self.AuxParams != None: ltools.addAuxParams(self, main_lv) self.add_volume(main_lv)
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] if self.TranspV != None: TranspV = self.TranspV ltools.placeUserLocationBuilders(self, geom, main_lv, TranspV)
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) builders = self.get_builders() sb_central = builders[0] sb_top = builders[1] sb_side = builders[2] ltools.placeCrossBuilders(main_lv, sb_central, sb_top, sb_side, self, geom)
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") print("KLOEBuilder::construct()") print("main_lv = " + main_lv.name) self.add_volume(main_lv) self.build_yoke(main_lv, geom) self.build_solenoid(main_lv, geom) self.build_ecal(main_lv, geom) self.build_tracker(main_lv, geom) self.build_muon_system(main_lv, geom) print("printing main_lv: " + str(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]] pos = [Q('0m'), Q('0m'), Q('0m')]
def construct(self, geom): main_lv, main_hDim = ltools.main_lv(self, geom, "Box") print("KLOEBuilder::construct()") print("main_lv = " + main_lv.name) self.add_volume(main_lv) self.build_yoke(main_lv, geom) self.build_solenoid(main_lv, geom) self.build_ecal(main_lv, geom) #self.build_muon_system(main_lv,geom) if (self.BuildGAR is True) or (self.BuildSTT is True): self.build_tracker(main_lv, geom) if (self.BuildSTTFULL is True): self.build_sttfull(main_lv, geom) if (self.Build3DST is True): self.build_3DST(main_lv, geom) if (self.Build3DSTwithSTT is True): self.build_3DSTwithSTT(main_lv, geom) print("printing main_lv: " + str(main_lv))
def construct(self, geom): """ Construct the geometry for Straw Tube Bar. :returns: None """ main_lv, main_hDim = ltools.main_lv(self, geom, "Box") if isinstance(self.Sensitive, str): main_lv.params.append(("SensDet", self.Sensitive)) self.add_volume(main_lv) copper_shape = geom.shapes.Tubs(self.name + "_copper", rmin=self.halfCopperDimension["rmin"], rmax=self.halfCopperDimension["rmax"], dz=self.halfCopperDimension["dz"]) copper_lv = geom.structure.Volume(self.name + "_copper_lv", material="Copper", shape=copper_shape) copper_pla = geom.structure.Placement(self.name + "_copper_pla", volume=copper_lv) main_lv.placements.append(copper_pla.name)
def construct( self, geom ): # main volume main_lv, main_hDim = ltools.main_lv( self, geom, "Box") print( "KLOESTT::construct()") print( " main_lv = "+ main_lv.name) self.add_volume( main_lv ) rot=[Q("0deg"),Q("0deg"),Q("0deg")] if self.modRot!=None: rot=self.modRot mod_builder=self.get_builder("STTModule") mod_lv=mod_builder.get_volume() # build modules starting from -z edge of KLOESTT # startingOffset moves us away from the edge (e.g., to center the array of modules in z) startz=-main_hDim[2]+self.startingOffset for imod in range(self.nModules): loc=[Q("0cm"),Q("0cm"),startz+(self.modWidth+self.gap)*(imod+0.5)] basename=self.name+'_'+mod_lv.name+'_'+str(imod) print( "Placing STTModule " + basename+" at "+str(loc)) mod_pos=geom.structure.Position(basename+'_pos',loc[0],loc[1],loc[2]) mod_rot=geom.structure.Rotation(basename+'_rot',rot[0],rot[1],rot[2]) mod_pla=geom.structure.Placement(basename+'_pla',volume=mod_lv,pos=mod_pos,rot=mod_rot) main_lv.placements.append(mod_pla.name)
def construct(self, geom): start_time = tm.time() main_lv, main_hDim = ltools.main_lv(self, geom, "Tubs") print("KLOESTTFULL::construct()") print(" main_lv = " + main_lv.name) self.add_volume(main_lv) # LAr target LAr_tgt_lv = self.construct_LAr_target(geom) LAr_tgt_pla = geom.structure.Placement("LAr_tgt_pla", volume=LAr_tgt_lv) main_lv.placements.append(LAr_tgt_pla.name) # 2 XY module after LAr target currentXPos = -self.kloeTrkRegRadius + self.LArThickness cos = 0.0 halfHeight = 0.0 for imod in range(self.nFrontST): currentXPos += imod * 2 * self.planeXXThickness cos = currentXPos / self.kloeTrkRegRadius halfHeight = self.kloeTrkRegRadius * math.sqrt(1 - cos * cos) name = "frontST" + str(imod) frontST_lv = self.construct_XYSTPlane(geom, name + "_vol", halfHeight, self.kloeTrkRegHalfDx, "stGas_Ar19") frontST_pos = geom.structure.Position( name + "_pos", currentXPos + self.planeXXThickness, Q('0cm'), Q('0cm')) frontST_pla = geom.structure.Placement(name + "_pla", volume=frontST_lv, pos=frontST_pos) main_lv.placements.append(frontST_pla.name) currentXPos += 2 * self.planeXXThickness modBuilder = { 'C3H6Mod': self.construct_C3H6_Module, 'NoSlabMod': self.construct_NoSlab_Module, 'CMod': self.construct_C_Module } for imod in range(self.nMod_Tot): name = "sttmod" + str(imod) if ((imod - 3) % 13 == 0): modThickness = self.CModThickness modType = 2 construct_mod = modBuilder['CMod'] elif (imod > 84): modThickness = self.NoSlabModThickness modType = 3 construct_mod = modBuilder['NoSlabMod'] else: modThickness = self.C3H6ModThickness modType = 1 construct_mod = modBuilder['C3H6Mod'] if (currentXPos + 0.5 * modThickness) < 0.0: cos = currentXPos / self.kloeTrkRegRadius else: cos = (currentXPos + modThickness) / self.kloeTrkRegRadius halfHeight = self.kloeTrkRegRadius * math.sqrt(1 - cos * cos) halfDimension = { 'dx': modThickness / 2.0, 'dy': halfHeight, 'dz': self.kloeTrkRegHalfDx } mod_lv = construct_mod(geom, name, halfDimension) mod_pos = geom.structure.Position(name + "_pos", currentXPos + 0.5 * modThickness, Q('0cm'), Q('0cm')) mod_pla = geom.structure.Placement(name + "_pla", volume=mod_lv, pos=mod_pos) main_lv.placements.append(mod_pla.name) currentXPos += modThickness end_time = tm.time() elapsed_time = end_time - start_time print("elapsed time:" + str(elapsed_time))
def construct(self, geom): mod_types = ["C3H6Mod", "C3H6Mod", "C3H6Mod"] for i in range(6): for j in range(13): if j == 0: mod_types.append("CMod") else: mod_types.append("C3H6Mod") mod_types.append("CMod") mod_types.append("C3H6Mod") mod_types.append("C3H6Mod") mod_types.append("C3H6Mod") mod_types.append("NoSlabMod") mod_types.append("NoSlabMod") mod_types.append("NoSlabMod") mod_types.append("NoSlabMod") mod_types.append("NoSlabMod") print(mod_types) modthicknesses = { "NoSlabMod": self.noSlabModThickness, "CMod": self.cModThickness, "C3H6Mod": self.C3H6ModThickness } ############################## the main tube ####################################### main_lv, main_hDim = ltools.main_lv(self, geom, "Tubs") print("KLOESTTFULL::construct()") print(" main_lv = " + main_lv.name) self.add_volume(main_lv) ######################################## liq Argon ################################# self.construct_LAr_target(main_lv, geom) ##################################################################################### pos_Slab_in_C3H6Mod = geom.structure.Position( "pos_Slab_in_C3H6Mod", -self.C3H6ModThickness / 2.0 + self.slabThickness / 2.0, "0cm", "0cm") pos_foilchunk_in_C3H6Mod = geom.structure.Position( "pos_foilchunk_in_C3H6Mod", -self.C3H6ModThickness / 2.0 + self.slabThickness + self.totfoilThickness / 2.0, "0cm", "0cm") pos_ST_in_C3H6Mod = geom.structure.Position( "pos_ST_in_C3H6Mod", self.C3H6ModThickness / 2.0 - self.planeXXThickness, "0cm", "0cm") pos_Graphite_in_Cmod = geom.structure.Position( "pos_Graphite_in_Cmod", -self.cModThickness / 2.0 + self.graphiteThickness / 2.0, "0cm", "0cm") pos_ST_in_Cmod = geom.structure.Position( "pos_ST_in_Cmod", self.cModThickness / 2.0 - self.planeXXThickness, "0cm", "0cm") pos_foilchunk_in_NoSlabMod = geom.structure.Position( "pos_foilchunk_in_NoSlabMod", -self.noSlabModThickness / 2.0 + self.totfoilThickness / 2.0, "0cm", "0cm") pos_ST_in_NoSlabMod = geom.structure.Position( "pos_ST_in_NoSlabMod", self.noSlabModThickness / 2.0 - self.planeXXThickness, "0cm", "0cm") pos_hh_in_ST = geom.structure.Position("pos_hh_in_ST", -self.planeXXThickness / 2.0, "0cm", "0cm") pos_vv_in_ST = geom.structure.Position("pos_vv_in_ST", self.planeXXThickness / 2.0, "0cm", "0cm") pos_straw2relative = geom.structure.Position( "pos_straw2relative", self.strawRadius * self.sqrt3, self.strawRadius, Q('0m')) self.fiveFoilPositions = [] self.foilPositionsInFive = [] for i in range(self.nfoil / 5): self.fiveFoilPositions.append( geom.structure.Position( "pos_fiveFoilPositions_" + str(i), -self.totfoilThickness / 2.0 + self.fiveFoilThickness / 2.0 + i * (self.fiveFoilThickness + self.foilGap), Q('0m'), Q('0m'))) for i in range(5): self.foilPositionsInFive.append( geom.structure.Position("pos_foilInFive_" + str(i), (self.foilThickness + self.foilGap) * (i - 2), Q('0m'), Q('0m'))) self.horizontalST_Xe = self.construct_strawtube( geom, "horizontalST_Xe", self.kloeTrkRegHalfDx, "C3H6Mod") self.horizontalST_Ar = self.construct_strawtube( geom, "horizontalST_Ar", self.kloeTrkRegHalfDx, "CMod") ######################################## Front ST ################################# usedLength = self.liqArThickness ratio = (self.kloeTrkRegRadius - usedLength) / self.kloeTrkRegRadius height = self.kloeTrkRegRadius * math.sqrt(1 - ratio * ratio) module_lv = self.construct_strawplane( geom, "frontST", height, "gra" ) # every time there is no raditor (with foils) we use Ar instead pos_frontST1 = geom.structure.Position( "pos_frontST1", -self.kloeTrkRegRadius + usedLength + self.planeXXThickness, "0cm", "0cm") pos_frontST2 = geom.structure.Position( "pos_frontST2", -self.kloeTrkRegRadius + usedLength + 3 * self.planeXXThickness, "0cm", "0cm") frontST_pla1 = geom.structure.Placement("pla_frontST1", volume=module_lv, pos=pos_frontST1, copynumber=0) frontST_pla2 = geom.structure.Placement("pla_frontST2", volume=module_lv, pos=pos_frontST2, copynumber=1) main_lv.placements.append(frontST_pla1.name) main_lv.placements.append(frontST_pla2.name) usedLength += self.frontStrawThickness ##################################################################################### nModule = 1 for imod in range(nModule): print("### imod ### ", imod) print("### type ### ", mod_types[imod]) ModThickness = modthicknesses[mod_types[imod]] loc = [ usedLength - self.kloeTrkRegRadius + 0.5 * ModThickness, Q("0cm"), Q("0cm") ] if (usedLength + 0.5 * ModThickness) < self.kloeTrkRegRadius: ratio = (self.kloeTrkRegRadius - usedLength) / self.kloeTrkRegRadius else: ratio = (usedLength - self.kloeTrkRegRadius + ModThickness) / self.kloeTrkRegRadius height = self.kloeTrkRegRadius * math.sqrt(1 - ratio * ratio) halfDimension = { 'dx': ModThickness / 2.0, 'dy': height, 'dz': self.kloeTrkRegHalfDx } name = "STT_" + mod_types[imod] + "_" + str(imod) if mod_types[imod] == "NoSlabMod": module_lv = self.construct_noSlabModule( geom, name, self.Material, halfDimension) elif mod_types[imod] == "CMod": module_lv = self.construct_cModule(geom, name, self.Material, halfDimension) else: module_lv = self.construct_C3H6Module(geom, name, self.Material, halfDimension) module_pos = geom.structure.Position("pos_" + name, loc[0], loc[1], loc[2]) module_pla = geom.structure.Placement("pla_" + name, volume=module_lv, pos=module_pos, copynumber=imod) main_lv.placements.append(module_pla.name) usedLength += ModThickness # print("%2d %8s %10.3f %10.3f"%(imod,mod_types[imod],(usedLength-ModThickness).magnitude,usedLength.magnitude)) end_time = time.time() print("time diff:", end_time - self.start_time)
def construct( self, geom ): # PARTICULAR GEOMETRY, IT IS NO GENERAL, NO EVERYONE CAN USE #(xyz- = xyzn, xyz+ = xyzp) main_lv, main_hDim = ltools.main_lv( self, geom, "Box") sb_boolean_shape = geom.store.shapes.get(main_lv.shape) builders = self.get_builders() #XY (-Z) sb_xyzn = builders[0] sb_xyzn_lv = sb_xyzn.get_volume() sb_xyzn_shape = geom.store.shapes.get(sb_xyzn_lv.shape) sb_pos = geom.structure.Position(self.name+'_pos_xyzn', Q('0cm'), Q('0cm'), -main_hDim[2]+sb_xyzn.halfDimension['dz'] ) sb_boolean_shape = geom.shapes.Boolean( self.name+'_xyzn', type='intersection', first=sb_boolean_shape, second=sb_xyzn_shape, pos=sb_pos) #XY (+Z) sb_xyzp = builders[1] sb_xyzp_lv = sb_xyzp.get_volume() sb_xyzp_shape = geom.store.shapes.get(sb_xyzp_lv.shape) sb_pos = geom.structure.Position(self.name+'_pos_xyzp', Q('0cm'), Q('0cm'), main_hDim[2]-sb_xyzp.halfDimension['dz'] ) sb_boolean_shape = geom.shapes.Boolean( self.name+'_xyzp', type='union', first=sb_boolean_shape, second=sb_xyzp_shape, pos=sb_pos) #YZ (-X) sb_yzxn = builders[2] sb_yzxn_lv = sb_yzxn.get_volume() sb_yzxn_shape = geom.store.shapes.get(sb_yzxn_lv.shape) sb_pos = geom.structure.Position(self.name+'_pos_yzxn', -main_hDim[0]+sb_yzxn.halfDimension['dx'], Q('0cm'), Q('0cm') ) sb_boolean_shape = geom.shapes.Boolean( self.name+'_yzxn', type='union', first=sb_boolean_shape, second=sb_yzxn_shape, pos=sb_pos) #YZ (+X) sb_yzxp = builders[3] sb_yzxp_lv = sb_yzxp.get_volume() sb_yzxp_shape = geom.store.shapes.get(sb_yzxp_lv.shape) sb_pos = geom.structure.Position(self.name+'_pos_yzxp', +main_hDim[0]-sb_yzxp.halfDimension['dx'], Q('0cm'), Q('0cm') ) sb_boolean_shape = geom.shapes.Boolean( self.name+'_yzxp', type='union', first=sb_boolean_shape, second=sb_yzxp_shape, pos=sb_pos) #XZ (-Y) sb_xzyn = builders[4] sb_xzyn_lv = sb_xzyn.get_volume() sb_xzyn_shape = geom.store.shapes.get(sb_xzyn_lv.shape) sb_pos = geom.structure.Position(self.name+'_pos_xzyn', Q('0cm'), -main_hDim[1]+sb_xzyn.halfDimension['dy']+Q('20cm'), Q('0cm') ) sb_boolean_shape = geom.shapes.Boolean( self.name+'_xzyn', type='union', first=sb_boolean_shape, second=sb_xzyn_shape, pos=sb_pos) sb_boolean_lv = geom.structure.Volume('vol'+sb_boolean_shape.name, material=self.Material, shape=sb_boolean_shape) if isinstance(self.Sensitive,str): sb_boolean_lv.params.append(("SensDet",self.Sensitive)) if isinstance(self.BField,str): sb_boolean_lv.params.append(("BField",self.BField)) if isinstance(self.EField,str): sb_boolean_lv.params.append(("EField",self.EField)) self.add_volume( sb_boolean_lv )
def construct(self, geom): # main volume main_lv, main_hDim = ltools.main_lv(self, geom, "Box") print("STTModule::construct()") print(" main_lv = " + main_lv.name) self.add_volume(main_lv) # Straw Plane 1 plane1_builder = self.get_builder("STTPlane1") print("plane1_builder=" + str(plane1_builder)) plane1_lv = plane1_builder.get_volume() plane1_pos = geom.structure.Position(self.name + '_Plane1_pos', self.centerPlane1[0], self.centerPlane1[1], self.centerPlane1[2]) plane1_rot = geom.structure.Rotation(self.name + '_Plane1_rot', self.rotationPlane1[0], self.rotationPlane1[1], self.rotationPlane1[2]) plane1_pla = geom.structure.Placement(self.name + '_Plane1_pla', volume=plane1_lv, pos=plane1_pos, rot=plane1_rot) main_lv.placements.append(plane1_pla.name) # Straw Plane 2 plane2_builder = self.get_builder("STTPlane2") print("plane2_builder=" + str(plane2_builder)) plane2_lv = plane2_builder.get_volume() plane2_pos = geom.structure.Position(self.name + '_Plane2_pos', self.centerPlane2[0], self.centerPlane2[1], self.centerPlane2[2]) plane2_rot = geom.structure.Rotation(self.name + '_Plane2_rot', self.rotationPlane2[0], self.rotationPlane2[1], self.rotationPlane2[2]) plane2_pla = geom.structure.Placement(self.name + '_Plane2_pla', volume=plane2_lv, pos=plane2_pos, rot=plane2_rot) main_lv.placements.append(plane2_pla.name) # build the 4 radiators if self.radiators: # center of the radiator modules along y radiator_position = [ [ self.centerPlane1[0], self.centerPlane1[1] - self.radiatorOffset, self.centerPlane1[2] ], [ self.centerPlane1[0], self.centerPlane1[1] + self.radiatorOffset, self.centerPlane1[2] ], [ self.centerPlane2[0], self.centerPlane2[1] - self.radiatorOffset, self.centerPlane2[2] ], [ self.centerPlane2[0], self.centerPlane2[1] + self.radiatorOffset, self.centerPlane2[2] ] ] radiator_rotation = [[ self.rotationPlane1[0], self.rotationPlane1[1], self.rotationPlane1[2] ], [ self.rotationPlane1[0], self.rotationPlane1[1], self.rotationPlane1[2] ], [ self.rotationPlane2[0], self.rotationPlane2[1], self.rotationPlane2[2] ], [ self.rotationPlane2[0], self.rotationPlane2[1], self.rotationPlane2[2] ]] radiator_hd = [ self.radiator1HalfDimension, self.radiator1HalfDimension, self.radiator2HalfDimension, self.radiator2HalfDimension ] radiator_name = ['1A', '1B', '2A', '2B'] for pos, rot, hd, rname in zip(radiator_position, radiator_rotation, radiator_hd, radiator_name): basename = 'STTModule_Radiator_' + rname rad_shape = geom.shapes.Box(basename, hd[0], hd[1], hd[2]) rad_lv = geom.structure.Volume(basename + "_vol", material="RadiatorBlend", shape=rad_shape) rad_pos = geom.structure.Position(basename + "_pos", pos[0], pos[1], pos[2]) rad_rot = geom.structure.Rotation(basename + "_rot", rot[0], rot[1], rot[2]) rad_pla = geom.structure.Placement(basename + "_pla", volume=rad_lv, pos=rad_pos, rot=rad_rot) main_lv.placements.append(rad_pla.name)
def construct(self, geom): """ Construct the geometry. The standard geometry consists of a cylindrical vessel filled with gas. Two TPC sensitive volumes are placed within the gas, as is a central electrode. After that, a readout plane and field cage are added to each TPC. args: geom: The geometry """ # If using a custom gas, define here if self.Composition is not None: geom.matter.Mixture(self.GasType, density=self.GasDensity, components=self.Composition) main_lv, main_hDim = ltools.main_lv(self, geom, 'Tubs') print('GasTPCBuilder::construct()') print('main_lv = ' + main_lv.name) self.add_volume(main_lv) # Construct the chamber tpc_chamber_shape = geom.shapes.Tubs('TPCChamber', rmax=self.ChamberRadius, dz=self.ChamberLength * 0.5) tpc_chamber_lv = geom.structure.Volume('volTPCChamber', material=self.ChamberMaterial, shape=tpc_chamber_shape) if self.BField is not None: tpc_chamber_lv.params.append(('BField', self.BField)) # Place into main LV pos = [Q('0m'), Q('0m'), Q('0m')] tpc_chamber_pos = geom.structure.Position('TPCChamber_pos', pos[0], pos[1], pos[2]) tpc_chamber_pla = geom.structure.Placement('TPCChamber_pla', volume=tpc_chamber_lv, pos=tpc_chamber_pos) main_lv.placements.append(tpc_chamber_pla.name) # Add in the gas volume tpc_gas_shape = geom.shapes.Tubs( 'TPCGas', rmax=self.ChamberRadius - self.WallThickness, dz=0.5 * self.ChamberLength - self.EndCapThickness) tpc_gas_lv = geom.structure.Volume('volTPCGas', material=self.GasType, shape=tpc_gas_shape) # Place gas into the chamber pos = [Q('0m'), Q('0m'), Q('0m')] tpc_gas_pos = geom.structure.Position('TPCGas_pos', pos[0], pos[1], pos[2]) tpc_gas_pla = geom.structure.Placement('TPCGas_pla', volume=tpc_gas_lv, pos=tpc_gas_pos) tpc_chamber_lv.placements.append(tpc_gas_pla.name) # Construct the TPCs if not self.BuildEmpty: self.construct_tpcs(geom, tpc_gas_lv)
def construct(self, geom): # liqAR STXXYY STXXYY ||||| 3+ 1+ 12 + 1 + 12 + 1 + 12 + 1 + 12+ 1 + 12+ 1 + 12 + 1 + 3 |||| 5 no_slab modules sqrt3 = 1.7320508 kloeTrkRegRadius = self.kloeVesselRadius - self.extRadialgap kloeTrkRegHalfDx = self.kloeVesselHalfDx - self.extLateralgap planeXXThickness = self.strawRadius * (2 + sqrt3) totfoilThickness = self.nfoil * self.foilThickness + (self.nfoil - 1) * self.foilGap regModThickness = planeXXThickness * 2 + totfoilThickness + self.slabThickness cModThickness = planeXXThickness * 2 + self.graphiteThickness noSlabModThickness = planeXXThickness * 2 + totfoilThickness self.planeXXThickness = planeXXThickness self.totfoilThickness = totfoilThickness self.kloeTrkRegHalfDx = kloeTrkRegHalfDx self.kloeTrkRegRadius = kloeTrkRegRadius self.pureSTModThickness = planeXXThickness * 4 self.SingleSTModThickness = planeXXThickness * 2 self.regModThickness = regModThickness self.noSlabModThickness = noSlabModThickness test_nfront = (kloeTrkRegRadius - self.Depth3DST / 2 - self.offset3DSTcenter) / (self.pureSTModThickness + self.pureSTModGap) test_nMid = self.Depth3DST / (self.pureSTModThickness + self.pureSTModGap) test_nRear2 = kloeTrkRegRadius - self.Depth3DST / 2 + self.offset3DSTcenter - ( self.pureSTModThickness + self.pureSTModGap ) * self.nRear1Mod - self.noSlabModThickness * self.nRear3Mod test_nRear2A = test_nRear2 / self.regModThickness test_nRear2B = test_nRear2 / self.noSlabModThickness print("test_nfront:", test_nfront) print("test_nMid:", test_nMid) print("test_nRear2A:", test_nRear2A) print("test_nRear2B:", test_nRear2B) self.frontGap = kloeTrkRegRadius - ( self.pureSTModThickness + self.pureSTModGap ) * self.nFrontMod - self.Depth3DST / 2 - self.offset3DSTcenter print("front gap:", self.frontGap) rearModsWidth = ( self.pureSTModThickness + self.pureSTModGap ) * self.nRear1Mod + self.regModThickness * self.nRear2Mod + self.noSlabModThickness * self.nRear3Mod self.rearGap = kloeTrkRegRadius - self.Depth3DST / 2 + self.offset3DSTcenter - rearModsWidth print("rearModsWidth:", rearModsWidth) print("self.rearGap:", self.rearGap) print("totfoilThickness:", totfoilThickness) print("self.slabThickness:", self.slabThickness) print("planeXXThickness:", planeXXThickness) print("regModThickness:", regModThickness) print("cModThickness:", cModThickness) print("noSlabModThickness:", noSlabModThickness) main_lv, main_hDim = ltools.main_lv(self, geom, "Tubs") self.add_volume(main_lv) # testShape = geom.shapes.Tubs("testShape", rmin=Q("2m"), rmax = Q("2.05m"), dz = self.kloeTrkRegHalfDx) # testlv = geom.structure.Volume("testlv", material="Tungsten", shape=testShape) # testpla = geom.structure.Placement("pla_test", volume=testlv) # main_lv.placements.append(testpla.name) pos_Slab_in_RegMod = geom.structure.Position( "pos_Slab_in_RegMod", -regModThickness / 2.0 + self.slabThickness / 2.0, "0cm", "0cm") pos_foilchunk_in_RegMod = geom.structure.Position( "pos_foilchunk_in_RegMod", -regModThickness / 2.0 + self.slabThickness + self.totfoilThickness / 2.0, "0cm", "0cm") pos_ST_in_RegMod = geom.structure.Position( "pos_ST_in_RegMod", regModThickness / 2.0 - planeXXThickness, "0cm", "0cm") pos_Graphite_in_Cmod = geom.structure.Position( "pos_Graphite_in_Cmod", -cModThickness / 2.0 + self.graphiteThickness / 2.0, "0cm", "0cm") pos_ST_in_Cmod = geom.structure.Position( "pos_ST_in_Cmod", cModThickness / 2.0 - planeXXThickness, "0cm", "0cm") pos_foilchunk_in_NoSlabMod = geom.structure.Position( "pos_foilchunk_in_NoSlabMod", -noSlabModThickness / 2.0 + self.totfoilThickness / 2.0, "0cm", "0cm") pos_ST_in_NoSlabMod = geom.structure.Position( "pos_ST_in_NoSlabMod", noSlabModThickness / 2.0 - planeXXThickness, "0cm", "0cm") pos_hh_in_ST = geom.structure.Position("pos_hh_in_ST", -self.planeXXThickness / 2.0, "0cm", "0cm") pos_vv_in_ST = geom.structure.Position("pos_vv_in_ST", self.planeXXThickness / 2.0, "0cm", "0cm") pos_hh1_in_doubleST = geom.structure.Position( "pos_hh1_in_doubleST", -self.planeXXThickness / 2.0 * 3, "0cm", "0cm") pos_vv1_in_doubleST = geom.structure.Position( "pos_vv1_in_doubleST", -self.planeXXThickness / 2.0, "0cm", "0cm") pos_hh2_in_doubleST = geom.structure.Position( "pos_hh2_in_doubleST", self.planeXXThickness / 2.0, "0cm", "0cm") pos_vv2_in_doubleST = geom.structure.Position( "pos_vv2_in_doubleST", self.planeXXThickness / 2.0 * 3, "0cm", "0cm") pos_oneSrawDown = geom.structure.Position("pos_oneSrawDown", "0cm", -self.strawRadius * 2, "0cm") self.foilpositions = [] for i in range(self.nfoil): self.foilpositions.append( geom.structure.Position( "pos_foilpositions_" + str(i), -self.totfoilThickness / 2.0 + self.foilThickness / 2.0 + i * (self.foilThickness + self.foilGap), Q('0m'), Q('0m'))) self.horizontalST_Xe = self.construct_strawtube( geom, "horizontalST_Xe", kloeTrkRegHalfDx, "reg") self.horizontalST_Ar = self.construct_strawtube( geom, "horizontalST_Ar", kloeTrkRegHalfDx, "gra") ############################ build front STT self.build_frontSTT(geom, main_lv) ############################ build top & bottom & side STT self.build_TopBotSTT(geom, main_lv) self.build_sideSTT(geom, main_lv) ############################ build rear STT self.build_rearSTT(geom, main_lv) ########################### build 3DST self.build_3DST(geom, main_lv)