Functions
	transformNodes (tree, func)
	getHist (name, makehist)
	parseKeyLayer (keystring)
	getLayer (trk, hit_idx)
	getRow (trk, hit_idx)
	isKeyLayer (trk, hit_idx, key)
	findKeyLayerMod (trk, key)
	trackToModules (trk)
	parseGeometry ()
	divideKeyLayerModulesIntoSlices (eta_vals_for_key_layer)
	getModuleToSliceMap (mod_slice_map)
	trimSlice (slice_modules, slice_tracks)
	writeRMap (slice_modules, sliceid2int)
	printOccupancies (slice_modules)
	plotSlices (sliceid2int, slice_modules)

Variables
	parser = argparse.ArgumentParser(description='Flattens Wrapper Files')
	metavar
	type
	str
	nargs
	help
	action
	default
	args = parser.parse_args()
defaultdict	defaultdictlambda = lambda (defaultdictlambda)
list	dets = ["pixel","strip"]
list	regs = ["barrel","endcap"]
list	dirs = ["phi","eta"]
dict	int2det = {1:"pixel", 0:"strip"}
dict	det2int = {v:k for k,v in int2det.items()}
dict	int2reg = {0:"barrel", 2:"endcap"}
dict	reg2int = {v:k for k,v in int2reg.items()}
dict	striprows
dict	abcchipsperrow
int	stripsperabc = 128
	stripsperrow = transformNodes(abcchipsperrow, lambda x: x * stripsperabc)
dict	rowbounds = {}
str	geom = "Unknown"
dict	layers = { "pixel": { "barrel":5, "endcap": 8 if geom=="ITK-22" else 8 }, "strip" : { "barrel":8, "endcap":12}}
dict	hists = {}
	fileList = args.inname
	Data = ROOT.TChain("ExtrapolationEngineTest")
	num_entries = min(args.evts,Data.GetEntries())
	t0 = time.clock()
	key1 = parseKeyLayer(args.keylayer)
	key2 = None
	min_eta
	max_eta
	histfile = ROOT.TFile("test.root",'recreate')
	eta_vals_for_key_layer = parseGeometry()
	nslices = args.nslices
	mod_slice_map = divideKeyLayerModulesIntoSlices(eta_vals_for_key_layer)
	slice_modules
	sliceid2int
	slice_tracks

Function Documentation

◆ divideKeyLayerModulesIntoSlices()

divideKeyLayerModulesIntoSlices ( eta_vals_for_key_layer )

Definition at line 323 of file module_driven_slicing.py.

def divideKeyLayerModulesIntoSlices(eta_vals_for_key_layer):
    key_modules_per_slice = float(len(eta_vals_for_key_layer))/nslices
    key_modules_for_slices=[[]]
 
    for i,row in enumerate(sorted(eta_vals_for_key_layer)):
        if i >= len(key_modules_for_slices)*key_modules_per_slice:
            key_modules_for_slices.append([])
        key_modules_for_slices[-1].append(row)
 
    msg.info("Modules in slices %d", key_modules_for_slices)
 
 
    
    # make a map of modules to slices
    return {m:i for i,s in enumerate(key_modules_for_slices) for m in s }
 
 
 
#--------------------------------------------------------------------------------
# Build List of Modules in Slices
#--------------------------------------------------------------------------------
 

◆ findKeyLayerMod()

findKeyLayerMod	(		trk,
			key )

Definition at line 232 of file module_driven_slicing.py.

def findKeyLayerMod(trk,key):
    # return None for events with two hits in keylayer
    mixedrows=False
    row=None
    for hit_idx in range(len(trk.SensitivePosX)):
        if isKeyLayer(trk,hit_idx,key):
            rownew= getRow(trk,hit_idx)[1]
            if row and (rownew!=row):
                mixedrows=True
            row = rownew
    return row if not mixedrows else None
 
 
 
 

◆ getHist()

getHist	(		name,
			makehist )

Definition at line 120 of file module_driven_slicing.py.

def getHist(name,makehist):
    if name not in hists:
        hists[name]=makehist(name)
    return hists[name]
 
 
#----------------------------------------------------------------------
#  Open file(s) for reading
#----------------------------------------------------------------------
# get list of files

