module_driven_slicing Namespace Reference

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

Variables
	parser
	description
	metavar
	type
	str
	nargs
	help
	action
	default
	args
	defaultdictlambda
	int2det
	det2int
	int2reg
	reg2int
	striprows
	abcchipsperrow
	stripsperabc
	stripsperrow
	rowbounds
	geom
	layers
	hists
	fileList
	Data
	num_entries
	t0
	key1
	key2
	min_eta
	max_eta
	histfile
	eta_vals_for_key_layer
	nslices
	mod_slice_map
	slice_modules
	sliceid2int
	slice_tracks

Function Documentation

divideKeyLayerModulesIntoSlices()

def module_driven_slicing.divideKeyLayerModulesIntoSlices

(

eta_vals_for_key_layer

)

Definition at line 324 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()

def module_driven_slicing.findKeyLayerMod	(		trk,
			key
	)

Definition at line 233 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()

def module_driven_slicing.getHist	(		name,
			makehist
	)

Definition at line 121 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
fileList=args.inname

getLayer()

def module_driven_slicing.getLayer	(		trk,
			hit_idx
	)

Definition at line 172 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()

def module_driven_slicing.getModuleToSliceMap

(

mod_slice_map

)

Definition at line 346 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()

def module_driven_slicing.getRow	(		trk,
			hit_idx
	)

Definition at line 179 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()

def module_driven_slicing.isKeyLayer	(		trk,
			hit_idx,
			key
	)

Definition at line 223 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()

def module_driven_slicing.parseGeometry

(

)

Definition at line 292 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()

def module_driven_slicing.parseKeyLayer

(

keystring

)

Definition at line 150 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()

def module_driven_slicing.plotSlices	(		sliceid2int,
			slice_modules
	)

Definition at line 542 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()

def module_driven_slicing.printOccupancies

(

slice_modules

)

Definition at line 481 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()

def module_driven_slicing.trackToModules

(

trk

)

Definition at line 248 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()

def module_driven_slicing.transformNodes	(		tree,
			func
	)

Definition at line 48 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
#----------------------------------------------------------------------
dets=["pixel","strip"]
regs=["barrel","endcap"]
dirs=["phi","eta"]
 

trimSlice()

def module_driven_slicing.trimSlice	(		slice_modules,
			slice_tracks
	)

Definition at line 429 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()

def module_driven_slicing.writeRMap	(		slice_modules,
			sliceid2int
	)

Definition at line 443 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

module_driven_slicing.abcchipsperrow

Definition at line 88 of file module_driven_slicing.py.

action

module_driven_slicing.action

Definition at line 10 of file module_driven_slicing.py.

args

module_driven_slicing.args

Definition at line 27 of file module_driven_slicing.py.

Data

module_driven_slicing.Data

Definition at line 136 of file module_driven_slicing.py.

default

module_driven_slicing.default

Definition at line 11 of file module_driven_slicing.py.

defaultdictlambda

module_driven_slicing.defaultdictlambda

Definition at line 46 of file module_driven_slicing.py.

description

module_driven_slicing.description

Definition at line 7 of file module_driven_slicing.py.

det2int

module_driven_slicing.det2int

Definition at line 69 of file module_driven_slicing.py.

eta_vals_for_key_layer

module_driven_slicing.eta_vals_for_key_layer

Definition at line 573 of file module_driven_slicing.py.

fileList

module_driven_slicing.fileList

Definition at line 133 of file module_driven_slicing.py.

geom

module_driven_slicing.geom

Definition at line 107 of file module_driven_slicing.py.

help

module_driven_slicing.help

Definition at line 9 of file module_driven_slicing.py.

histfile

module_driven_slicing.histfile

Definition at line 571 of file module_driven_slicing.py.

hists

module_driven_slicing.hists

Definition at line 118 of file module_driven_slicing.py.

int2det

module_driven_slicing.int2det

Definition at line 68 of file module_driven_slicing.py.

int2reg

module_driven_slicing.int2reg

Definition at line 70 of file module_driven_slicing.py.

key1

module_driven_slicing.key1

Definition at line 158 of file module_driven_slicing.py.

key2

module_driven_slicing.key2

Definition at line 159 of file module_driven_slicing.py.

layers

module_driven_slicing.layers

Definition at line 114 of file module_driven_slicing.py.

max_eta

module_driven_slicing.max_eta

Definition at line 166 of file module_driven_slicing.py.

metavar

module_driven_slicing.metavar

Definition at line 8 of file module_driven_slicing.py.

min_eta

module_driven_slicing.min_eta

Definition at line 166 of file module_driven_slicing.py.

mod_slice_map

module_driven_slicing.mod_slice_map

Definition at line 580 of file module_driven_slicing.py.

nargs

module_driven_slicing.nargs

Definition at line 8 of file module_driven_slicing.py.

nslices

module_driven_slicing.nslices

Definition at line 575 of file module_driven_slicing.py.

num_entries

module_driven_slicing.num_entries

Definition at line 142 of file module_driven_slicing.py.

parser

module_driven_slicing.parser

Definition at line 7 of file module_driven_slicing.py.

reg2int

module_driven_slicing.reg2int

Definition at line 71 of file module_driven_slicing.py.

rowbounds

module_driven_slicing.rowbounds

Definition at line 99 of file module_driven_slicing.py.

slice_modules

module_driven_slicing.slice_modules

Definition at line 582 of file module_driven_slicing.py.

slice_tracks

module_driven_slicing.slice_tracks

Definition at line 582 of file module_driven_slicing.py.

sliceid2int

module_driven_slicing.sliceid2int

Definition at line 582 of file module_driven_slicing.py.

str

module_driven_slicing.str

Definition at line 8 of file module_driven_slicing.py.

striprows

module_driven_slicing.striprows

Definition at line 75 of file module_driven_slicing.py.

stripsperabc

module_driven_slicing.stripsperabc

Definition at line 96 of file module_driven_slicing.py.

stripsperrow

module_driven_slicing.stripsperrow

Definition at line 97 of file module_driven_slicing.py.

t0

module_driven_slicing.t0

Definition at line 144 of file module_driven_slicing.py.

type

module_driven_slicing.type

Definition at line 8 of file module_driven_slicing.py.