◆ getLayer()

getLayer	(		trk,
			hit_idx )

Definition at line 171 of file module_driven_slicing.py.

def getLayer(trk,hit_idx):
    if trk.SensitiveIsPixel[hit_idx] == 0: #strip
        layer = 2*trk.SensitiveLayerDisc[hit_idx]+trk.SensitiveSide[hit_idx]
    else: #pixel
        layer = trk.SensitiveLayerDisc[hit_idx]
    return layer
 

◆ getModuleToSliceMap()

getModuleToSliceMap ( mod_slice_map )

Definition at line 345 of file module_driven_slicing.py.

def getModuleToSliceMap(mod_slice_map):
    slice_modules=defaultdict(lambda :
                              { det:{
                                  reg:{
                                      lyr:{
                                          d:defaultdict(lambda:0) for d in dirs}
                                      for lyr in range(layers[det][reg]) }
                                  for reg in regs }
                                for det in dets })
 
    slice_hists={}
    slice_tracks=defaultdict(lambda:0)
    sliceid2int={}
 
    events=0
    tracks_used=0
    missing_keylayer_hit=0
    for trk in Data:
        events = events + 1
        if events>args.evts:
            break
 
        # only process tracks in region
        if trk.StartEta > max_eta or trk.StartEta < min_eta:
            continue
 
        modules = trackToModules(trk)
 
        if not key1["lyr"] in modules[key1["det"]][key1["reg"]]:
            missing_keylayer_hit+=1
            continue
        mod1 = modules[key1["det"]][key1["reg"]][key1["lyr"]][0]
        slicenum = mod_slice_map[mod1]
        if args.test1slice and slicenum!=0:
            continue
            
        if key2:
            if not key2["lyr"] in modules[key2["det"]][key2["reg"]]:
                missing_keylayer_hit+=1
                continue
            mod2 = modules[key2["det"]][key2["reg"]][key2["lyr"]][0]
            slicenum=(slicenum,mod2)
 
 
 
        # add other modules to slice
        for det in modules:
            for reg in modules[det]:
                for lyr in modules[det][reg]:
                    modidxs=modules[det][reg][lyr]
                    slice_modules[slicenum][int2det[det]][int2reg[reg]][lyr]["eta"][modidxs[0]]+=1
                    slice_modules[slicenum][int2det[det]][int2reg[reg]][lyr]["phi"][modidxs[1]]+=1
 
                    hit_idx = modidxs[2]
 
                    if slicenum not in slice_hists:
                        sliceid2int[slicenum]=len(slice_modules)-1
                        slice_hists[slicenum]=ROOT.TH2D("rz"+str(sliceid2int[slicenum]),"rz"+str(slicenum)+"; z[mm]; r[mm]",800,-200,+600,1000,0,1000)
                    slice_hists[slicenum].Fill(trk.SensitivePosZ[hit_idx],trk.SensitivePosR[hit_idx])
 
                    hname=int2det[det]+"_"+int2reg[reg]+"_"+str(lyr)+"_"+str(modidxs[0])
                    if hname not in slice_hists:
                        slice_hists[hname]=ROOT.TH1D(hname,hname+"; z[mm]",800,-200,+600)
                    slice_hists[hname].Fill(trk.SensitivePosZ[hit_idx])
 
 
        tracks_used+=1
        slice_tracks[slicenum]+=1
 
    msg.info("Tracks Used=%d" %(tracks_used))
    msg.info("%d tracks with no keylayer hit found or multiple hits in keylayer" %(int(str(missing_keylayer_hit))))
 
    for hist in slice_hists.values():
        hist.Write()
    
    return slice_modules,sliceid2int,slice_tracks
 
 
 
#--------------------------------------------------------------------------------
# Trimming
#--------------------------------------------------------------------------------
 

◆ getRow()

getRow	(		trk,
			hit_idx )

Definition at line 178 of file module_driven_slicing.py.

def getRow(trk,hit_idx): # returns localrow,globalrow
 
    strip = trk.SensitivePhiIndex[hit_idx]
    bec=int2reg[abs(trk.SensitiveBarrelEndcap[hit_idx])]
    layer=getLayer(trk,hit_idx)
    etamod=trk.SensitiveEtaModule[hit_idx]
    localrow,globalrow=None,None    
    r=trk.SensitivePosR[hit_idx]
    z=trk.SensitivePosZ[hit_idx]
    
    # calculate row from strip
    if trk.SensitiveIsPixel[hit_idx] == 0:
 
        if "strip_number" not in hists:
            hists["strip_number"]=ROOT.TH2D("strip_number_hist",";module;strip",500,0,500,800,0,8000)
        hists["strip_number"].Fill(reg2int[bec]*100+layer*10+etamod,strip)    
 
        # this is a binned lookup to get the row number
        localrow = bisect.bisect_left(rowbounds[bec][abs(etamod)],strip)        
        
        rows_in_module=striprows[bec][layer][abs(etamod)]
        
        if localrow > rows_in_module:
           msg.error("Error row(%d) greater than number of rows in module %d" %(localrow,rows_in_module))
        globalrow=rows_in_module*etamod+localrow
 
 
        if globalrow==6:
            if "z_mod6" not in hists:
                hists["z_mod6"]=ROOT.TH2D("z_mod6",";z;lyr",2500,0,500,10,0,10)
            hists["z_mod6"].Fill(z,layer)
        
    else:        
        localrow=trk.SensitiveEtaModule[hit_idx]
        globalrow=localrow
        getHist("pixel_rz_layer"+str(layer),
                lambda n: ROOT.TH2D(n,";z[mm]; r[mm]",3000,0,+3000,1000,0,1000)).Fill(z,r)
         
    return localrow,globalrow
 
#--------------------------------------------------------------------------------
# Find module of track in key layer
#--------------------------------------------------------------------------------
 

◆ isKeyLayer()

isKeyLayer	(	trk,
		hit_idx,
		key )

Definition at line 222 of file module_driven_slicing.py.

def isKeyLayer(trk,hit_idx,key):
    if key["det"]!=trk.SensitiveIsPixel[hit_idx]:
        return False
    if key["reg"]!=abs(trk.SensitiveBarrelEndcap[hit_idx]):
        return False
    if getLayer(trk,hit_idx)!=key["lyr"]:
        return False
    return True
 
    

◆ parseGeometry()

parseGeometry ( )

Definition at line 291 of file module_driven_slicing.py.

def parseGeometry():
    eta_vals_for_key_layer=set()
    events=0
    tracks_used=0
    for trk in Data:
        events = events + 1
        if events>args.evts:
            break
 
        # only process tracks in region
        if trk.StartEta > max_eta or trk.StartEta < min_eta:
            continue
 
        modules = trackToModules(trk)
        if not key1["lyr"] in modules[key1["det"]][key1["reg"]]:
            # no hit in layer
            continue
 
        eta_vals_for_key_layer.add(modules[key1["det"]][key1["reg"]][key1["lyr"]][0])
 
        tracks_used+=1
        
    msg.info("%d eta rows:",len(eta_vals_for_key_layer))
    msg.info(sorted(eta_vals_for_key_layer))
    msg.info("Tracks Used = %d", tracks_used)
    return eta_vals_for_key_layer
 
 
    
#--------------------------------------------------------------------------------
# Define key layer in terms of modules
#--------------------------------------------------------------------------------

◆ parseKeyLayer()

parseKeyLayer ( keystring )

Definition at line 149 of file module_driven_slicing.py.

def parseKeyLayer(keystring):
    key={}
    key_det,key_reg,key_lyr = keystring.split(",")
    key["lyr"]=int(key_lyr)
    key["det"]=det2int[key_det]
    key["reg"]=reg2int[key_reg]
    return key
        

◆ plotSlices()

plotSlices	(		sliceid2int,
			slice_modules )

Definition at line 541 of file module_driven_slicing.py.

def plotSlices(sliceid2int,slice_modules):
 
    events=0
    for trk in Data:
        events = events + 1
        if events>args.evts:
            break
        
        for hit_idx in range(len(trk.SensitivePosX)):
            det = trk.SensitiveIsPixel[hit_idx]
            reg = abs(trk.SensitiveBarrelEndcap[hit_idx])
            lyr = getLayer(trk,hit_idx)
            row = getRow(trk,hit_idx)[1]
            r=trk.SensitivePosR[hit_idx]
            z=trk.SensitivePosZ[hit_idx]
 
            for sliceid,modules in slice_modules.items():
                hist = getHist("slice_{}_rz".format(sliceid2int[sliceid]),
                               lambda n: ROOT.TH2D(n,"; z[mm]; r[mm]",3500,-500,+3000,1000,0,1000))
 
                if row in modules[int2det[det]][int2reg[reg]][lyr]["eta"]:            
                    hist.Fill(z,r)
 
            
 
#--------------------------------------------------------------------------------
# Main
#--------------------------------------------------------------------------------
 

◆ printOccupancies()

printOccupancies ( slice_modules )

Definition at line 480 of file module_driven_slicing.py.

def printOccupancies(slice_modules):
 
    duplication_count={
        det:{
            reg:{
                lyr:defaultdict(lambda: 0) for lyr in range(layers[det][reg]) }
            for reg in regs }
        for det in dets }
 
    for sliceid in slice_modules:
        for det in slice_modules[sliceid].keys():
            for reg in slice_modules[sliceid][det].keys():
                for lyr in slice_modules[sliceid][det][reg].keys():                
                    for etamod in slice_modules[sliceid][det][reg][lyr]["eta"].keys():
                        duplication_count[det][reg][lyr][etamod]+=1
 
 
    barrel_occupancies_4mrad_100mm={"pixel": [2.5,1.2,0.9,0.75,0.6],                         
                                    "strip": [0.4,0.4,0.3,0.3,0.2,0.2,0.2,0.2]}
    barrel_lengths={"pixel": [20,40,40,40,40],
                    "strip": [25,25,25,25,50,50,50,50]}
    occupancies_per_module = {det:{reg: [] for reg in regs} for det in dets}
    for det in dets:
        for i in range(len(barrel_lengths[det])):
            occupancies_per_module[det]['barrel'].append(barrel_occupancies_4mrad_100mm[det][i]*barrel_lengths[det][i]/float(100))
 
        occupancies_per_module[det]['endcap']=[0 for i in range(layers[det][reg])]
    
    layer_options = { "FPGATrackSimlike" : { "pixel" : [4], "strip":[0,2,3,4,5,6,7]},
                      "Outer5" :  { "pixel" : [4], "strip":[0,2,4,6]},
                      "Inner5" :  { "pixel" : [0,1,2,4,5], "strip":[]},
                      "Mid5" :  { "pixel" : [2,4,5], "strip":[0,2]}}
 
    layer_options_occ = defaultdict(lambda:1)
 
    msg.info("%-5s %-6s %-5s %-12s %-10s %-10s"  % ("","","","","min/max","min/max",))
    msg.info("%-5s %-6s %-5s %-12s %-10s %-10s"  % ("det","reg","lyr","duplication","modules","occupancy",))
    for det in dets:
        for reg in regs:
            for lyr in range(layers[det][reg]):
                dup=-1
                if len(duplication_count[det][reg][lyr])!=0:
                    dup = sum(duplication_count[det][reg][lyr].values())/float(len(duplication_count[det][reg][lyr]))
                occs = [occupancies_per_module[det][reg][lyr]*len(slice_modules[sliceid][det][reg][lyr]["eta"]) for sliceid in slice_modules]
                lens = [len(slice_modules[sliceid][det][reg][lyr]["eta"]) for sliceid in slice_modules]
 
                for opt,config in layer_options.items():
                    if lyr in config[det]:
                        layer_options_occ[opt]*=sum(occs)/float(len(occs))
 
                msg.info("%5s %5s %-5d    %2.2f      [%2d,%2d]     [%2.2f,%2.2f]"  % (det,reg,lyr,dup,min(lens),max(lens),min(occs),max(occs)))
 
    msg.info("\nOccupancies:\n")
    for opt,occ in layer_options_occ.items():
        msg.info(opt,occ)
 
 
 
#--------------------------------------------------------------------------------
# Plot Slices
#--------------------------------------------------------------------------------

◆ trackToModules()

trackToModules ( trk )

Definition at line 247 of file module_driven_slicing.py.

def trackToModules(trk):
    modules = defaultdict(defaultdictlambda) # indexed on layer
 
    for hit_idx in range(len(trk.SensitivePosX)):
        det = trk.SensitiveIsPixel[hit_idx]
        reg = abs(trk.SensitiveBarrelEndcap[hit_idx])
        lyr = getLayer(trk,hit_idx)
        row = getRow(trk,hit_idx)[1]
        phimod = trk.SensitivePhiModule[hit_idx]
        r=trk.SensitivePosR[hit_idx]
        z=trk.SensitivePosZ[hit_idx]
        if reg==reg2int['barrel']:
            if lyr not in modules[det][reg] or r < modules[det][reg][lyr][3]:
                modules[det][reg][lyr]=(row,phimod,hit_idx,r,z)
        else:
            if lyr not in modules[det][reg] or z < modules[det][reg][lyr][4]:
                modules[det][reg][lyr]=(row,phimod,hit_idx,r,z)
 
    for reg in modules[det2int['strip']]:
        if reg==reg2int['barrel']:
            varidx=3
        else:
            varidx=4
        
        varlast=10000 # large value
        lastlyr=10000 # large value
        for lyr in sorted(modules[det][reg].keys(),reverse=True):
            if varlast < modules[det][reg][lyr][varidx]:
                del modules[det][reg][lyr]
            elif lyr+1==lastlyr and lyr%2==0 and (varlast-modules[det][reg][lyr][varidx]) > 10.0: 
                del modules[det][reg][lyr+1] # remove outer hit
            else:
                lastlyr=lyr
                varlast=modules[det][reg][lyr][varidx]
                    
            
    return modules
 
 
#--------------------------------------------------------------------------------
# Parse Geometry
#--------------------------------------------------------------------------------
 
 

◆ transformNodes()

transformNodes	(		tree,
			func )

Definition at line 47 of file module_driven_slicing.py.

def transformNodes(tree,func):
    retv={}
    for key,val in tree.items():        
        if 'dict' in type(val).__name__:
            retv[key]=transformNodes(val,func)
        else:
            if 'list' in type(val).__name__:
                retv[key]=[func(subval) for subval in val]
            else:
                retv[key]=func(val)
    return retv
 
 
#----------------------------------------------------------------------
#  Constants
#----------------------------------------------------------------------

◆ trimSlice()

trimSlice	(		slice_modules,
			slice_tracks )

Definition at line 428 of file module_driven_slicing.py.

def trimSlice(slice_modules,slice_tracks):
 
    for sliceid in slice_modules:
        for det in dets:
            for reg in regs:
                for lyr in slice_modules[sliceid][det][reg]:
                    for mod in list(slice_modules[sliceid][det][reg][lyr]["eta"]):
                        if slice_modules[sliceid][det][reg][lyr]["eta"][mod]/float(slice_tracks[sliceid]) < args.trim:
                            del  slice_modules[sliceid][det][reg][lyr]["eta"][mod]
 
 
#--------------------------------------------------------------------------------
# Write RMap File
#--------------------------------------------------------------------------------

◆ writeRMap()

writeRMap	(		slice_modules,
			sliceid2int )

Definition at line 442 of file module_driven_slicing.py.

def writeRMap(slice_modules,sliceid2int):
    nslices=len(sliceid2int)
    rmap = open(args.outfilelabel+'_KeyLayer-%s%s%s_NSlices-%d.rmap' % (
        args.keylayer.replace(",","_"),
        "_KeyLayer2-"+args.keylayer2.replace(",","_") if args.keylayer2 else "",
        ("_trim_%1.3f" % (args.trim,)).replace(".","_") if args.trim else "",
        nslices), 'w')
 
    rmap.write("towers "+str(nslices)+" phi 16\n\n")
 
    int2sliceid={v:k for k,v in sliceid2int.items()}
    for i in range(len(slice_modules)):
        rmap.write("\n%d \n" % i)
        sliceid=int2sliceid[i]
 
        mindefault = lambda x,default=0: min(x) if len(x) else default
        maxdefault = lambda x,default=0: max(x) if len(x) else default
 
        for det in dets:
            for reg in regs:
                for lyr in range(layers[det][reg]):
                    rmap.write("%d %d %d %d %d %d %d %d %d\n" % (
                        1 if det=="pixel" else 0,
                        1 if reg=="endcap" else 0,
                        lyr,
                        mindefault(slice_modules[sliceid][det][reg][lyr]["phi"].keys(),default=0),
                        maxdefault(slice_modules[sliceid][det][reg][lyr]["phi"].keys(),default=0),
                        len(slice_modules[sliceid][det][reg][lyr]["phi"]),
                        mindefault(slice_modules[sliceid][det][reg][lyr]["eta"].keys(),default=0),
                        maxdefault(slice_modules[sliceid][det][reg][lyr]["eta"].keys(),default=0),
                        len(slice_modules[sliceid][det][reg][lyr]["eta"])))
 
 
    rmap.close()
    
#--------------------------------------------------------------------------------
# Estimate duplication
#--------------------------------------------------------------------------------

Variable Documentation

◆ abcchipsperrow

dict module_driven_slicing.abcchipsperrow

Initial value:

= { 'barrel' : {i+1:[10,10,10,10] for i in range(14)}, # actually 2 rows for some but doesn't matter
                 'endcap' : {0:[8,8,9,9],
                             1:[10,10,11,11],
                             2:[12,12],
                             3:[14,14],
                             4:[8,8],
                             5:[9,9]} }

Definition at line 87 of file module_driven_slicing.py.

◆ action

module_driven_slicing.action

Definition at line 9 of file module_driven_slicing.py.

◆ args

module_driven_slicing.args = parser.parse_args()

Definition at line 26 of file module_driven_slicing.py.

◆ Data

module_driven_slicing.Data = ROOT.TChain("ExtrapolationEngineTest")

Definition at line 135 of file module_driven_slicing.py.

◆ default

module_driven_slicing.default

Definition at line 10 of file module_driven_slicing.py.

◆ defaultdictlambda

defaultdict module_driven_slicing.defaultdictlambda = lambda (defaultdictlambda)

Definition at line 45 of file module_driven_slicing.py.

◆ det2int

dict module_driven_slicing.det2int = {v:k for k,v in int2det.items()}

Definition at line 68 of file module_driven_slicing.py.

◆ dets

list module_driven_slicing.dets = ["pixel","strip"]

Definition at line 63 of file module_driven_slicing.py.

◆ dirs

list module_driven_slicing.dirs = ["phi","eta"]

Definition at line 65 of file module_driven_slicing.py.

◆ eta_vals_for_key_layer

module_driven_slicing.eta_vals_for_key_layer = parseGeometry()

Definition at line 572 of file module_driven_slicing.py.

◆ fileList

module_driven_slicing.fileList = args.inname

Definition at line 130 of file module_driven_slicing.py.

◆ geom

str geom = "Unknown"

Definition at line 106 of file module_driven_slicing.py.

◆ help

module_driven_slicing.help

Definition at line 8 of file module_driven_slicing.py.

◆ histfile

module_driven_slicing.histfile = ROOT.TFile("test.root",'recreate')

Definition at line 570 of file module_driven_slicing.py.

◆ hists

dict module_driven_slicing.hists = {}

Definition at line 117 of file module_driven_slicing.py.

◆ int2det

dict module_driven_slicing.int2det = {1:"pixel", 0:"strip"}

Definition at line 67 of file module_driven_slicing.py.

◆ int2reg

dict module_driven_slicing.int2reg = {0:"barrel", 2:"endcap"}

Definition at line 69 of file module_driven_slicing.py.

◆ key1

module_driven_slicing.key1 = parseKeyLayer(args.keylayer)

Definition at line 157 of file module_driven_slicing.py.

◆ key2

module_driven_slicing.key2 = None

Definition at line 158 of file module_driven_slicing.py.

◆ layers

dict module_driven_slicing.layers = { "pixel": { "barrel":5, "endcap": 8 if geom=="ITK-22" else 8 }, "strip" : { "barrel":8, "endcap":12}}

Definition at line 113 of file module_driven_slicing.py.

◆ max_eta

module_driven_slicing.max_eta

Definition at line 165 of file module_driven_slicing.py.

◆ metavar

module_driven_slicing.metavar

Definition at line 7 of file module_driven_slicing.py.

◆ min_eta

module_driven_slicing.min_eta

Definition at line 165 of file module_driven_slicing.py.

◆ mod_slice_map

module_driven_slicing.mod_slice_map = divideKeyLayerModulesIntoSlices(eta_vals_for_key_layer)

Definition at line 579 of file module_driven_slicing.py.

◆ nargs

module_driven_slicing.nargs

Definition at line 7 of file module_driven_slicing.py.

◆ nslices

module_driven_slicing.nslices = args.nslices

Definition at line 574 of file module_driven_slicing.py.

◆ num_entries

module_driven_slicing.num_entries = min(args.evts,Data.GetEntries())

Definition at line 141 of file module_driven_slicing.py.

◆ parser

module_driven_slicing.parser = argparse.ArgumentParser(description='Flattens Wrapper Files')

Definition at line 6 of file module_driven_slicing.py.

◆ reg2int

dict module_driven_slicing.reg2int = {v:k for k,v in int2reg.items()}

Definition at line 70 of file module_driven_slicing.py.

◆ regs

list module_driven_slicing.regs = ["barrel","endcap"]

Definition at line 64 of file module_driven_slicing.py.

◆ rowbounds

dict module_driven_slicing.rowbounds = {}

Definition at line 98 of file module_driven_slicing.py.

◆ slice_modules

module_driven_slicing.slice_modules

Definition at line 581 of file module_driven_slicing.py.

◆ slice_tracks

module_driven_slicing.slice_tracks

Definition at line 581 of file module_driven_slicing.py.

◆ sliceid2int

module_driven_slicing.sliceid2int

Definition at line 581 of file module_driven_slicing.py.

◆ str

module_driven_slicing.str

Definition at line 7 of file module_driven_slicing.py.

◆ striprows

dict module_driven_slicing.striprows

Initial value:

= { 'barrel' : {0:[None]+[4]*14,
                        1:[None]+[4]*14,
                        2:[None]+[4]*14,
                        3:[None]+[4]*14,
                        4:[None]+[2]*14,
                        5:[None]+[2]*14,
                        6:[None]+[2]*14,
                        7:[None]+[2]*14},
            'endcap' : {i:[4,4,2,4,2,2] for i in range(12)}           
}

Definition at line 74 of file module_driven_slicing.py.

◆ stripsperabc

int module_driven_slicing.stripsperabc = 128

Definition at line 95 of file module_driven_slicing.py.

◆ stripsperrow

module_driven_slicing.stripsperrow = transformNodes(abcchipsperrow, lambda x: x * stripsperabc)

Definition at line 96 of file module_driven_slicing.py.

◆ t0

module_driven_slicing.t0 = time.clock()

Definition at line 143 of file module_driven_slicing.py.

◆ type

module_driven_slicing.type

Definition at line 7 of file module_driven_slicing.py.

Functions

Variables

Function Documentation

◆ divideKeyLayerModulesIntoSlices()

◆ findKeyLayerMod()

◆ getHist()

◆ getLayer()

◆ getModuleToSliceMap()

◆ getRow()

◆ isKeyLayer()

◆ parseGeometry()

◆ parseKeyLayer()

◆ plotSlices()

◆ printOccupancies()

◆ trackToModules()

◆ transformNodes()

◆ trimSlice()

◆ writeRMap()

Variable Documentation

◆ abcchipsperrow

◆ action

◆ args

◆ Data

◆ default

◆ defaultdictlambda

◆ det2int

◆ dets

◆ dirs

◆ eta_vals_for_key_layer

◆ fileList

◆ geom

◆ help

◆ histfile

◆ hists

◆ int2det

◆ int2reg

◆ key1

◆ key2

◆ layers

◆ max_eta

◆ metavar

◆ min_eta

◆ mod_slice_map

◆ nargs

◆ nslices

◆ num_entries

◆ parser

◆ reg2int

◆ regs

◆ rowbounds

◆ slice_modules

◆ slice_tracks

◆ sliceid2int

◆ str

◆ striprows

◆ stripsperabc

◆ stripsperrow

◆ t0

◆ type