class Events(object): def __init__(self, files, tree_name, options=None): logging.info('opening input files:') logging.info(pprint.pformat(files)) if options is not None: if not hasattr(options, "inputFiles"): options.inputFiles = files if not hasattr(options, "maxEvents"): options.maxEvents = 0 if not hasattr(options, "secondaryInputFiles"): options.secondaryInputFiles = [] self.events = FWLiteEvents(options=options) else: self.events = FWLiteEvents(files) logging.info('done') def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
class CMSEDMEvents(object): def __init__(self, paths, maxEvents=-1, start=0): load_fwlite() if start < 0: raise ValueError( "start must be greater than or equal to zero: {} is given". format(start)) self.edm_event = EDMEvents(paths) # https://github.com/cms-sw/cmssw/blob/CMSSW_8_1_X/DataFormats/FWLite/python/__init__.py#L457 nevents_in_dataset = self.edm_event.size() start = min(nevents_in_dataset, start) if maxEvents > -1: self.nEvents = min(nevents_in_dataset - start, maxEvents) else: self.nEvents = nevents_in_dataset - start self.start = start self.iEvent = -1 def __len__(self): return self.nEvents def __repr__(self): return '{}(edm_event = {!r}, maxEvents = {!r}, start = {!r}, nEvents = {!r}, iEvent = {!r})'.format( self.__class__.__name__, self.edm_event, self.maxEvents, self.start, self.nEvents, self.iEvent) def __iter__(self): for self.iEvent in xrange(self.nEvents): self.edm_event.to(self.start + self.iEvent) yield self self.iEvent = -1
class Events(object): def __init__(self, files, tree_name): self.events = FWLiteEvents(files) def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
class Events(object): def __init__(self, files, tree_name, options=None): if options is not None : if not hasattr(options,"inputFiles"): options.inputFiles=files if not hasattr(options,"maxEvents"): options.maxEvents = 0 if not hasattr(options,"secondaryInputFiles"): options.secondaryInputFiles = [] self.events = FWLiteEvents(options=options) else : self.events = FWLiteEvents(files) def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
class Events(object): def __init__(self, files, tree_name, options=None): from DataFormats.FWLite import Events as FWLiteEvents if options is not None: if not hasattr(options, "inputFiles"): options.inputFiles = files if not hasattr(options, "maxEvents"): options.maxEvents = 0 if not hasattr(options, "secondaryInputFiles"): options.secondaryInputFiles = [] self.events = FWLiteEvents(options=options) else: self.events = FWLiteEvents(files) def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
class Events(object): def __init__(self, files, tree_name, options=None): from DataFormats.FWLite import Events as FWLiteEvents #TODO not sure we still need the stuff below from ROOT import gROOT, gSystem, AutoLibraryLoader print "Loading FW Lite" gSystem.Load("libFWCoreFWLite") gROOT.ProcessLine('FWLiteEnabler::enable();') gSystem.Load("libFWCoreFWLite") gSystem.Load("libDataFormatsPatCandidates") from ROOT import gInterpreter gInterpreter.ProcessLine("using namespace reco;") gInterpreter.ProcessLine("using edm::refhelper::FindUsingAdvance;") if options is not None: if not hasattr(options, "inputFiles"): options.inputFiles = files if not hasattr(options, "maxEvents"): options.maxEvents = 0 if not hasattr(options, "secondaryInputFiles"): options.secondaryInputFiles = [] self.events = FWLiteEvents(options=options) else: self.events = FWLiteEvents(files) def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
class Events(object): def __init__(self, files, tree_name, options=None): from DataFormats.FWLite import Events as FWLiteEvents #TODO not sure we still need the stuff below from ROOT import gROOT, gSystem, AutoLibraryLoader print "Loading FW Lite" gSystem.Load("libFWCoreFWLite"); gROOT.ProcessLine('FWLiteEnabler::enable();') gSystem.Load("libFWCoreFWLite"); gSystem.Load("libDataFormatsPatCandidates"); from ROOT import gInterpreter gInterpreter.ProcessLine("using namespace reco;") gInterpreter.ProcessLine("using edm::refhelper::FindUsingAdvance;") if options is not None : if not hasattr(options,"inputFiles"): options.inputFiles=files if not hasattr(options,"maxEvents"): options.maxEvents = 0 if not hasattr(options,"secondaryInputFiles"): options.secondaryInputFiles = [] self.events = FWLiteEvents(options=options) else : self.events = FWLiteEvents(files) def __len__(self): return self.events.size() def __getattr__(self, key): return getattr(self.events, key) def __getitem__(self, iEv): self.events.to(iEv) return self
def loop(fname) : mus = [Handle("vector<reco::Track> "), "generalTracks"] eventsRef = Events(fname) for i in range(0, eventsRef.size()): a= eventsRef.to(i) a=eventsRef.getByLabel(mus[1],mus[0]) pmus = [] for mu in mus[0].product() : if (mu.pt()<5) : continue if (not mu.innerOk()) : continue e = 1000*(mu.momentum().r()-mu.outerMomentum().r()) if (e<0) : continue print e z = abs(mu.outerPosition().z()) r = mu.outerPosition().rho() #rhoH.Fill(mu.outerPosition().rho(),e) zH.Fill(mu.outerPosition().z(),e) etaH.Fill(mu.outerPosition().eta(),e) if (z>240) : xyeH.Fill(mu.outerPosition().x(),mu.outerPosition().y(),e) xyH.Fill(mu.outerPosition().x(),mu.outerPosition().y(),1) if (r<120) :phiH.Fill(mu.outerPosition().phi(),e) rhoH.Fill(r,e) c1 = TCanvas( 'c1', fname, 200, 10, 1000, 1400 ) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c1.Divide(2,3) c1.cd(1) rhoH.Draw() c1.cd(2) zH.Draw() c1.cd(3) xyH.Draw("COLZ") c1.cd(4) xyeH.Divide(xyH) xyeH.Draw("COLZ") c1.cd(5) etaH.Draw() c1.cd(6) phiH.Draw() c1.Print("eloss"+fname+".png")
def loop(fname): mus = [Handle("vector<reco::Track> "), "generalTracks"] eventsRef = Events(fname) for i in range(0, eventsRef.size()): a = eventsRef.to(i) a = eventsRef.getByLabel(mus[1], mus[0]) pmus = [] for mu in mus[0].product(): if (mu.pt() < 5): continue if (not mu.innerOk()): continue e = 1000 * (mu.momentum().r() - mu.outerMomentum().r()) if (e < 0): continue print e z = abs(mu.outerPosition().z()) r = mu.outerPosition().rho() #rhoH.Fill(mu.outerPosition().rho(),e) zH.Fill(mu.outerPosition().z(), e) etaH.Fill(mu.outerPosition().eta(), e) if (z > 240): xyeH.Fill(mu.outerPosition().x(), mu.outerPosition().y(), e) xyH.Fill(mu.outerPosition().x(), mu.outerPosition().y(), 1) if (r < 120): phiH.Fill(mu.outerPosition().phi(), e) rhoH.Fill(r, e) c1 = TCanvas('c1', fname, 200, 10, 1000, 1400) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c1.Divide(2, 3) c1.cd(1) rhoH.Draw() c1.cd(2) zH.Draw() c1.cd(3) xyH.Draw("COLZ") c1.cd(4) xyeH.Divide(xyH) xyeH.Draw("COLZ") c1.cd(5) etaH.Draw() c1.cd(6) phiH.Draw() c1.Print("eloss" + fname + ".png")
class EOSEventsWithDownload(object): def __init__(self, files, tree_name): query = ["edmFileUtil", "--ls", "-j" ] + [("file:" + f if f[0] == "/" else f) for f in files] retjson = subprocess.check_output(query) retobj = json.loads(retjson) self._files = [] self._nevents = 0 for entry in retobj: self._files.append( (str(entry['file']), self._nevents, self._nevents + entry['events'] )) # str() is needed since the output is a unicode string self._nevents += entry['events'] self._fileindex = -1 self._localCopy = None self.events = None ## Discover where I am self.inMeyrin = True if 'LSB_JOBID' in os.environ and 'HOSTNAME' in os.environ: hostname = os.environ['HOSTNAME'].replace(".cern.ch", "") try: wigners = subprocess.check_output(["bmgroup", "g_wigner"]).split() if hostname in wigners: self.inMeyrin = False print "Host %s is in bmgroup g_wigner, so I assume I'm in Wigner and not Meyrin" % hostname except: pass def __len__(self): return self._nevents def __getattr__(self, key): return getattr(self.events, key) def isLocal(self, filename): fpath = filename.replace("root://eoscms.cern.ch//", "/").replace("root://eoscms//", "/") if "?" in fpath: fpath = fpath.split["?"][0] try: finfo = subprocess.check_output([ "/afs/cern.ch/project/eos/installation/pro/bin/eos.select", "fileinfo", fpath ]) replicas = False nears = False for line in finfo.split("\n"): if line.endswith("geotag"): replicas = True elif replicas and ".cern.ch" in line: geotag = int(line.split()[-1]) print "Found a replica with geotag %d" % geotag if self.inMeyrin: if geotag > 9000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away else: if geotag < 1000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away # if we have found some near replicas, and no far replicas if nears: return True except: pass # we don't know, so we don't transfer (better slow than messed up) return True def __getitem__(self, iEv): if self._fileindex == -1 or not ( self._files[self._fileindex][1] <= iEv and iEv < self._files[self._fileindex][2]): self.events = None # so it's closed if self._localCopy: print "Removing local cache file %s" % self._localCopy try: os.remove(self._localCopy) except: pass self._localCopy = None for i, (fname, first, last) in enumerate(self._files): if first <= iEv and iEv < last: print "For event range [ %d, %d ) will use file %r " % ( first, last, fname) self._fileindex = i if fname.startswith("root://eoscms"): if not self.isLocal(fname): tmpdir = os.environ[ 'TMPDIR'] if 'TMPDIR' in os.environ else "/tmp" rndchars = "".join( [hex(ord(i))[2:] for i in os.urandom(8)]) localfile = "%s/%s-%s.root" % ( tmpdir, os.path.basename(fname).replace( ".root", ""), rndchars) try: print "Filename %s is remote (geotag >= 9000), will do a copy to local path %s " % ( fname, localfile) subprocess.check_output( ["xrdcp", "-f", fname, localfile]) self._localCopy = localfile fname = localfile except: print "Could not save file locally, will run from remote" if os.path.exists(localfile): os.remove( localfile ) # delete in case of incomplete transfer print "Will run from " + fname self.events = FWLiteEvents([fname]) break self.events.to(iEv - self._files[self._fileindex][1]) return self def __del__(self): todelete = getattr(self, '_localCopy', None) if todelete: print "Removing local cache file ", todelete os.remove(todelete)
from DataFormats.FWLite import Handle, Events from ROOT import gROOT, gStyle, TCanvas, TF1, TFile, TTree, gRandom, TH1F, TH2F import os eventsOri = Events("step3_ori.root") eventsNew = Events("step3.root") tracksOri = Handle("std::vector<reco::Track>") tracksNew = Handle("std::vector<reco::Track>") label = "generalTracks" quality = "highPurity" for i in range(0, eventsOri.size()): a= eventsOri.to(i) a= eventsNew.to(i) # print "Event", i a=eventsOri.getByLabel(label, tracksOri) a=eventsNew.getByLabel(label, tracksNew) ntOri = tracksOri.product().size() ntNew = tracksOri.product().size() if (ntOri != ntNew ) : print i, ntOri,ntNew
#inputFiles = inputFiles[:1] if not small else inputFiles print "Running over files:",inputFiles print "plotDir:",options.plotDir handles={k:Handle(edmCollections[k][0]) for k in edmCollections.keys()} res={} events = Events(inputFiles) events.toBegin() products={} size=events.size() #if not small else 2000 missingCollections=[] for nev in range(size): if nev%1000==0:print nev,'/',size events.to(nev) eaux=events.eventAuxiliary() run=eaux.run() if options.run>0 and not run==options.run: # print run, options.run continue for k in [ x for x in edmCollections.keys() if x not in missingCollections]: try: events.getByLabel(edmCollections[k][1:],handles[k]) products[k]=handles[k].product() except: products[k]=None print "Not found:",k missingCollections.append(k) d={}
class DiMuAnalyzer( Looper ): def __init__(self, name, component, cfg): super( DiMuAnalyzer, self).__init__(component.fraction) self.name = name self.cmp = component self.cfg = cfg self.events = Events( glob.glob( self.cmp.files) ) self.triggerList = TriggerList( self.cmp.triggers ) ## if self.cmp.isMC or self.cmp.isEmbed: ## self.trigEff = TriggerEfficiency() ## self.trigEff.tauEff = None ## self.trigEff.lepEff = None ## if self.cmp.tauEffWeight is not None: ## self.trigEff.tauEff = getattr( self.trigEff, ## self.cmp.tauEffWeight ) ## if self.cmp.muEffWeight is not None: ## self.trigEff.lepEff = getattr( self.trigEff, ## self.cmp.muEffWeight ) # here create outputs ## self.regions = H2TauTauRegions( self.cfg.cuts ) ## self.output = Output( self.name, self.regions ) ## if self.cmp.name == 'DYJets': ## self.outputFakes = Output( self.name + '_Fakes', self.regions ) self.output = DiMuOutput( self.name ) self.counters = Counters() self.averages = {} self.InitHandles() self.InitCounters() self.logger = logging.getLogger(self.name) self.logger.addHandler(logging.FileHandler('/'.join([self.output.name, 'log.txt']))) def LoadCollections(self, event ): '''Load all collections''' for str,handle in self.handles.iteritems(): handle.Load( event ) # could do something clever to get the products... a setattr maybe? if self.cmp.isMC: for str,handle in self.mchandles.iteritems(): handle.Load( event ) if self.cmp.isEmbed: for str,handle in self.embhandles.iteritems(): handle.Load( event ) def InitHandles(self): '''Initialize all handles for the products we want to read''' self.handles = {} self.mchandles = {} self.embhandles = {} self.handles['cmgTriggerObjectSel'] = AutoHandle( 'cmgTriggerObjectSel', 'std::vector<cmg::TriggerObject>>') if self.cmp.isMC and self.cmp.vertexWeight is not None: self.handles['vertexWeight'] = AutoHandle( self.cmp.vertexWeight, 'double' ) self.handles['vertices'] = AutoHandle( 'offlinePrimaryVertices', 'std::vector<reco::Vertex>' ) self.handles['jets'] = AutoHandle( 'cmgPFJetSel', 'std::vector<cmg::PFJet>' ) self.mchandles['genParticles'] = AutoHandle( 'genParticlesStatus3', 'std::vector<reco::GenParticle>' ) self.embhandles['generatorWeight'] = AutoHandle( ('generator', 'weight'), 'double') self.handles['diMu'] = AutoHandle( 'cmgDiMuonSel', 'std::vector<cmg::DiObject<cmg::Muon,cmg::Muon>>') def InitCounters(self): '''Initialize histograms physics objects, counters.''' # declaring counters and averages self.counters = Counters() self.counters.addCounter('triggerPassed') self.counters.addCounter('exactlyOneDiMu') self.counters.addCounter('singleDiMu') self.counters.addCounter('VBF') # self.averages['triggerWeight']=Average('triggerWeight') ## self.averages['lepEffWeight']=Average('lepEffWeight') ## self.averages['tauEffWeight']=Average('tauEffWeight') self.averages['vertexWeight']=Average('vertexWeight') ## self.averages['generatorWeight']=Average('generatorWeight') self.averages['eventWeight']=Average('eventWeight') def process( self, iEv ): '''Navigate to a given event and process it.''' cuts = self.cfg.cuts # output event structure self.event = Event() # navigating to the correct FWLite event self.iEvent = iEv self.events.to(iEv) self.LoadCollections(self.events) # reading CMG objects from the handle #COLIN this kind of stuff could be automatized cmgDiMus = self.handles['diMu'].product() ## cmgLeptons = self.handles['leptons'].product() self.event.triggerObject = self.handles['cmgTriggerObjectSel'].product()[0] self.event.vertices = self.handles['vertices'].product() cmgJets = self.handles['jets'].product() if self.cmp.isMC: genParticles = self.mchandles['genParticles'].product() self.event.genParticles = map( GenParticle, genParticles) # converting them into my own python objects def testMuon(muon): if muon.pt() > cuts.muPt: return True else: return False def testDiMuon(diMuon): return testMuon( diMuon.leg1() ) and testMuon( diMuon.leg2() ) self.event.diMus = [ DiLepton(diMu) for diMu in cmgDiMus if testDiMuon(diMu) ] # self.event.leptons = [ Lepton(lepton) for lepton in cmgLeptons ] self.event.dirtyJets = [] for cmgJet in cmgJets: jet = Jet( cmgJet ) if self.cmp.isMC: scale = random.gauss( self.cmp.jetScale, self.cmp.jetSmear) jet.scaleEnergy( scale ) if not testJet( cmgJet, cuts): continue self.event.dirtyJets.append(jet) self.counters.counter('triggerPassed').inc('a: All events') if not self.triggerList.triggerPassed(self.event.triggerObject): return False self.counters.counter('triggerPassed').inc('b: Trig OK ') self.counters.counter('exactlyOneDiMu').inc('a: any # of di-mus ') if len(self.event.diMus)==0: # print 'Event %d : No di-mu.' % iEv return False if len(self.event.diMus)>1: # print 'Event %d : Too many tau-mus: n = %d' % (iEv, len(self.event.diMus)) #COLIN could be nice to have a counter class # which knows why events are rejected. make histograms with that. self.logger.warning('Ev %d: more than 1 di-mu : n = %d' % (iEv, len(self.event.diMus))) self.counters.counter('exactlyOneDiMu').inc('b: at least 1 di-mu ') #MUONS #if not self.leptonAccept(self.event.leptons): # return False # self.counters.counter('exactlyOneDiMu').inc('c: exactly one lepton ') self.event.diMu = self.event.diMus[0] if len(self.event.diMus)>1: self.event.diMu = bestDiMu( self.event.diMus ) elif len(self.event.diMus)==1: self.counters.counter('exactlyOneDiMu').inc('d: exactly 1 di-mu ') else: raise ValueError('should not happen!') ################## Starting from here, we have the di-mu ############### self.event.diTau = self.event.diMu diMu = self.event.diMu self.counters.counter('singleDiMu').inc('a: best di-mu') if diMu.leg1().pt() > cuts.muPt and \ diMu.leg2().pt() > cuts.muPt : self.counters.counter('singleDiMu').inc( 'b: pt1,2 > {pt:3.1f}'.format( pt = cuts.muPt) ) else: return False if abs(diMu.leg1().eta()) < cuts.muEta and \ abs(diMu.leg2().eta()) < cuts.muEta : self.counters.counter('singleDiMu').inc( 'c: |eta1,2| < {eta:3.1f}'.format( eta = cuts.muEta) ) else: return False if cuts.minMass < diMu.mass() and diMu.mass() < cuts.maxMass: self.counters.counter('singleDiMu').inc( 'd: {min:3.1f} < m < {max:3.1f}'.format(min = cuts.minMass, max = cuts.maxMass) ) else: return False if diMu.leg1().relIso( 0.5 ) < cuts.muIso and \ diMu.leg2().relIso( 0.5 ) < cuts.muIso: self.counters.counter('singleDiMu').inc( 'e: iso1,2 < {iso:3.1f}'.format(iso=cuts.muIso) ) else: return False #SELECT BARREL MUONS # clean up jet collection self.event.jets = cleanObjectCollection( self.event.dirtyJets, masks = [self.event.diMu.leg1(), self.event.diMu.leg2() ], deltaRMin = 0.5 ) # print '-----------' # if len(self.event.dirtyJets)>0: # print 'Dirty:' # print '\n\t'.join( map(str, self.event.dirtyJets) ) # print self.event.diMu # print 'Clean:' # print '\n\t'.join( map(str, self.event.jets) ) self.counters.counter('VBF').inc('a: all events ') if len(self.event.jets)>1: self.counters.counter('VBF').inc('b: at least 2 jets ') self.event.vbf = VBF( self.event.jets ) if self.event.vbf.mjj > cuts.VBF_Mjj: self.counters.counter('VBF').inc('c: Mjj > {mjj:3.1f}'.format(mjj = cuts.VBF_Mjj)) if abs(self.event.vbf.deta) > cuts.VBF_Deta: self.counters.counter('VBF').inc('d: deta > {deta:3.1f}'.format(deta = cuts.VBF_Deta)) if len(self.event.vbf.centralJets)==0: self.counters.counter('VBF').inc('e: no central jet ') self.event.eventWeight = 1 # self.event.triggerWeight = 1 self.event.vertexWeight = 1 if self.cmp.isMC: self.event.vertexWeight = self.handles['vertexWeight'].product()[0] self.event.eventWeight = self.event.vertexWeight self.output.Fill( self.event ) self.averages['vertexWeight'].add( self.event.vertexWeight ) self.averages['eventWeight'].add( self.event.eventWeight ) return True def Write(self): '''Write all histograms to their root files''' self.output.Write() def __str__(self): name = 'Loop %s' % self.name component = str(self.cmp) counters = map(str, self.counters.counters) strave = map(str, self.averages.values()) return '\n'.join([name, component] + counters + strave )
class Loop: '''Manages looping and navigation on a set of events.''' def __init__(self, name, component, cfg): '''Build a loop object. listOfFiles can be "*.root". name will be used to make the output directory''' self.name = name self.cmp = component self.cfg = cfg self.events = Events(glob.glob(self.cmp.files)) self.triggerList = TriggerList(self.cmp.triggers) if self.cmp.isMC: self.trigEff = TriggerEfficiency() self.trigEff.tauEff = None self.trigEff.lepEff = None if self.cmp.tauEffWeight is not None: self.trigEff.tauEff = getattr(self.trigEff, self.cmp.tauEffWeight) if self.cmp.muEffWeight is not None: self.trigEff.lepEff = getattr(self.trigEff, self.cmp.muEffWeight) #self.cmp.turnOnCurve = None #if self.cmp.isMC: # if self.cmp.tauTriggerTOC is not None: # self.cmp.turnOnCurve = TurnOnCurve( self.cmp.tauTriggerTOC ) self._MakeOutputDir() self.counters = Counters() self.averages = {} # self.histograms = [] self.InitHandles() def _MakeOutputDir(self): index = 0 name = self.name while True: try: # print 'mkdir', self.name os.mkdir(name) break except OSError: index += 1 name = '%s_%d' % (self.name, index) self.logger = logging.getLogger(self.name) self.logger.addHandler( logging.FileHandler('/'.join([self.name, 'log.txt']))) def LoadCollections(self, event): '''Load all collections''' for str, handle in self.handles.iteritems(): handle.Load(event) # could do something clever to get the products... a setattr maybe? def InitHandles(self): '''Initialize all handles for the products we want to read''' self.handles = {} self.handles['cmgTauMuCorFullSelSVFit'] = AutoHandle( 'cmgTauMuCorSVFitFullSel', 'std::vector<cmg::DiObject<cmg::Tau,cmg::Muon>>') ## self.handles['cmgTauMu'] = AutoHandle( 'cmgTauMu', ## 'std::vector<cmg::DiObject<cmg::Tau,cmg::Muon>>') self.handles['cmgTriggerObjectSel'] = AutoHandle( 'cmgTriggerObjectSel', 'std::vector<cmg::TriggerObject>>') if self.cmp.isMC and self.cmp.vertexWeight is not None: self.handles['vertexWeight'] = AutoHandle(self.cmp.vertexWeight, 'double') self.handles['vertices'] = AutoHandle('offlinePrimaryVertices', 'std::vector<reco::Vertex>') self.handles['leptons'] = AutoHandle('cmgMuonSel', 'std::vector<cmg::Muon>') self.handles['jets'] = AutoHandle('cmgPFJetSel', 'std::vector<cmg::PFJet>') def InitOutput(self): '''Initialize histograms physics objects, counters.''' #COLIN do I really need to declare them? # declaring physics objects self.diTau = None self.triggerObject = None # declaring counters and averages self.counters = Counters() self.counters.addCounter('triggerPassed') self.counters.addCounter('exactlyOneDiTau') self.counters.addCounter('singleDiTau') self.counters.addCounter('VBF') # self.averages['triggerWeight']=Average('triggerWeight') self.averages['lepEffWeight'] = Average('lepEffWeight') self.averages['tauEffWeight'] = Average('tauEffWeight') self.averages['vertexWeight'] = Average('vertexWeight') self.averages['eventWeight'] = Average('eventWeight') self.regions = H2TauTauRegions(self.cfg.cuts) self.histoLists = {} inclusiveRegions = set() for regionName in self.regions.regionNames(): self.histoLists[regionName] = H2TauTauHistogramList('/'.join( [self.name, regionName])) incRegName = inclusiveRegionName(regionName) inclusiveRegions.add(incRegName) for regionName in inclusiveRegions: self.histoLists[regionName] = H2TauTauHistogramList('/'.join( [self.name, regionName])) def ToEvent(self, iEv): '''Navigate to a given event and process it.''' # output event structure self.event = Event() # navigating to the correct FWLite event self.iEvent = iEv self.events.to(iEv) self.LoadCollections(self.events) # reading CMG objects from the handle #COLIN this kind of stuff could be automatized cmgDiTaus = self.handles['cmgTauMuCorFullSelSVFit'].product() cmgLeptons = self.handles['leptons'].product() self.event.triggerObject = self.handles['cmgTriggerObjectSel'].product( )[0] self.event.vertices = self.handles['vertices'].product() cmgJets = self.handles['jets'].product() # converting them into my own python objects self.event.diTaus = [DiTau(diTau) for diTau in cmgDiTaus] self.event.leptons = [Lepton(lepton) for lepton in cmgLeptons] self.event.jets = [ Jet(jet) for jet in cmgJets if testJet(jet, self.cfg.cuts) ] self.event.jets = [] for cmgJet in cmgJets: if not testJet(jet, self.cfg.cuts): continue jet = Jet(cmgJet) # print jet.energy() jet.scaleEnergy(1) # print jet.energy() self.event.jets.append(jet) self.counters.counter('triggerPassed').inc('a: All events') if not self.triggerList.triggerPassed(self.event.triggerObject): return False self.counters.counter('triggerPassed').inc('b: Trig OK ') self.counters.counter('exactlyOneDiTau').inc('a: any # of di-taus ') if len(self.event.diTaus) == 0: print 'Event %d : No tau mu.' % i return False if len(self.event.diTaus) > 1: # print 'Event %d : Too many tau-mus: n = %d' % (iEv, len(self.event.diTaus)) #COLIN could be nice to have a counter class # which knows why events are rejected. make histograms with that. self.logger.warning('Ev %d: more than 1 di-tau : n = %d' % (iEv, len(self.event.diTaus))) self.counters.counter('exactlyOneDiTau').inc('b: at least 1 di-tau ') if not leptonAccept(self.event.leptons): return False self.counters.counter('exactlyOneDiTau').inc('c: exactly one lepton ') self.event.diTau = self.event.diTaus[0] if len(self.event.diTaus) > 1: self.event.diTau = bestDiTau(self.event.diTaus) elif len(self.event.diTaus) == 1: self.counters.counter('exactlyOneDiTau').inc( 'd: exactly 1 di-tau ') else: raise ValueError('should not happen!') cuts = self.cfg.cuts self.counters.counter('singleDiTau').inc('a: best di-tau') self.event.tau = Tau(self.event.diTau.leg1()) if self.event.tau.calcEOverP() > 0.2: self.counters.counter('singleDiTau').inc('b: E/p > 0.2 ') else: return False if self.event.tau.pt() > cuts.tauPt: self.counters.counter('singleDiTau').inc( 'c: tau pt > {ptCut:3.1f}'.format(ptCut=cuts.tauPt)) else: return False self.event.lepton = Lepton(self.event.diTau.leg2()) if self.event.lepton.pt() > cuts.lepPt: self.counters.counter('singleDiTau').inc( 'd: lep pt > {ptCut:3.1f}'.format(ptCut=cuts.lepPt)) else: return False if abs(self.event.lepton.eta()) < cuts.lepEta: self.counters.counter('singleDiTau').inc( 'e: lep |eta| <{etaCut:3.1f}'.format(etaCut=cuts.lepEta)) else: return False self.counters.counter('VBF').inc('a: all events ') if len(self.event.jets) > 1: self.counters.counter('VBF').inc('b: at least 2 jets ') self.event.vbf = VBF(self.event.jets) if self.event.vbf.mjj > cuts.VBF_Mjj: self.counters.counter('VBF').inc( 'c: Mjj > {mjj:3.1f}'.format(mjj=cuts.VBF_Mjj)) if abs(self.event.vbf.deta) > cuts.VBF_Deta: self.counters.counter('VBF').inc( 'd: deta > {deta:3.1f}'.format(deta=cuts.VBF_Deta)) if len(self.event.vbf.centralJets) == 0: self.counters.counter('VBF').inc('e: no central jet ') # print self.event.vbf self.event.eventWeight = 1 # self.event.triggerWeight = 1 self.event.vertexWeight = 1 self.event.tauEffWeight = 1 self.event.lepEffWeight = 1 if self.cmp.isMC: self.event.vertexWeight = self.handles['vertexWeight'].product()[0] self.event.eventWeight *= self.event.vertexWeight if self.trigEff.tauEff is not None: self.event.tauEffWeight = self.trigEff.tauEff( self.event.tau.pt()) if self.trigEff.lepEff is not None: self.event.lepEffWeight = self.trigEff.lepEff( self.event.lepton.pt(), self.event.lepton.eta()) self.event.eventWeight = self.event.vertexWeight * \ self.event.tauEffWeight * \ self.event.lepEffWeight # if self.cmp.turnOnCurve is not None: # self.event.triggerWeight = self.cmp.turnOnCurve.weight( # self.event.tau.pt() ) # self.event.eventWeight *= self.event.triggerWeight # self.averages['triggerWeight'].add( self.event.triggerWeight ) self.averages['tauEffWeight'].add(self.event.tauEffWeight) self.averages['lepEffWeight'].add(self.event.lepEffWeight) self.averages['vertexWeight'].add(self.event.vertexWeight) self.averages['eventWeight'].add(self.event.eventWeight) # exclusive analysis regionName = self.regions.test(self.event) histoList = self.histoLists[regionName] histoList.Fill(self.event, self.event.eventWeight) # inclusive analysis incRegionName = inclusiveRegionName(regionName) histoList = self.histoLists[incRegionName] histoList.Fill(self.event, self.event.eventWeight) return True def Loop(self, nEvents=-1): '''Loop on a given number of events, and call ToEvent for each event.''' print 'starting loop' self.InitOutput() nEvents = int(nEvents) for iEv in range(0, self.events.size()): if iEv == nEvents: break if iEv % 1000 == 0: print 'event', iEv try: self.ToEvent(iEv) except ValueError: #COLIN should not be a value error break self.logger.warning(str(self)) def Write(self): '''Write all histograms to their root files''' # for hist in self.histograms: # hist.Write() for histoList in self.histoLists.values(): histoList.Write() def __str__(self): name = 'Loop %s' % self.name component = str(self.cmp) counters = map(str, self.counters.counters) strave = map(str, self.averages.values()) # triggers = ': '.join( ['triggers', str(self.triggers)] ) # trigs = str( self.triggerList ) # vertexWeight = ': '.join( ['vertex weight', str(self.cmp.vertexWeight) ]) return '\n'.join([name, component] + counters + strave)
class Loop: '''Manages looping and navigation on a set of events.''' def __init__(self, name, component, cfg): '''Build a loop object. listOfFiles can be "*.root". name will be used to make the output directory''' self.name = name self.cmp = component self.cfg = cfg self.events = Events( glob.glob( self.cmp.files) ) self.triggerList = TriggerList( self.cmp.triggers ) if self.cmp.isMC: self.trigEff = TriggerEfficiency() self.trigEff.tauEff = None self.trigEff.lepEff = None if self.cmp.tauEffWeight is not None: self.trigEff.tauEff = getattr( self.trigEff, self.cmp.tauEffWeight ) if self.cmp.muEffWeight is not None: self.trigEff.lepEff = getattr( self.trigEff, self.cmp.muEffWeight ) #self.cmp.turnOnCurve = None #if self.cmp.isMC: # if self.cmp.tauTriggerTOC is not None: # self.cmp.turnOnCurve = TurnOnCurve( self.cmp.tauTriggerTOC ) self._MakeOutputDir() self.counters = Counters() self.averages = {} # self.histograms = [] self.InitHandles() def _MakeOutputDir(self): index = 0 name = self.name while True: try: # print 'mkdir', self.name os.mkdir( name ) break except OSError: index += 1 name = '%s_%d' % (self.name, index) self.logger = logging.getLogger(self.name) self.logger.addHandler(logging.FileHandler('/'.join([self.name, 'log.txt']))) def LoadCollections(self, event ): '''Load all collections''' for str,handle in self.handles.iteritems(): handle.Load( event ) # could do something clever to get the products... a setattr maybe? def InitHandles(self): '''Initialize all handles for the products we want to read''' self.handles = {} self.handles['cmgTauMuCorFullSelSVFit'] = AutoHandle( 'cmgTauMuCorSVFitFullSel', 'std::vector<cmg::DiObject<cmg::Tau,cmg::Muon>>') ## self.handles['cmgTauMu'] = AutoHandle( 'cmgTauMu', ## 'std::vector<cmg::DiObject<cmg::Tau,cmg::Muon>>') self.handles['cmgTriggerObjectSel'] = AutoHandle( 'cmgTriggerObjectSel', 'std::vector<cmg::TriggerObject>>') if self.cmp.isMC and self.cmp.vertexWeight is not None: self.handles['vertexWeight'] = AutoHandle( self.cmp.vertexWeight, 'double' ) self.handles['vertices'] = AutoHandle( 'offlinePrimaryVertices', 'std::vector<reco::Vertex>' ) self.handles['leptons'] = AutoHandle( 'cmgMuonSel', 'std::vector<cmg::Muon>' ) self.handles['jets'] = AutoHandle( 'cmgPFJetSel', 'std::vector<cmg::PFJet>' ) def InitOutput(self): '''Initialize histograms physics objects, counters.''' #COLIN do I really need to declare them? # declaring physics objects self.diTau = None self.triggerObject = None # declaring counters and averages self.counters = Counters() self.counters.addCounter('triggerPassed') self.counters.addCounter('exactlyOneDiTau') self.counters.addCounter('singleDiTau') self.counters.addCounter('VBF') # self.averages['triggerWeight']=Average('triggerWeight') self.averages['lepEffWeight']=Average('lepEffWeight') self.averages['tauEffWeight']=Average('tauEffWeight') self.averages['vertexWeight']=Average('vertexWeight') self.averages['eventWeight']=Average('eventWeight') self.regions = H2TauTauRegions( self.cfg.cuts ) self.histoLists = {} inclusiveRegions = set() for regionName in self.regions.regionNames(): self.histoLists[ regionName ] = H2TauTauHistogramList( '/'.join([self.name, regionName])) incRegName = inclusiveRegionName( regionName ) inclusiveRegions.add( incRegName ) for regionName in inclusiveRegions: self.histoLists[ regionName ] = H2TauTauHistogramList( '/'.join([self.name, regionName ])) def ToEvent( self, iEv ): '''Navigate to a given event and process it.''' # output event structure self.event = Event() # navigating to the correct FWLite event self.iEvent = iEv self.events.to(iEv) self.LoadCollections(self.events) # reading CMG objects from the handle #COLIN this kind of stuff could be automatized cmgDiTaus = self.handles['cmgTauMuCorFullSelSVFit'].product() cmgLeptons = self.handles['leptons'].product() self.event.triggerObject = self.handles['cmgTriggerObjectSel'].product()[0] self.event.vertices = self.handles['vertices'].product() cmgJets = self.handles['jets'].product() # converting them into my own python objects self.event.diTaus = [ DiTau(diTau) for diTau in cmgDiTaus ] self.event.leptons = [ Lepton(lepton) for lepton in cmgLeptons ] self.event.jets = [ Jet(jet) for jet in cmgJets if testJet(jet, self.cfg.cuts) ] self.event.jets = [] for cmgJet in cmgJets: if not testJet( jet, self.cfg.cuts): continue jet = Jet( cmgJet ) # print jet.energy() jet.scaleEnergy( 1 ) # print jet.energy() self.event.jets.append(jet) self.counters.counter('triggerPassed').inc('a: All events') if not self.triggerList.triggerPassed(self.event.triggerObject): return False self.counters.counter('triggerPassed').inc('b: Trig OK ') self.counters.counter('exactlyOneDiTau').inc('a: any # of di-taus ') if len(self.event.diTaus)==0: print 'Event %d : No tau mu.' % i return False if len(self.event.diTaus)>1: # print 'Event %d : Too many tau-mus: n = %d' % (iEv, len(self.event.diTaus)) #COLIN could be nice to have a counter class # which knows why events are rejected. make histograms with that. self.logger.warning('Ev %d: more than 1 di-tau : n = %d' % (iEv, len(self.event.diTaus))) self.counters.counter('exactlyOneDiTau').inc('b: at least 1 di-tau ') if not leptonAccept(self.event.leptons): return False self.counters.counter('exactlyOneDiTau').inc('c: exactly one lepton ') self.event.diTau = self.event.diTaus[0] if len(self.event.diTaus)>1: self.event.diTau = bestDiTau( self.event.diTaus ) elif len(self.event.diTaus)==1: self.counters.counter('exactlyOneDiTau').inc('d: exactly 1 di-tau ') else: raise ValueError('should not happen!') cuts = self.cfg.cuts self.counters.counter('singleDiTau').inc('a: best di-tau') self.event.tau = Tau( self.event.diTau.leg1() ) if self.event.tau.calcEOverP() > 0.2: self.counters.counter('singleDiTau').inc('b: E/p > 0.2 ') else: return False if self.event.tau.pt()>cuts.tauPt: self.counters.counter('singleDiTau').inc('c: tau pt > {ptCut:3.1f}'.format(ptCut = cuts.tauPt)) else: return False self.event.lepton = Lepton( self.event.diTau.leg2() ) if self.event.lepton.pt()>cuts.lepPt: self.counters.counter('singleDiTau').inc('d: lep pt > {ptCut:3.1f}'.format(ptCut = cuts.lepPt)) else: return False if abs( self.event.lepton.eta() ) < cuts.lepEta: self.counters.counter('singleDiTau').inc('e: lep |eta| <{etaCut:3.1f}'.format(etaCut = cuts.lepEta)) else: return False self.counters.counter('VBF').inc('a: all events ') if len(self.event.jets)>1: self.counters.counter('VBF').inc('b: at least 2 jets ') self.event.vbf = VBF( self.event.jets ) if self.event.vbf.mjj > cuts.VBF_Mjj: self.counters.counter('VBF').inc('c: Mjj > {mjj:3.1f}'.format(mjj = cuts.VBF_Mjj)) if abs(self.event.vbf.deta) > cuts.VBF_Deta: self.counters.counter('VBF').inc('d: deta > {deta:3.1f}'.format(deta = cuts.VBF_Deta)) if len(self.event.vbf.centralJets)==0: self.counters.counter('VBF').inc('e: no central jet ') # print self.event.vbf self.event.eventWeight = 1 # self.event.triggerWeight = 1 self.event.vertexWeight = 1 self.event.tauEffWeight = 1 self.event.lepEffWeight = 1 if self.cmp.isMC: self.event.vertexWeight = self.handles['vertexWeight'].product()[0] self.event.eventWeight *= self.event.vertexWeight if self.trigEff.tauEff is not None: self.event.tauEffWeight = self.trigEff.tauEff(self.event.tau.pt()) if self.trigEff.lepEff is not None: self.event.lepEffWeight = self.trigEff.lepEff( self.event.lepton.pt(), self.event.lepton.eta() ) self.event.eventWeight = self.event.vertexWeight * \ self.event.tauEffWeight * \ self.event.lepEffWeight # if self.cmp.turnOnCurve is not None: # self.event.triggerWeight = self.cmp.turnOnCurve.weight( # self.event.tau.pt() ) # self.event.eventWeight *= self.event.triggerWeight # self.averages['triggerWeight'].add( self.event.triggerWeight ) self.averages['tauEffWeight'].add( self.event.tauEffWeight ) self.averages['lepEffWeight'].add( self.event.lepEffWeight ) self.averages['vertexWeight'].add( self.event.vertexWeight ) self.averages['eventWeight'].add( self.event.eventWeight ) # exclusive analysis regionName = self.regions.test( self.event ) histoList = self.histoLists[regionName] histoList.Fill( self.event, self.event.eventWeight ) # inclusive analysis incRegionName = inclusiveRegionName( regionName ) histoList = self.histoLists[incRegionName] histoList.Fill( self.event, self.event.eventWeight ) return True def Loop(self, nEvents=-1 ): '''Loop on a given number of events, and call ToEvent for each event.''' print 'starting loop' self.InitOutput() nEvents = int(nEvents) for iEv in range(0, self.events.size() ): if iEv == nEvents: break if iEv%1000 ==0: print 'event', iEv try: self.ToEvent( iEv ) except ValueError: #COLIN should not be a value error break self.logger.warning( str(self) ) def Write(self): '''Write all histograms to their root files''' # for hist in self.histograms: # hist.Write() for histoList in self.histoLists.values(): histoList.Write() def __str__(self): name = 'Loop %s' % self.name component = str(self.cmp) counters = map(str, self.counters.counters) strave = map(str, self.averages.values()) # triggers = ': '.join( ['triggers', str(self.triggers)] ) # trigs = str( self.triggerList ) # vertexWeight = ': '.join( ['vertex weight', str(self.cmp.vertexWeight) ]) return '\n'.join([name, component] + counters + strave )
def loop(flist,fname,aod) : csvfile = open(fname+'.csv','wb') writer = csv.writer(csvfile) vertices = [Handle("vector<reco::Vertex>"), "offlineSlimmedPrimaryVertices" ] mus = [Handle("vector<pat::Muon>"), "slimmedMuons"] pfMETH = [Handle('std::vector<pat::MET>'),"slimmedMETs"] if (aod) : vertices = [Handle("vector<reco::Vertex>"), "offlinePrimaryVertices" ] mus = [Handle("vector<pat::Muon>"),"cleanPatMuons"] pfMETH = [Handle('vector<pat::MET>'),"systematicsMET"] sip2d = TH1F("SIP2D","SIP2D",40,-10.,10.) sip3d = TH1F("SIP3D","SIP3D",40,-10.,10.) sipxy = TH1F("tk2d","TK SIPXY",40,-10.,10.) sipz = TH1F("tk3z","TK SIPZ",40,-10.,10.) recoilRawH = ROOT.TH1F("Raw MET","Raw MET",1000,0,1000) recoilH = ROOT.TH1F("Recoil","Recoil",100,-10,10) responsePt = ROOT.TProfile("responsePt","responsePt",20,0,100) resolutionPt = ROOT.TProfile("resolutionPt","resolutionPt",20,0,100) responsePU = ROOT.TProfile("responsePU","responsePU",20,0,40) resolutionPU = ROOT.TProfile("resolutionPU","resolutionPU",20,0,40) hmass = ROOT.TH1F("Z mass","Z mass",100,70,120) # eventsRef = Events(flist) nw=0 nehpt=0 nwhpt=0 nech=0 nwch=0 # for i in range(0, eventsRef.size()): a= eventsRef.to(i) eventsRef.getByLabel(pfMETH[1],pfMETH[0]) met = pfMETH[0].product()[0] recoilRawH.Fill(met.pt()) if((i%5000)==0) : print "Event", i a=eventsRef.getByLabel(vertices[1],vertices[0]) pv = vertices[0].product()[0] pvp = vertices[0].product()[0].position() nv = vertices[0].product().size() a=eventsRef.getByLabel(mus[1],mus[0]) muons = mus[0].product() # print muons.size() for mu1,mu2 in itertools.combinations(muons,2): if not(mu1.pt()>15 and mu2.pt()>5): continue; if mu1.charge()+mu2.charge() !=0: continue; if not(mu1.isGlobalMuon() and mu2.isGlobalMuon()) : continue # print mu1.pt(),mu2.pt(),mu1.charge()+mu2.charge(), mu1.isGlobalMuon(), mu2.isGlobalMuon(), mu1.track().chi2(),mu1.track().ndof(),mu1.track().hitPattern().pixelLayersWithMeasurement() if (mu1.track().hitPattern().pixelLayersWithMeasurement()<1): continue if (mu2.track().hitPattern().pixelLayersWithMeasurement()<1): continue mass = (mu1.p4()+mu2.p4()).M() if not (mass>70 and mass<120): continue hmass.Fill(mass) diMu = mu1.p4()+mu2.p4() recoil = -(met.p4()+diMu) Z = diMu.Vect() R = recoil.Vect() Z.SetZ(0) R.SetZ(0) URSP = R.Dot(Z.Unit()) URES = R.Dot(Z.Unit().Cross(ROOT.math.XYZVector(0,0,1))) writer.writerow([i,mass,diMu.pt(),URSP,URES, mu1.pt(),mu1.eta(),mu1.phi(),mu1.dB(2)/mu1.edB(2),mu1.dB(1)/mu1.edB(1),mu1.track().dxy(pvp)/mu1.track().dxyError(),mu1.track().dz(pvp)/mu1.track().dzError(), mu2.pt(),mu2.eta(),mu2.phi(),mu2.dB(2)/mu2.edB(2),mu2.dB(1)/mu2.edB(1),mu2.track().dxy(pvp)/mu2.track().dxyError(),mu2.track().dz(pvp)/mu2.track().dzError()]) responsePt.Fill(diMu.pt(),URSP/diMu.Pt()) resolutionPt.Fill(diMu.pt(),URES/diMu.Pt()) if diMu.pt()>20.0: responsePU.Fill(nv,URSP/diMu.Pt()) resolutionPU.Fill(nv,URES/diMu.Pt()) recoilH.Fill( (URSP+diMu.Pt())/diMu.Pt()) sip2d.Fill(mu1.dB(2)/mu1.edB(2)) sip3d.Fill(mu1.dB(1)/mu1.edB(1)) sipxy.Fill(mu1.track().dxy(pvp)/mu1.track().dxyError()) sipz.Fill(mu1.track().dz(pvp)/mu1.track().dzError()) sip2d.Fill(mu2.dB(2)/mu2.edB(2)) sip3d.Fill(mu2.dB(1)/mu2.edB(1)) sipxy.Fill(mu2.track().dxy(pvp)/mu2.track().dxyError()) sipz.Fill(mu2.track().dz(pvp)/mu2.track().dzError()) csvfile.close() c1 = TCanvas( 'c1', fname, 200, 10, 1000, 1400 ) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c1.Divide(2,4) c1.cd(1).SetLogy() sip2d.DrawNormalized() e = TF1("q","0.5*exp(-0.5*x*x)/sqrt(6.28)",-10.,10.) e.Draw("same") c1.cd(2).SetLogy() sip3d.DrawNormalized() e.Draw("same") c1.cd(3).SetLogy() sipxy.DrawNormalized() e.Draw("same") c1.cd(4).SetLogy() sipz.DrawNormalized() e.Draw("same") c1.cd(5).SetLogy() hmass.DrawNormalized() c1.Print("dataHist/sipall"+fname+".png") c2 = TCanvas( 'c2', fname, 200, 10, 1000, 1400 ) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c2.Divide(2,3) c2.cd(1) responsePt.Draw() c2.cd(2) resolutionPt.Draw() c2.cd(3) responsePU.Draw() c2.cd(4) resolutionPU.Draw() c2.cd(5).SetLogy() recoilH.DrawNormalized() c2.cd(6).SetLogy() recoilRawH.DrawNormalized() c2.Print("dataHist/ResponseZmumu"+fname+".png")
class H2TauTauAnalyzer( Looper ): def __init__(self, name, component, cfg): self.name = name self.cmp = component self.cfg = cfg self.events = Events( glob.glob( self.cmp.files) ) self.triggerList = TriggerList( self.cmp.triggers ) #SPEC? if self.cmp.isMC or self.cmp.isEmbed: self.trigEff = TriggerEfficiency() self.trigEff.tauEff = None self.trigEff.lepEff = None if self.cmp.tauEffWeight is not None: self.trigEff.tauEff = getattr( self.trigEff, self.cmp.tauEffWeight ) if self.cmp.muEffWeight is not None: self.trigEff.lepEff = getattr( self.trigEff, self.cmp.muEffWeight ) # here create outputs self.regions = H2TauTauRegions( self.cfg.cuts ) self.output = H2TauTauOutput( self.name, self.regions ) if self.cmp.name == 'DYJets': self.outputFakes = H2TauTauOutput( self.name + '_Fakes', self.regions ) self.logger = logging.getLogger(self.name) self.logger.addHandler(logging.FileHandler('/'.join([self.output.name, 'log.txt']))) self.counters = Counters() self.averages = {} self.InitHandles() self.InitCounters() def LoadCollections(self, event ): '''Load all collections''' for str,handle in self.handles.iteritems(): handle.Load( event ) # could do something clever to get the products... a setattr maybe? if self.cmp.isMC: for str,handle in self.mchandles.iteritems(): handle.Load( event ) if self.cmp.isEmbed: for str,handle in self.embhandles.iteritems(): handle.Load( event ) def InitHandles(self): '''Initialize all handles for the products we want to read''' self.handles = {} self.mchandles = {} self.embhandles = {} self.handles['cmgTriggerObjectSel'] = AutoHandle( 'cmgTriggerObjectSel', 'std::vector<cmg::TriggerObject>>') if self.cmp.isMC and self.cmp.vertexWeight is not None: self.handles['vertexWeight'] = AutoHandle( self.cmp.vertexWeight, 'double' ) self.handles['vertices'] = AutoHandle( 'offlinePrimaryVertices', 'std::vector<reco::Vertex>' ) self.handles['jets'] = AutoHandle( 'cmgPFJetSel', 'std::vector<cmg::PFJet>' ) self.mchandles['genParticles'] = AutoHandle( 'genParticlesStatus3', 'std::vector<reco::GenParticle>' ) self.embhandles['generatorWeight'] = AutoHandle( ('generator', 'weight'), 'double') self.InitSpecificHandles() def InitCounters(self): '''Initialize histograms physics objects, counters.''' # declaring counters and averages self.counters = Counters() self.counters.addCounter('triggerPassed') self.counters.addCounter('exactlyOneDiTau') self.counters.addCounter('singleDiTau') self.counters.addCounter('VBF') # self.averages['triggerWeight']=Average('triggerWeight') self.averages['lepEffWeight']=Average('lepEffWeight') self.averages['tauEffWeight']=Average('tauEffWeight') self.averages['vertexWeight']=Average('vertexWeight') self.averages['generatorWeight']=Average('generatorWeight') self.averages['eventWeight']=Average('eventWeight') def process( self, iEv ): '''Navigate to a given event and process it.''' # output event structure self.event = Event() # navigating to the correct FWLite event self.iEvent = iEv self.events.to(iEv) self.LoadCollections(self.events) # reading CMG objects from the handle #COLIN this kind of stuff could be automatized cmgDiTaus = self.handles['diTau'].product() cmgLeptons = self.handles['leptons'].product() self.event.triggerObject = self.handles['cmgTriggerObjectSel'].product()[0] self.event.vertices = self.handles['vertices'].product() cmgJets = self.handles['jets'].product() if self.cmp.isMC: genParticles = self.mchandles['genParticles'].product() self.event.genParticles = map( GenParticle, genParticles) # converting them into my own python objects self.event.diTaus = [ DiTau(diTau) for diTau in cmgDiTaus ] self.event.leptons = [ Lepton(lepton) for lepton in cmgLeptons ] # self.event.dirtyJets = [ Jet(jet) for jet in cmgJets if testJet(jet, self.cfg.cuts) ] self.event.dirtyJets = [] for cmgJet in cmgJets: jet = Jet( cmgJet ) if self.cmp.isMC: scale = random.gauss( self.cmp.jetScale, self.cmp.jetSmear) jet.scaleEnergy( scale ) if not testJet( cmgJet, self.cfg.cuts): continue self.event.dirtyJets.append(jet) self.counters.counter('triggerPassed').inc('a: All events') if not self.triggerList.triggerPassed(self.event.triggerObject): return False self.counters.counter('triggerPassed').inc('b: Trig OK ') self.counters.counter('exactlyOneDiTau').inc('a: any # of di-taus ') if len(self.event.diTaus)==0: print 'Event %d : No di-tau.' % i return False if len(self.event.diTaus)>1: # print 'Event %d : Too many tau-mus: n = %d' % (iEv, len(self.event.diTaus)) #COLIN could be nice to have a counter class # which knows why events are rejected. make histograms with that. self.logger.warning('Ev %d: more than 1 di-tau : n = %d' % (iEv, len(self.event.diTaus))) self.counters.counter('exactlyOneDiTau').inc('b: at least 1 di-tau ') #MUONS if not self.leptonAccept(self.event.leptons): return False self.counters.counter('exactlyOneDiTau').inc('c: exactly one lepton ') self.event.diTau = self.event.diTaus[0] if len(self.event.diTaus)>1: self.event.diTau = bestDiTau( self.event.diTaus ) elif len(self.event.diTaus)==1: self.counters.counter('exactlyOneDiTau').inc('d: exactly 1 di-tau ') else: raise ValueError('should not happen!') cuts = self.cfg.cuts self.counters.counter('singleDiTau').inc('a: best di-tau') self.event.tau = Tau( self.event.diTau.leg1() ) if self.event.tau.decayMode() == 0 and \ self.event.tau.calcEOverP() < 0.2: #MUONS return False else: self.counters.counter('singleDiTau').inc('b: E/p > 0.2 ') if self.event.tau.pt()>cuts.tauPt: self.counters.counter('singleDiTau').inc('c: tau pt > {ptCut:3.1f}'.format(ptCut = cuts.tauPt)) else: return False self.event.lepton = Lepton( self.event.diTau.leg2() ) if self.event.lepton.pt()>cuts.lepPt: self.counters.counter('singleDiTau').inc('d: lep pt > {ptCut:3.1f}'.format(ptCut = cuts.lepPt)) else: return False if abs( self.event.lepton.eta() ) < cuts.lepEta: self.counters.counter('singleDiTau').inc('e: lep |eta| <{etaCut:3.1f}'.format(etaCut = cuts.lepEta)) else: return False ################## Starting from here, we have the di-tau ############### # clean up jet collection self.event.jets = cleanObjectCollection( self.event.dirtyJets, masks = [self.event.diTau.leg1(), self.event.diTau.leg2() ], deltaRMin = 0.5 ) # print '-----------' # if len(self.event.dirtyJets)>0: # print 'Dirty:' # print '\n\t'.join( map(str, self.event.dirtyJets) ) # print self.event.diTau # print 'Clean:' # print '\n\t'.join( map(str, self.event.jets) ) self.counters.counter('VBF').inc('a: all events ') if len(self.event.jets)>1: self.counters.counter('VBF').inc('b: at least 2 jets ') self.event.vbf = VBF( self.event.jets ) if self.event.vbf.mjj > cuts.VBF_Mjj: self.counters.counter('VBF').inc('c: Mjj > {mjj:3.1f}'.format(mjj = cuts.VBF_Mjj)) if abs(self.event.vbf.deta) > cuts.VBF_Deta: self.counters.counter('VBF').inc('d: deta > {deta:3.1f}'.format(deta = cuts.VBF_Deta)) if len(self.event.vbf.centralJets)==0: self.counters.counter('VBF').inc('e: no central jet ') matched = None if self.cmp.name == 'DYJets': leg1DeltaR, leg2DeltaR = self.event.diTau.match( self.event.genParticles ) if leg1DeltaR>-1 and leg1DeltaR < 0.1 and \ leg2DeltaR>-1 and leg2DeltaR < 0.1: matched = True else: matched = False self.event.eventWeight = 1 # self.event.triggerWeight = 1 self.event.vertexWeight = 1 self.event.tauEffWeight = 1 self.event.lepEffWeight = 1 self.event.generatorWeight = 1 if self.cmp.isMC: self.event.vertexWeight = self.handles['vertexWeight'].product()[0] if self.cmp.isEmbed: self.event.generatorWeight = self.embhandles['generatorWeight'].product()[0] if self.cmp.isMC or self.cmp.isEmbed: if self.trigEff.tauEff is not None: self.event.tauEffWeight = self.trigEff.tauEff(self.event.tau.pt()) #MUONS if self.trigEff.lepEff is not None: self.event.lepEffWeight = self.trigEff.lepEff( self.event.lepton.pt(), self.event.lepton.eta() ) self.event.eventWeight = self.event.vertexWeight * \ self.event.tauEffWeight * \ self.event.lepEffWeight * \ self.event.generatorWeight # self.averages['triggerWeight'].add( self.event.triggerWeight ) self.averages['tauEffWeight'].add( self.event.tauEffWeight ) self.averages['lepEffWeight'].add( self.event.lepEffWeight ) self.averages['vertexWeight'].add( self.event.vertexWeight ) self.averages['generatorWeight'].add( self.event.generatorWeight ) self.averages['eventWeight'].add( self.event.eventWeight ) regionName = self.regions.test( self.event ) if matched is None or matched is True: self.output.Fill( self.event, regionName ) elif matched is False: self.outputFakes.Fill( self.event, regionName ) else: raise ValueError('should not happen!') return True def Write(self): '''Write all histograms to their root files''' # for hist in self.histograms: # hist.Write() self.output.Write() if self.cmp.name == 'DYJets': self.outputFakes.Write() def __str__(self): name = 'Loop %s' % self.name component = str(self.cmp) counters = map(str, self.counters.counters) strave = map(str, self.averages.values()) return '\n'.join([name, component] + counters + strave )
print 'Error: I need a CMSSW environment available to run!' exit(1) import ROOT ROOT.gROOT.SetBatch(True) ROOT.PyConfig.IgnoreCommandLineOptions = True from DataFormats.FWLite import Handle, Events fedHandle = Handle('FEDRawDataCollection') events = Events(args.input) if events.size() > 1: print 'Warning, this script is designed for pre-picked EDM files (i.e. 1 event!)' events.to(args.event) if not events.getByLabel(args.label, fedHandle): print "Sorry, I couldn't load the FED collection for event %d :<" % args.event exit(1) fedsToPrint = map(int, args.feds.split(',')) for iFed in fedsToPrint: fedEDMObject = fedHandle.product().FEDData(iFed) fedData = fedEDMObject.data( ) # no worries about executor for unknown type ... fedData.SetSize(fedEDMObject.size() / 8) # size in bytes, we read in long (8 bytes) with open(args.output + '_fed%d.txt' % iFed, 'w') as fout: for word in fedData: # Signed to unsigned word conversion fout.write('%016x\n' % (word & (2**64 - 1)))
class EOSEventsWithDownload(object): def __init__(self, files, tree_name): query = ["edmFileUtil", "--ls", "-j"]+[("file:"+f if f[0]=="/" else f) for f in files] retjson = subprocess.check_output(query) retobj = json.loads(retjson) self._files = [] self._nevents = 0 for entry in retobj: self._files.append( (str(entry['file']), self._nevents, self._nevents+entry['events'] ) ) # str() is needed since the output is a unicode string self._nevents += entry['events'] self._fileindex = -1 self._localCopy = None self.events = None ## Discover where I am self.inMeyrin = True if 'LSB_JOBID' in os.environ and 'HOSTNAME' in os.environ: hostname = os.environ['HOSTNAME'].replace(".cern.ch","") try: wigners = subprocess.check_output(["bmgroup","g_wigner"]).split() if hostname in wigners: self.inMeyrin = False print "Host %s is in bmgroup g_wigner, so I assume I'm in Wigner and not Meyrin" % hostname except: pass ## How aggressive should I be? # 0 = default; 1 = always fetch from Wigner; 2 = always fetch from anywhere if it's a xrootd url self.aggressive = getattr(self.__class__, 'aggressive', 0) print "Aggressive prefetching level %d" % self.aggressive def __len__(self): return self._nevents def __getattr__(self, key): return getattr(self.events, key) def isLocal(self,filename): if self.aggressive >= 2: return False if self.aggressive >= 1 and not self.inMeyrin: return False fpath = filename.replace("root://eoscms.cern.ch//","/").replace("root://eoscms//","/") if "?" in fpath: fpath = fpath.split["?"][0] try: finfo = subprocess.check_output(["/afs/cern.ch/project/eos/installation/pro/bin/eos.select", "fileinfo", fpath]) replicas = False nears = False for line in finfo.split("\n"): if line.endswith("geotag"): replicas = True elif replicas and ".cern.ch" in line: geotag = int(line.split()[-1]) print "Found a replica with geotag %d" % geotag if self.inMeyrin: if geotag > 9000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away else: if geotag < 1000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away # if we have found some near replicas, and no far replicas if nears: return True except: pass # we don't know, so we don't transfer (better slow than messed up) return True def __getitem__(self, iEv): if self._fileindex == -1 or not(self._files[self._fileindex][1] <= iEv and iEv < self._files[self._fileindex][2]): self.events = None # so it's closed if self._localCopy: print "Removing local cache file %s" % self._localCopy try: os.remove(self._localCopy) except: pass self._localCopy = None for i,(fname,first,last) in enumerate(self._files): if first <= iEv and iEv < last: print "For event range [ %d, %d ) will use file %r " % (first,last,fname) self._fileindex = i if fname.startswith("root://eoscms") or (self.aggressive >= 2 and fname.startswith("root://")): if not self.isLocal(fname): tmpdir = os.environ['TMPDIR'] if 'TMPDIR' in os.environ else "/tmp" rndchars = "".join([hex(ord(i))[2:] for i in os.urandom(8)]) localfile = "%s/%s-%s.root" % (tmpdir, os.path.basename(fname).replace(".root",""), rndchars) try: print "Filename %s is remote (geotag >= 9000), will do a copy to local path %s " % (fname,localfile) start = timeit.default_timer() subprocess.check_output(["xrdcp","-f","-N",fname,localfile]) print "Time used for transferring the file locally: %s s" % (timeit.default_timer() - start) self._localCopy = localfile fname = localfile except: print "Could not save file locally, will run from remote" if os.path.exists(localfile): os.remove(localfile) # delete in case of incomplete transfer print "Will run from "+fname self.events = FWLiteEvents([fname]) break self.events.to(iEv - self._files[self._fileindex][1]) return self def endLoop(self): if '_localCopy' not in self.__dict__: return todelete = self.__dict__['_localCopy'] if todelete: print "Removing local cache file ",todelete os.remove(todelete) def __del__(self): self.endLoop()
def loop(fname): genPars = Handle("vector<reco::GenParticle>") genParsLabel = "prunedGenParticles" gPar = [Handle("vector<pat::PackedGenParticle>"), "packedGenParticles"] vertices = [ Handle("vector<reco::Vertex>"), "offlineSlimmedPrimaryVertices" ] mus = [Handle("vector<pat::Muon>"), "slimmedMuons"] sip2d = TH1F("SIP2D", "SIP2D", 40, -10., 10.) sip3d = TH1F("SIP3D", "SIP3D", 40, -10., 10.) sipxy = TH1F("tk2d", "TK SIPXY", 40, -10., 10.) sipz = TH1F("tk3z", "TK SIPZ", 40, -10., 10.) sip3d_l = TH1F("SIP2D l", "SIP2D l", 40, -10., 10.) sip3d_h = TH1F("SIP2D h", "SIP2D h", 40, -10., 10.) sip3d_best = TH1F("SIP2D best", "SIP2D best", 40, -10., 10.) vert = TH1F("zpv", "zpv", 100, -10., 10.) sip_v = TProfile("SIP2D vs zpv", "SIP2D best vs zpv", 50, 0., 5., 0., 10.) # eventsRef = Events(fname) nw = 0 nehpt = 0 nwhpt = 0 nech = 0 nwch = 0 # for i in range(0, eventsRef.size()): a = eventsRef.to(i) print "Event", i a = eventsRef.getByLabel(genParsLabel, genPars) zpv = 0 gpvp = genPars.product()[0].vertex() for part in genPars.product(): if (part.vz() != 0): zpv = part.vz() gpvp = part.vertex() break print "zpv ", zpv # nmu = 0 nel = 0 nch1 = 0 nch2 = 0 gmu = [] for part in genPars.product(): if (part.status() != 1): continue if (abs(part.pdgId()) == 13 and part.pt() > 5 and abs(part.eta()) < 2.4): gmu.append((part.phi(), part.eta(), part.charge() * part.pt())) if (abs(part.pdgId()) == 13 and part.pt() > 5 and abs(part.eta()) < 2.4): nmu += 1 if (abs(part.pdgId()) == 11 and part.pt() > 7 and abs(part.eta()) < 2.4): nel += 1 if (abs(part.pdgId()) == 13 and part.pt() > 8 and abs(part.eta()) < 2.4): nch1 += 1 if (abs(part.pdgId()) == 11 and part.pt() > 10 and abs(part.eta()) < 2.4): nch1 += 1 if (abs(part.pdgId()) == 13 and part.pt() > 20 and abs(part.eta()) < 2.4): nch2 += 1 if (abs(part.pdgId()) == 11 and part.pt() > 20 and abs(part.eta()) < 2.4): nch2 += 1 # if (abs(part.pdgId())==13): # print "part", part.phi(),part.eta(), part.pt(), part.vz(), part.vx(), part.vy(), part.mass(), part.pdgId(), part.status() # print "nmu ", nmu,nel # print gmu a = eventsRef.getByLabel(vertices[1], vertices[0]) minz = 99999. iv = 0 ii = 0 pv = vertices[0].product()[0] pvp = vertices[0].product()[0].position() nv = vertices[0].product().size() for v in vertices[0].product(): if (abs(v.z() - zpv) < minz): minz = abs(v.z() - zpv) iv = ii ii += 1 print "pv ", iv, minz if (iv != 0): nw += 1 # if (nmu+nel>3) : if (nmu > 1): nehpt += 1 if (iv != 0): nwhpt += 1 # if (nch1>0 and nch2>0) : if (nch1 < 1): continue # nech += 1 if (iv != 0): nwch += 1 a = eventsRef.getByLabel(mus[1], mus[0]) pmus = [] for mu in mus[0].product(): if (mu.pt() < 5): continue # if ( mu.isTrackerMuon() or mu.isGlobalMuon()) : if (mu.isGlobalMuon()): pmus.append( (mu.phi(), mu.eta(), mu.pt() * mu.charge(), mu.dB(2) / mu.edB(2), mu.dB(1) / mu.edB(1), mu.track().dxy(gpvp) / mu.track().dxyError(), mu.track().dz(gpvp) / mu.track().dzError(), mu.track().hitPattern().pixelLayersWithMeasurement())) # print 'mu', iv, mu.phi(), mu.eta(), mu.pt(), mu.dB(2)/mu.edB(2), mu.dB(1)/mu.edB(1), mu.isTrackerMuon(), mu.isGlobalMuon() # print pmus matches = [] i = 0 for g in gmu: j = 0 for mu in pmus: j += 1 if (g[2] / mu[2] < 0.5 or g[2] / mu[2] > 2.0): continue dr = dR2(g[0], g[1], mu[0], mu[1]) if (dr > 0.04): continue matches.append((i, j - 1, dr, abs(1. - g[2] / mu[2]))) #print "matched mu", mu i += 1 if (len(matches) < 1): continue vert.Fill((pv.z() - zpv) / pv.zError()) k = matches[0][0] best = 99999 dr = 999999 for m in matches: # if (abs(pv.z()-zpv)<3*pv.zError()) : if (pmus[m[1]][7] > 2): # if (nv<21) : sip3d_l.Fill(pmus[m[1]][3]) else: sip3d_h.Fill(pmus[m[1]][3]) sip2d.Fill(pmus[m[1]][4]) sip3d.Fill(pmus[m[1]][3]) sipxy.Fill(pmus[m[1]][5]) sipz.Fill(pmus[m[1]][6]) sip_v.Fill(abs(pv.z() - zpv) / pv.zError(), abs(pmus[m[1]][5])) if (m[0] != k): sip3d_best.Fill(best) k = m[0] best = pmus[m[1]][4] dr = m[3] else: if (m[3] < dr): dr = m[3] best = pmus[m[1]][4] if (dr < 9999): sip3d_best.Fill(best) print "wrong pv", nw, nehpt, nwhpt, nech, nwch c1 = TCanvas('c1', fname, 200, 10, 1000, 1400) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c1.Divide(2, 4) c1.cd(1).SetLogy() sip2d.DrawNormalized() e = TF1("q", "0.5*exp(-0.5*x*x)/sqrt(6.28)", -10., 10.) e.Draw("same") c1.cd(2).SetLogy() sip3d.DrawNormalized() e.Draw("same") c1.cd(3).SetLogy() sipxy.DrawNormalized() e.Draw("same") c1.cd(4).SetLogy() sipz.DrawNormalized() e.Draw("same") c1.cd(5).SetLogy() sip3d_l.DrawNormalized() e.Draw("same") c1.cd(6).SetLogy() sip3d_h.DrawNormalized() e.Draw("same") # sip3d_best.DrawNormalized() c1.cd(7).SetLogy() vert.DrawNormalized() # ev = TF1("qv","0.2*exp(-0.5*x*x)/sqrt(6.28)",-10.,10.) # ev.Draw("same") c1.cd(8) sip_v.Draw() c1.Print("sipall" + fname + ".png")
class EOSEventsWithDownload(object): def __init__(self, files, tree_name): self.aggressive = getattr(self.__class__, 'aggressive', 0) self.long_cache = getattr(self.__class__, 'long_cache', False) print "Aggressive prefetching level %d" % self.aggressive self._files = [] self._nevents = 0 try: query = ["edmFileUtil", "--ls", "-j" ] + [("file:" + f if f[0] == "/" else f) for f in files] retjson = subprocess.check_output(query) retobj = json.loads(retjson) for entry in retobj: self._files.append( (str(entry['file']), self._nevents, self._nevents + entry['events'] )) # str() is needed since the output is a unicode string self._nevents += entry['events'] except subprocess.CalledProcessError: print "Failed the big query: ", query ## OK, now we go for something more fancy for f in files: print "Try file: ", f OK = False # step 1: try the local query if f[0] == "/": urls = ['file:' + f] else: urls = [f] # one retry try: # then try the two main redirectors, and EOS again if "/store/data" in f and "PromptReco" in f: urls.append( convertFileAccess( f, "root://eoscms.cern.ch//eos/cms/tier0%s")) urls.append( convertFileAccess(f, "root://xrootd-cms.infn.it/%s")) urls.append( convertFileAccess(f, "root://cmsxrootd.fnal.gov/%s")) urls.append( convertFileAccess( f, "root://cms-xrd-global.cern.ch/%s")) urls.append( convertFileAccess( f, "root://eoscms.cern.ch//eos/cms%s")) except: pass for u in urls: print "Try url: ", u try: query = ["edmFileUtil", "--ls", "-j", u] retjson = subprocess.check_output(query) retobj = json.loads(retjson) for entry in retobj: self._files.append( (str(entry['file']), self._nevents, self._nevents + entry['events']) ) # str() is needed since the output is a unicode string self._nevents += entry['events'] OK = True print "Successful URL ", u break except: print "Failed the individual query: ", query pass if not OK: if self.aggressive == 3 and "/store/mc" in f: print "Will skip file ", f continue raise RuntimeError, "Failed to file %s in any way. aborting job " % f else: print self._files if self.aggressive == 3 and self._nevents == 0: raise RuntimeError, "Failed to find all files for this component. aborting job " self._fileindex = -1 self._localCopy = None self.events = None ## Discover where I am self.inMeyrin = True if 'LSB_JOBID' in os.environ and 'HOSTNAME' in os.environ and self.aggressive == 1: hostname = os.environ['HOSTNAME'].replace(".cern.ch", "") try: wigners = subprocess.check_output(["bmgroup", "g_wigner"]).split() if hostname in wigners: self.inMeyrin = False print "Host %s is in bmgroup g_wigner, so I assume I'm in Wigner and not Meyrin" % hostname except: pass ## How aggressive should I be? # 0 = default; 1 = always fetch from Wigner; 2 = always fetch from anywhere if it's a xrootd url def __len__(self): return self._nevents def __getattr__(self, key): return getattr(self.events, key) def isLocal(self, filename): if self.aggressive == -2: return True if filename.startswith( "root://") and not filename.startswith("root://eoscms"): return False # always prefetch AAA if self.aggressive == -1: return True if self.aggressive >= 2: return False if self.aggressive >= 1 and not self.inMeyrin: return False fpath = filename.replace("root://eoscms.cern.ch//", "/").replace("root://eoscms//", "/") if "?" in fpath: fpath = fpath.split["?"][0] try: finfo = subprocess.check_output(["eos", "fileinfo", fpath]) replicas = False nears = False for line in finfo.split("\n"): if line.endswith("geotag"): replicas = True elif replicas and ".cern.ch" in line: geotag = int(line.split()[-1]) print "Found a replica with geotag %d" % geotag if self.inMeyrin: if geotag > 9000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away else: if geotag < 1000: return False # far replica: bad (EOS sometimes gives the far even if there's a near!) else: nears = True # we have found a replica that is far away # if we have found some near replicas, and no far replicas if nears: return True except: pass # we don't know, so we don't transfer (better slow than messed up) return True def __getitem__(self, iEv): if self._fileindex == -1 or not ( self._files[self._fileindex][1] <= iEv and iEv < self._files[self._fileindex][2]): self.events = None # so it's closed if self._localCopy: print "Removing local cache file %s" % self._localCopy try: os.remove(self._localCopy) except: pass self._localCopy = None for i, (fname, first, last) in enumerate(self._files): if first <= iEv and iEv < last: print "For event range [ %d, %d ) will use file %r " % ( first, last, fname) self._fileindex = i if fname.startswith("root://eoscms") or ( self.aggressive >= 2 and fname.startswith("root://")): if not self.isLocal(fname): tmpdir = os.environ[ 'TMPDIR'] if 'TMPDIR' in os.environ else "/tmp" rndchars = "".join( [hex(ord(i))[2:] for i in os.urandom(8)] ) if not self.long_cache else "long_cache-id%d-%s" % ( os.getuid(), hashlib.sha1(fname).hexdigest()) localfile = "%s/%s-%s.root" % ( tmpdir, os.path.basename(fname).replace( ".root", ""), rndchars) if self.long_cache and os.path.exists(localfile): print "Filename %s is already available in local path %s " % ( fname, localfile) fname = localfile else: try: print "Filename %s is remote (geotag >= 9000), will do a copy to local path %s " % ( fname, localfile) start = timeit.default_timer() subprocess.check_output([ "xrdcp", "-f", "-N", fname, localfile ]) print "Time used for transferring the file locally: %s s" % ( timeit.default_timer() - start) if not self.long_cache: self._localCopy = localfile fname = localfile except: print "Could not save file locally, will run from remote" if os.path.exists(localfile): os.remove( localfile ) # delete in case of incomplete transfer print "Will run from " + fname self.events = FWLiteEvents([fname]) break self.events.to(iEv - self._files[self._fileindex][1]) return self def endLoop(self): if '_localCopy' not in self.__dict__: return todelete = self.__dict__['_localCopy'] if todelete: print "Removing local cache file ", todelete os.remove(todelete) def __del__(self): self.endLoop()
indicies = events.fileIndicies() for event in events: newIndicies = event.fileIndicies() if indicies != newIndicies: print "new file" indicies = newIndicies event.getByLabel('Thing', thingHandle) thing = thingHandle.product() for loop in range(thing.size()): print thing.at(loop).a events.toBegin() for event in events: pass events.toBegin() for event in events: event.getByLabel('Thing', thingHandle) thing = thingHandle.product() for loop in range(thing.size()): print thing.at(loop).a for i in xrange(events.size()): if not events.to(i): print "failed to go to index ", i exit(1) print "Python test succeeded!"
count=0 oldRun=-99 for event0 in events0: ##print event.eventAuxiliary().event(), event.eventAuxiliary().run(), event.eventAuxiliary().luminosityBlock() #Need to pick up the same events in the other file event0.getByLabel (recHitLabel, recHitProductLabel, recHithandle) recHits0=recHithandle.product() if oldRun!=event0.eventAuxiliary().run(): oldRun=event0.eventAuxiliary().run() print 'processing run:', oldRun #if count>100: break events1.to(count) #print event0.eventAuxiliary().event(), event0.eventAuxiliary().run(), event0.eventAuxiliary().luminosityBlock()##, event1.eventAuxiliary().event(), event1.eventAuxiliary().run(), event1.eventAuxiliary().luminosityBlock() for event1 in events1: #print 'event1', event1.eventAuxiliary().event(), event1.eventAuxiliary().run(), event1.eventAuxiliary().luminosityBlock() if event1.eventAuxiliary().event()!=event0.eventAuxiliary().event() and event1.eventAuxiliary().run()!=event0.eventAuxiliary().run(): break event1.getByLabel (recHitLabel, recHitProductLabel, recHithandle) recHits1=recHithandle.product() checkRawID=-99 for n, rechit0 in enumerate(recHits0): rechit1=recHits1[n] #print rechit0.detid().rawId(), rechit0.chi2(), rechit1.detid().rawId(), rechit1.chi2() if rechit0.chi2()!=rechit1.chi2(): evtList.append([event0.eventAuxiliary().run(), event0.eventAuxiliary().luminosityBlock(), event0.eventAuxiliary().event(), rechit0.detid().rawId()])
from DataFormats.FWLite import Handle, Events from ROOT import gROOT, gStyle, TCanvas, TF1, TFile, TTree, gRandom, TH1F, TH2F import os eventsRef = Events("ReReco_1.root") tracksRef = Handle("std::vector<reco::Track>") label = "generalTracks" quality = "highPurity" #quality = "tight" #quality = "loose" for i in range(0, eventsRef.size()): #for i in range(0, 200): a = eventsRef.to(i) print "Event", i a = eventsRef.getByLabel(label, tracksRef) trVal = [] for track in tracksRef.product(): # if (track.phi()<0) : continue # if (track.eta()<0) : continue # if (track.pt()<5) : continue # if (track.quality(track.qualityByName(quality))) : pattern = track.hitPattern() if (pattern.numberOfValidHits() != (pattern.numberOfValidPixelHits() + pattern.numberOfValidStripHits())): print pattern.numberOfValidHits(), pattern.numberOfValidPixelHits( ), pattern.numberOfValidStripHits( ), pattern.numberOfValidPixelHits( ) + pattern.numberOfValidStripHits() # trVal.append([10*int(100*track.eta())+track.phi(), "ori", track.eta(), track.phi(), track.pt(), track.numberOfValidHits() , track.hitPattern().numberOfValidPixelHits(), track.ndof(),track.chi2(),
from DataFormats.FWLite import Handle, Events from ROOT import gROOT, gStyle, TCanvas, TF1, TFile, TTree, gRandom, TH1F, TH2F import os eventsOri = Events("step3_ori.root") eventsNew = Events("step3.root") tracksOri = Handle("std::vector<reco::Track>") tracksNew = Handle("std::vector<reco::Track>") label = "generalTracks" quality = "highPurity" for i in range(0, eventsOri.size()): a = eventsOri.to(i) a = eventsNew.to(i) # print "Event", i a = eventsOri.getByLabel(label, tracksOri) a = eventsNew.getByLabel(label, tracksNew) ntOri = tracksOri.product().size() ntNew = tracksOri.product().size() if (ntOri != ntNew): print i, ntOri, ntNew
elist = ROOT.gDirectory.Get("eList") number_events = elist.GetN() print "Reading: ", sample[ "name"], bin, "file", file, "with", number_events, "Events using cut", commoncf if small: if number_events > 1000: number_events = 1000 for i in range(0, number_events): if (i % 100000 == 0) and i > 0: print i # # Update all the Tuples if elist.GetN() > 0 and ntot > 0: c.GetEntry(elist.GetEntry(i)) # MC specific part if mode == "MC": events.to(elist.GetEntry(i)) events.getByLabel(label, handle) gps = handle.product() lgp = [] lgp2 = [] igp = 0 for gp in gps: if gp.status() == 3: lgp.append(gp) if (abs(gp.pdgId() == 11) or abs( gp.pdgId() == 13)) and gp.pt() > 3.: lgp2.append(gp) lgp2 = sorted(lgp2, key=lambda k: -k.pt()) s.ngp = min(len(lgp) + len(lgp2), 20) for igp, gp in enumerate(lgp):
def compare(target_file, ref_file, file_prefix="file:", out_dir="./"): ### Objects from file ### eles, ele_label = Handle("std::vector<pat::Electron>"), "slimmedElectrons" eles_ref = Handle("std::vector<pat::Electron>") phos, pho_label = Handle("std::vector<pat::Photon>"), "slimmedPhotons" phos_ref = Handle("std::vector<pat::Photon>") ### Events loop ### min_pho_et = 10 min_ele_et = 5 do_phos = True do_eles = True evtLUT = {} events_ref = Events(file_prefix + ref_file) for event_nr, event in enumerate(events_ref): runnr = event.eventAuxiliary().run() eventnr = event.eventAuxiliary().event() lumi = event.eventAuxiliary().luminosityBlock() if runnr not in evtLUT: evtLUT[runnr] = {} if lumi not in evtLUT[runnr]: evtLUT[runnr][lumi] = {} evtLUT[runnr][lumi][eventnr] = event_nr events = Events(file_prefix + target_file) ele_diffs = EleDiffSummary() pho_diffs = PhoDiffSummary() for event_nr, event in enumerate(events): runnr = event.eventAuxiliary().run() eventnr = event.eventAuxiliary().event() lumi = event.eventAuxiliary().luminosityBlock() event_found = events_ref.to(evtLUT[runnr][lumi][eventnr]) event_id = str(event.eventAuxiliary().run()) + ":" + str( event.eventAuxiliary().luminosityBlock()) + ":" + str( event.eventAuxiliary().event()) if do_phos: event.getByLabel(pho_label, phos) events_ref.getByLabel(pho_label, phos_ref) for pho_nr, pho in enumerate(phos.product()): if pho.et() < min_pho_et: continue pho_ref = match_by_sc(pho, phos_ref.product()) pho_diffs.fill(pho, pho_ref) if do_eles: event.getByLabel(ele_label, eles) events_ref.getByLabel(ele_label, eles_ref) for ele_nr, ele in enumerate(eles.product()): if ele.et() < min_ele_et: continue ele_ref = match_by_sc(ele, eles_ref.product()) ele_diffs.fill(ele, ele_ref) target_path_file = os.path.split(target_file) ref_path_file = os.path.split(ref_file) hashstr = hashlib.md5(target_file).hexdigest() out_tag_phos = "pho_{}".format(hashstr) out_tag_eles = "ele_{}".format(hashstr) comp_strs = [] comp_strs.append("<br><br>file = {}<br>".format(target_path_file[1])) comp_strs.append("target dir = {}<br>".format(target_path_file[0])) comp_strs.append("reference dir = {}<br>".format(ref_path_file[0])) comp_strs.append("Photons<br>") comp_strs.append(pho_diffs.create_summary(out_dir, out_tag_phos)) comp_strs.append("Electrons<br>") comp_strs.append(ele_diffs.create_summary(out_dir, out_tag_eles)) # pho_diffs.create_summary(out_dir) return '\n'.join(comp_strs)
def loop(fname) : genPars = Handle("vector<reco::GenParticle>") genParsLabel = "prunedGenParticles" gPar = [Handle("vector<pat::PackedGenParticle>"), "packedGenParticles"] vertices = [Handle("vector<reco::Vertex>"), "offlineSlimmedPrimaryVertices" ] mus = [Handle("vector<pat::Muon>"), "slimmedMuons"] sip2d = TH1F("SIP2D","SIP2D",40,-10.,10.) sip3d = TH1F("SIP3D","SIP3D",40,-10.,10.) sipxy = TH1F("tk2d","TK SIPXY",40,-10.,10.) sipz = TH1F("tk3z","TK SIPZ",40,-10.,10.) sip3d_l = TH1F("SIP2D l","SIP2D l",40,-10.,10.) sip3d_h = TH1F("SIP2D h","SIP2D h",40,-10.,10.) sip3d_best = TH1F("SIP2D best","SIP2D best",40,-10.,10.) vert = TH1F("zpv","zpv",100,-10.,10.) sip_v = TProfile("SIP2D vs zpv","SIP2D best vs zpv",50,0.,5.,0.,10.) # eventsRef = Events(fname) nw=0 nehpt=0 nwhpt=0 nech=0 nwch=0 # for i in range(0, eventsRef.size()): a= eventsRef.to(i) print "Event", i a=eventsRef.getByLabel(genParsLabel, genPars) zpv=0 gpvp = genPars.product()[0].vertex() for part in genPars.product(): if (part.vz()!=0) : zpv = part.vz() gpvp = part.vertex() break print "zpv " , zpv # nmu=0 nel=0 nch1=0 nch2=0 gmu = [] for part in genPars.product(): if (part.status()!=1) : continue if (abs(part.pdgId())==13 and part.pt()>5 and abs(part.eta())<2.4) : gmu.append((part.phi(),part.eta(), part.charge()*part.pt())) if (abs(part.pdgId())==13 and part.pt()>5 and abs(part.eta())<2.4) : nmu+=1 if (abs(part.pdgId())==11 and part.pt()>7 and abs(part.eta())<2.4) : nel+=1 if (abs(part.pdgId())==13 and part.pt()>8 and abs(part.eta())<2.4) : nch1+=1 if (abs(part.pdgId())==11 and part.pt()>10 and abs(part.eta())<2.4) : nch1+=1 if (abs(part.pdgId())==13 and part.pt()>20 and abs(part.eta())<2.4) : nch2+=1 if (abs(part.pdgId())==11 and part.pt()>20 and abs(part.eta())<2.4) : nch2+=1 # if (abs(part.pdgId())==13): # print "part", part.phi(),part.eta(), part.pt(), part.vz(), part.vx(), part.vy(), part.mass(), part.pdgId(), part.status() # print "nmu ", nmu,nel # print gmu a=eventsRef.getByLabel(vertices[1],vertices[0]) minz=99999. iv=0 ii=0 pv = vertices[0].product()[0] pvp = vertices[0].product()[0].position() nv = vertices[0].product().size() for v in vertices[0].product() : if (abs(v.z()-zpv) < minz) : minz=abs(v.z()-zpv) iv = ii ii+=1 print "pv ", iv, minz if (iv!=0) : nw+=1 # if (nmu+nel>3) : if (nmu>1) : nehpt+=1 if (iv!=0) : nwhpt+=1 # if (nch1>0 and nch2>0) : if (nch1<1) : continue # nech+=1 if (iv!=0) : nwch+=1 a=eventsRef.getByLabel(mus[1],mus[0]) pmus = [] for mu in mus[0].product() : if (mu.pt()<5) : continue # if ( mu.isTrackerMuon() or mu.isGlobalMuon()) : if ( mu.isGlobalMuon()) : pmus.append(( mu.phi(), mu.eta(), mu.pt()*mu.charge(), mu.dB(2)/mu.edB(2), mu.dB(1)/mu.edB(1), mu.track().dxy(gpvp)/mu.track().dxyError(), mu.track().dz(gpvp)/mu.track().dzError(), mu.track().hitPattern().pixelLayersWithMeasurement() )) # print 'mu', iv, mu.phi(), mu.eta(), mu.pt(), mu.dB(2)/mu.edB(2), mu.dB(1)/mu.edB(1), mu.isTrackerMuon(), mu.isGlobalMuon() # print pmus matches = [] i=0 for g in gmu : j = 0 for mu in pmus : j+=1 if ( g[2]/mu[2] < 0.5 or g[2]/mu[2] > 2.0 ) : continue dr = dR2(g[0],g[1],mu[0],mu[1]) if ( dr > 0.04 ) : continue matches.append((i,j-1, dr, abs(1.-g[2]/mu[2]))) #print "matched mu", mu i+=1 if (len(matches)<1 ) : continue vert.Fill((pv.z()-zpv)/pv.zError()) k=matches[0][0] best = 99999 dr = 999999 for m in matches : # if (abs(pv.z()-zpv)<3*pv.zError()) : if(pmus[m[1]][7]>2) : # if (nv<21) : sip3d_l.Fill(pmus[m[1]][3]) else : sip3d_h.Fill(pmus[m[1]][3]) sip2d.Fill(pmus[m[1]][4]) sip3d.Fill(pmus[m[1]][3]) sipxy.Fill(pmus[m[1]][5]) sipz.Fill(pmus[m[1]][6]) sip_v.Fill(abs(pv.z()-zpv)/pv.zError(),abs(pmus[m[1]][5])) if (m[0]!=k) : sip3d_best.Fill(best) k=m[0] best = pmus[m[1]][4] dr = m[3] else : if (m[3]<dr ): dr = m[3] best = pmus[m[1]][4] if (dr<9999) : sip3d_best.Fill(best) print "wrong pv", nw, nehpt, nwhpt,nech,nwch c1 = TCanvas( 'c1', fname, 200, 10, 1000, 1400 ) gStyle.SetOptStat(111111) gStyle.SetHistLineWidth(2) c1.Divide(2,4) c1.cd(1).SetLogy() sip2d.DrawNormalized() e = TF1("q","0.5*exp(-0.5*x*x)/sqrt(6.28)",-10.,10.) e.Draw("same") c1.cd(2).SetLogy() sip3d.DrawNormalized() e.Draw("same") c1.cd(3).SetLogy() sipxy.DrawNormalized() e.Draw("same") c1.cd(4).SetLogy() sipz.DrawNormalized() e.Draw("same") c1.cd(5).SetLogy() sip3d_l.DrawNormalized() e.Draw("same") c1.cd(6).SetLogy() sip3d_h.DrawNormalized() e.Draw("same") # sip3d_best.DrawNormalized() c1.cd(7).SetLogy() vert.DrawNormalized() # ev = TF1("qv","0.2*exp(-0.5*x*x)/sqrt(6.28)",-10.,10.) # ev.Draw("same") c1.cd(8) sip_v.Draw() c1.Print("sipall"+fname+".png")
def main(args): MAX_FILES_TO_PROCESS = args.maxfiles x_axis_definition = [40, 0.5, 40.5] if args.bxaxis: x_axis_definition = [4000, -0.5, 3999.5] numerical_lumi = [] numerical_bn = [] bunch_to_train = [0 for x in range(4000)] # In case the user specified LS using the range syntax X-Y, extend it in the form X, X+1, ..., Y. if args.lumi: numerical_lumi.extend(explicitRange(args.lumi)) # Same range extension for the BX number if args.bn: numerical_bn.extend(explicitRange(args.bn)) if args.alltrainsaverage: numerical_bn.extend(explicitRange(args.alltrainsaverage, bunch_to_train)) if args.alltrains: numerical_bn.extend([i for i in range(0,4000)]) print "\nSelecting LS: ", numerical_lumi print "\nSelecting BN: ", numerical_bn print "\nBunch to Train: ", bunch_to_train f = TFile(args.output, "RECREATE") tracks_h = Handle("std::vector<reco::Track>") pv_h = Handle("std::vector<reco::Vertex>") hit_type = {0:'ok', 1:'missing', 2:'inactive', 3:'bad'} hit_category = {0:'track_hits', 1:'missing_inner_hits', 2:'missing_outer_hits'} det = {1:'PXB', 2:'PXF', 3:'TIB', 4:'TID', 5:'TOB', 6:'TEC'} subdet = {'PXB': { 1:'Layer1', 2:'Layer2', 3:'Layer3'}, 'PXF': { 1:'Disk1', 2:'Disk2'}, 'TIB': { 1:'Layer1', 2:'Layer2', 3:'Layer3', 4:'Layer4'}, 'TID': { 1:'wheel1', 2:'wheel2', 3:'wheel3'}, 'TOB': { 1:'Layer1', 2:'Layer2', 3:'Layer3', 4:'Layer4', 5:'Layer5', 6:'Layer6'}, 'TEC': { 1:'wheel1', 2:'wheel2', 3:'wheel3', 4:'wheel4', 5:'wheel5', 6:'wheel6', 7:'wheel7', 8:'wheel8', 9:'wheel9'}} histograms = {} histograms_barrel = {} histograms_endcap = {} for d in subdet.keys(): for sd in subdet[d].keys(): name = d+subdet[d][sd] histograms.setdefault(name, {}).setdefault(0, TH1F('Hits_ok_%s' % name, 'Hits_ok_%s' % name, *x_axis_definition)).Sumw2 histograms.setdefault(name, {}).setdefault(1, TH1F('Hits_missing_%s' % name, 'Hits_missing_%s' % name, *x_axis_definition)).Sumw2 histograms.setdefault(name, {}).setdefault(2, TH1F('Hits_inactive_%s' % name, 'Hits_inactive_%s' % name, *x_axis_definition)).Sumw2 histograms.setdefault(name, {}).setdefault(3, TH1F('Hits_bad_%s' % name, 'Hits_bad_%s' % name, *x_axis_definition)).Sumw2 histograms.setdefault(name, {}).setdefault(4, TH1F('Hits_ok_and_missing_%s' % name, 'Hits_ok_and_missing_%s' % name, *x_axis_definition)).Sumw2 histograms_barrel.setdefault(name, {}).setdefault(0, TH1F('Hits_ok_%s_barrel' % name, 'Hits_ok_%s_barrel' % name, *x_axis_definition)).Sumw2 histograms_barrel.setdefault(name, {}).setdefault(1, TH1F('Hits_missing_%s_barrel' % name, 'Hits_missing_%s_barrel' % name, *x_axis_definition)).Sumw2 histograms_barrel.setdefault(name, {}).setdefault(2, TH1F('Hits_inactive_%s_barrel' % name, 'Hits_inactive_%s_barrel' % name, *x_axis_definition)).Sumw2 histograms_barrel.setdefault(name, {}).setdefault(3, TH1F('Hits_bad_%s_barrel' % name, 'Hits_bad_%s_barrel' % name, *x_axis_definition)).Sumw2 histograms_barrel.setdefault(name, {}).setdefault(4, TH1F('Hits_ok_and_missing_%s_barrel' % name, 'Hits_ok_and_missing_%s_barrel' % name, *x_axis_definition)).Sumw2 histograms_endcap.setdefault(name, {}).setdefault(0, TH1F('Hits_ok_%s_endcap' % name, 'Hits_ok_%s_endcap' % name, *x_axis_definition)).Sumw2 histograms_endcap.setdefault(name, {}).setdefault(1, TH1F('Hits_missing_%s_endcap' % name, 'Hits_missing_%s_endcap' % name, *x_axis_definition)).Sumw2 histograms_endcap.setdefault(name, {}).setdefault(2, TH1F('Hits_inactive_%s_endcap' % name, 'Hits_inactive_%s_endcap' % name, *x_axis_definition)).Sumw2 histograms_endcap.setdefault(name, {}).setdefault(3, TH1F('Hits_bad_%s_endcap' % name, 'Hits_bad_%s_endcap' % name, *x_axis_definition)).Sumw2 histograms_endcap.setdefault(name, {}).setdefault(4, TH1F('Hits_ok_and_missing_%s_endcap' % name, 'Hits_ok_and_missing_%s_endcap' % name, *x_axis_definition)).Sumw2 files = [] if args.input: files.extend(args.input) elif args.eosdir: files.extend(map(lambda x: 'root://eoscms/'+ x, getFileListFromEOS(args.eosdir)) ) else: print 'No input given, quitting' sys.exit(1) total_files = 0 if MAX_FILES_TO_PROCESS < 0: total_files = len(files) else: total_files = min(MAX_FILES_TO_PROCESS, len(files)) analyzed_files = 0 start_cumulative_time = time() start_time = start_cumulative_time end_time = start_cumulative_time file_count = -1 for input_file in files: file_count += 1 analyzed_files += 1 if MAX_FILES_TO_PROCESS > 0 and analyzed_files > MAX_FILES_TO_PROCESS: break print "\n", input_file events = Events(input_file) total_events = float(events.size()) analized_events = 0. for e in range(events.size()): analized_events += 1.0 if analized_events*100./total_events == 100: end_time = time() if not args.debug: sys.stdout.write("\r %d/%d --> %4.1f [%4.1f m / %6f s] ETA: %4.1f m ==> LS: %d" % (file_count, total_files, analized_events*100./total_events, (end_time-start_time)/60.,(end_time-start_time), (end_time-start_cumulative_time)/(60.*analyzed_files) * (total_files - analyzed_files), events.eventAuxiliary().luminosityBlock())) start_time = end_time sys.stdout.flush() a = events.to(e) if args.lumi: if not events.eventAuxiliary().luminosityBlock() in numerical_lumi: continue if len(numerical_bn) !=0 and not events.eventAuxiliary().bunchCrossing() in numerical_bn: continue a = events.getByLabel("generalTracks", tracks_h) a = events.getByLabel("offlinePrimaryVertices", pv_h) good_vertices = getNumberOfGoodVertices(pv_h) if good_vertices < 1: continue for track in range(tracks_h.product().size()): t = tracks_h.product()[track] if not t.quality(t.qualityByName("highPurity")): continue if t.pt() < 1.0 or t.dxy() > 0.1: continue hp = t.hitPattern() if args.debug: print "\n\n" for category in hit_category.keys(): if args.debug: print hit_category[category], "pt, eta, phi, dxy, originalAlgo-4", t.pt(), t.eta(), t.phi(), t.dxy(), t.originalAlgo()-4 for hit in range(0, hp.numberOfHits(category)): pattern = hp.getHitPattern(category, hit) valid = hp.validHitFilter(pattern) missing = hp.missingHitFilter(pattern) inactive = hp.inactiveHitFilter(pattern) bad = hp.badHitFilter(pattern) hit_type = -1 if valid: hit_type = 0 elif missing: hit_type = 1 elif inactive: hit_type = 2 elif bad: hit_type = 3 d = det[hp.getSubStructure(pattern)] sd = subdet[d][hp.getSubSubStructure(pattern)] name = d+sd if args.overwrite: good_vertices = args.overwrite if args.alltrainsaverage is not None: good_vertices = bunch_to_train[events.eventAuxiliary().bunchCrossing()] if args.alltrains: good_vertices = events.eventAuxiliary().bunchCrossing() if abs(t.eta()) < 1.4: if name in histograms_barrel.keys(): histograms_barrel[name][hit_type].Fill(good_vertices) else: if name in histograms_endcap.keys(): histograms_endcap[name][hit_type].Fill(good_vertices) if name in histograms.keys(): # We don't do any selection on any category other than missing! if hit_type != 1: histograms[name][hit_type].Fill(good_vertices) else: if args.hitcategory and not category in args.hitcategory: continue histograms[name][hit_type].Fill(good_vertices) if args.debug: printPattern(hit, category, d, sd, hp, pattern) f.cd() for kind in histograms.keys(): histograms[kind][4].Add(histograms[kind][0]+histograms[kind][1]) histograms.setdefault(kind, {}).setdefault(5, TGraphAsymmErrors(histograms[kind][0], histograms[kind][4])).Write() histograms_barrel[kind][4].Add(histograms_barrel[kind][0]+histograms_barrel[kind][1]) histograms_barrel.setdefault(kind, {}).setdefault(5, TGraphAsymmErrors(histograms_barrel[kind][0], histograms_barrel[kind][4])).Write() histograms_endcap[kind][4].Add(histograms_endcap[kind][0]+histograms_endcap[kind][1]) histograms_endcap.setdefault(kind, {}).setdefault(5, TGraphAsymmErrors(histograms_endcap[kind][0], histograms_endcap[kind][4])).Write() if args.debug: f.ls() f.Write() f.Close()
eventsRef = Events(fname+'.root') tracksRef = Handle("std::vector<reco::Track>") label = "generalTracks" quality = "highPurity" #quality = "tight" #quality = "loose" mvaRef = Handle("std::vector<float>") mcMatchRef = Handle("std::vector<float>") for i in range(0, eventsRef.size()): #for i in range(0, 200): a= eventsRef.to(i) print "Event", i a=eventsRef.getByLabel(label, tracksRef) a=eventsRef.getByLabel(label, 'MVAValues',mvaRef) a=eventsRef.getByLabel("trackMCQuality",mcMatchRef) mcMatch = mcMatchRef.product() mva = mvaRef.product() trVal = [] k = -1 for track in tracksRef.product(): k+=1 # if (track.phi()<0) : continue # if (abs(track.eta())>2.3) : continue # if (track.pt()<4) : continue # if (track.quality(track.qualityByName(quality))) : writer.writerow([i,track.eta(), track.phi(), track.pt(),
eventsRef = Events("arizzi_53XRECO_step3.root") eventsNew = Events("step3all-samesim.root") tracksRef = Handle("std::vector<reco::Track>") tracksNew = Handle("std::vector<reco::Track>") label = "generalTracks" quality = "highPurity" #quality = "tight" #quality = "loose" for i in range(0, eventsRef.size()): #for i in range(0, 200): a= eventsRef.to(i) print "Event", i a=eventsRef.getByLabel(label, tracksRef) trVal = [] for track in tracksRef.product(): # if (track.phi()<0) : continue # if (track.eta()<0) : continue if (track.pt()<5) : continue if (track.quality(track.qualityByName(quality))) : trVal.append([10*int(100*track.eta())+track.phi(), "ori", track.eta(), track.phi(), track.pt(), track.numberOfValidHits() , track.hitPattern().numberOfValidPixelHits(), track.ndof(),track.chi2(), track.algo()-4,track.quality(track.qualityByName("highPurity"))]) ori = len(trVal) a= eventsNew.to(i) a=eventsNew.getByLabel(label, tracksNew) for track in tracksNew.product(): # if (track.phi()<0) : continue # if (track.eta()<0) : continue
class Looper(object): '''Creates a set of analyzers, and schedules the event processing.''' def __init__(self, name, cfg_comp, sequence, nPrint=0): '''Handles the processing of an event sample. An Analyzer is built for each Config.Analyzer present in sequence. The Looper can now be used to process an event, or a collection of events in the sample. name : name of the Looper, will be used as the output directory name cfg_comp: information for the input sample, see Config sequence: an ordered list of Config.Analyzer nPrint : number of events to print at the beginning ''' self.name = self._prepareOutput(name) self.outDir = self.name self.logger = logging.getLogger(self.name) self.logger.addHandler( logging.FileHandler('/'.join([self.name, 'log.txt']))) self.logger.addHandler(logging.StreamHandler(sys.stdout)) self.cfg_comp = cfg_comp self.classes = {} #TODO: should be a diclist? self.analyzers = map(self._buildAnalyzer, sequence) self.nPrint = nPrint # initialize FWLite chain on input file: try: self.events = Events(glob.glob(self.cfg_comp.files)) except RuntimeError: print 'cannot find any file matching pattern', self.cfg_comp.files raise def _prepareOutput(self, name): index = 0 tmpname = name while True: try: # print 'mkdir', self.name os.mkdir(tmpname) break except OSError: index += 1 tmpname = '%s_%d' % (name, index) return tmpname def _buildAnalyzer(self, cfg_ana): obj = None className = cfg_ana.name.split('_')[0] theClass = None try: # obviously, can't load a module twice # so keep track of the needed classes, instead several instances are built theClass = self.classes[className] print 'found class', theClass obj = theClass(cfg_ana, self.cfg_comp, self.outDir) except KeyError: try: file, path, desc = imp.find_module(className) mod = imp.load_module(className, file, path, desc) # getting the analyzer class object theClass = mod.__dict__[className] self.classes[className] = theClass # creating an analyzer #if hasattr( cfg_ana, 'instanceName'): # cfg_ana.name = cfg_ana.instanceName print 'loading class', theClass obj = theClass(cfg_ana, self.cfg_comp, self.outDir) finally: file.close() return obj def loop(self, nEvents=None): '''Loop on a given number of events. At the beginning of the loop, Analyzer.beginLoop is called for each Analyzer. At each event, self.process is called. At the end of the loop, Analyzer.endLoop is called.''' if nEvents is None: nEvents = self.events.size() else: nEvents = int(nEvents) eventSize = nEvents print 'starting loop, to process', eventSize, 'events.' for analyzer in self.analyzers: analyzer.beginLoop() for iEv in range(0, eventSize): if iEv == nEvents: break if iEv % 100 == 0: print 'event', iEv self.process(iEv) if iEv < self.nPrint: print self.event for analyzer in self.analyzers: analyzer.endLoop() self.logger.warning('') self.logger.warning(self.cfg_comp) self.logger.warning('') self.logger.warning( 'number of events processed: {nEv}'.format(nEv=eventSize)) def process(self, iEv): '''Run event processing for all analyzers in the sequence. This function is called by self.loop, but can also be called directly from the python interpreter, to jump to a given event. TODO: add an example for event investigation. ''' self.event = Event(iEv) self.iEvent = iEv self.events.to(iEv) for analyzer in self.analyzers: if analyzer.process(self.events, self.event) == False: return (False, analyzer.name) return (True, analyzer.name) def write(self): '''Writes all analyzers. See Analyzer.Write for more information.''' for analyzer in self.analyzers: analyzer.write() pass
import ROOT from DataFormats.FWLite import Events, Handle from PhysicsTools.PythonAnalysis import * events_new = Events(['step3_newCalib.root']) events_old = Events(['step3_RAW2DIGI_RECO.root']) edmCollections = [ {'name':'pfMet', 'label':("pfMet"), 'edmType':"vector<reco::PFMET>"} ] handles={v['name']:Handle(v['edmType']) for v in edmCollections} for i in range(10): events_new.to(i) products_new = {} for v in edmCollections: events_new.getByLabel(v['label'],handles[v['name']]) products_new[v['name']] =handles[v['name']].product() events_old.to(i) products_old = {} for v in edmCollections: events_old.getByLabel(v['label'],handles[v['name']]) products_old[v['name']] =handles[v['name']].product() print "new",products_new['pfMet'][0].pt(), 'old', products_old['pfMet'][0].pt()
c.Draw(">>eList", commoncf) elist = ROOT.gDirectory.Get("eList") number_events = elist.GetN() print "Reading: ", sample["name"], bin, "with",number_events,"Events using cut", commoncf if small: if number_events>1000: number_events=1000 for i in range(0, number_events): if (i%10000 == 0) and i>0 : print i # # Update all the Tuples if elist.GetN()>0 and ntot>0: c.GetEntry(elist.GetEntry(i)) # MC specific part if not sample['name'].lower().count('data'): events.to(elist.GetEntry(i)) events.getByLabel(label,handle) gps = handle.product() if storeVectors: lgp = [] lgp2 = [] igp = 0 for gp in gps: if gp.status() == 3: lgp.append(gp) if (abs(gp.pdgId()==11) or abs(gp.pdgId()==13)) and gp.pt() > 3.: lgp2.append(gp) lgp2 = sorted(lgp2, key=lambda k: -k.pt()) s.ngp = min(len(lgp)+len(lgp2),20) for igp,gp in enumerate(lgp): s.gpPdg[igp] = gp.pdgId()
def launchNtuple(fileOutput, filesInput, maxEvents, preProcess=True, LS=None): t0 = time.time() print "Outputfile: {0}".format(fileOutput) print "Inputfiles: {0}".format(filesInput) print "MaxEvents; {0}".format(maxEvents) import os dir_ = os.getcwd() if preProcess: hltdumpFile = "hlt_dump.py" cmsswConfig = imp.load_source("cmsRunProcess", os.path.expandvars(hltdumpFile)) cmsswConfig.process.maxEvents.input = maxEvents cmsswConfig.process.source.fileNames = filesInput if LS is not None: print LS cmsswConfig.process.source.lumisToProcess = LS else: cmsswConfig.process.source.lumisToProcess = [] configfile = dir_ + "/mod_hlt_dump.py" f = open(configfile, 'w') f.write(cmsswConfig.process.dumpPython()) f.close() runstring = "{0} {1} >& {2}/cmsRun_hltDump.log".format( "cmsRun", configfile, dir_) print "Running pre-processor: %s " % runstring ret = os.system(runstring) if ret != 0: print "CMSRUN failed" exit(ret) print "Time to preprocess: {0:10f} s".format(time.time() - t0) print "Filesize of {0:8f} MB".format( os.path.getsize(dir_ + "/hltOut.root") * 1e-6) f = ROOT.TFile(fileOutput, "recreate") tree = ROOT.TTree("tree", "tree") fwLiteInputs = ["hltOut.root"] if len(filesInput) == 0: exit import os.path if not os.path.isfile(fwLiteInputs[0]): raise Exception(fwLiteInputs[0] + " does not exist.") events = Events(fwLiteInputs) triggerBits, triggerBitLabel = Handle("edm::TriggerResults"), ( "TriggerResults::MYHLT") triggerBits4RAW, triggerBitLabel4RAW = Handle("edm::TriggerResults"), ( "TriggerResults::HLT") #General event variables evt = SetVariable(tree, 'evt') lumi = SetVariable(tree, 'lumi') run = SetVariable(tree, 'run') events.to(0) for event in events: break #Add Branches of rerun menu event.getByLabel(triggerBitLabel, triggerBits) names = event.object().triggerNames(triggerBits.product()) triggerNames = names.triggerNames() for name in triggerNames: name = name.split("_v")[0] nTriggers = len(triggerNames) triggerVars = {} for trigger in triggerNames: triggerVars[trigger] = array('i', [0]) tree.Branch(trigger, triggerVars[trigger], trigger + '/O') #Add interesting brnaches from menu present in RAW interestingName = [ "HLTriggerFirstPath", "HLT_PFHT300PT30_QuadPFJet_75_60_45_40", "HLT_PFHT380_SixPFJet32_D", "HLTriggerFinalPath" ] event.getByLabel(triggerBitLabel4RAW, triggerBits4RAW) names4RAW = event.object().triggerNames(triggerBits4RAW.product()) triggerNames4RAW = names4RAW.triggerNames() for name4RAW in triggerNames4RAW: name4RAW = name4RAW.split("_v")[0] nTriggers4RAW = len(triggerNames4RAW) triggerVars4RAW = {} for trigger in triggerNames4RAW: for TIO in interestingName: if TIO in trigger: triggerVars4RAW[trigger] = array('i', [0]) tree.Branch("RAW_" + trigger, triggerVars4RAW[trigger], "RAW_" + trigger + '/O') nEvArray = array('i', [0]) tree.Branch("nEvents", nEvArray, "nEvents/I") crun = 0 cls = 0 print "Starting event loop" for iev, event in enumerate(events): run[0] = event.eventAuxiliary().run() lumi[0] = event.eventAuxiliary().luminosityBlock() evt[0] = event.eventAuxiliary().event() if crun != run[0] or cls != lumi[0]: crun = run[0] cls = lumi[0] print "-------------- Processing: ", crun, cls, " --------------" nEvArray[0] = 1 event.getByLabel(triggerBitLabel, triggerBits) names = event.object().triggerNames(triggerBits.product()) triggerspassing = [] for i, triggerName in enumerate(triggerNames): index = names.triggerIndex(triggerName) if checkTriggerIndex(triggerName, index, names.triggerNames()): triggerVars[triggerName][0] = triggerBits.product().accept( index) else: triggerVars[triggerName][0] = 0 event.getByLabel(triggerBitLabel4RAW, triggerBits4RAW) names = event.object().triggerNames(triggerBits4RAW.product()) for i, triggerName in enumerate(triggerNames4RAW): index = names.triggerIndex(triggerName) if checkTriggerIndex( triggerName, index, names.triggerNames()) and (triggerName in triggerVars4RAW.keys()): triggerVars4RAW[triggerName][0] = triggerBits4RAW.product( ).accept(index) if iev % 1000 == 1: print "Event: ", iev, " done." tree.Fill() f.Write() f.Close() print "Total time: {0:10f} s".format(time.time() - t0) print "Filesize of {0:8f} MB".format( os.path.getsize(dir_ + "/" + fileOutput) * 1e-6)
ptmiss = TH1F("pt miss","pt miss",100,-10.,10.) ptr = TH1F("pt ratio","pt ratio",100,-10.,10.) d0all = TH1F("d0 all","d0 all",100,-5.,5.) d0miss = TH1F("d0 miss","d0 miss",100,-5.,5.) d0r = TH1F("d0 ratio","d0 ratio",100,-5.,5.) dpall = TH1F("dp all","dp all",100,-0.5,0.5) dpmiss = TH1F("dp miss","dp miss",100,-0.5,0.5) dpr = TH1F("dp ratio","dp ratio",100,-0.5,0.5) algoall = TH1F("algo all","algo all",20,0,20) algomiss = TH1F("algo miss","algo miss",20,0,20) algor = TH1F("algo ratio","algo ratio",20,0,20) # for event in eventsRef: for i in range(0, eventsRef.size()): a= eventsRef.to(i) a= eventsNew.to(i) print "Event", i a=eventsRef.getByLabel(label, tracksRef) a=eventsNew.getByLabel(label, tracksNew) trRef = [] j = 0 for track in tracksRef.product(): if (track.found()<8) : continue if (track.quality(track.qualityByName(quality))) : dp = track.outerPosition().phi()-track.outerMomentum().phi() trRef.append((j,track.charge()*track.pt(), track.phi()+track.eta(),track.eta(),track.found(), track.hitPattern(), track.ndof(), track.chi2(), track.dxy(),dp, track.algo() )) j += 1 a = trRef.sort(key=lambda tr: tr[2]) print j trNew = []
import ROOT from DataFormats.FWLite import Events, Handle from PhysicsTools.PythonAnalysis import * events_new = Events([ '~/eos/cms/store/group/phys_jetmet/schoef/pickEvents/jack_metTailPhys14_susyHadronic/merged_bad_GEN-SIM_rereco_740_newPFHadCalib.root' ]) #events_old = Events(['~/eos/cms/store/group/phys_jetmet/schoef/pickEvents/jack_metTailPhys14_susyHadronic/merged_bad_GEN-SIM.root']) edmCollections = [{ 'name': 'pfMet', 'label': ("pfMet"), 'edmType': "vector<reco::PFMET>" }] handles = {v['name']: Handle(v['edmType']) for v in edmCollections} for i in range(events_new.size()): events_new.to(i) products_new = {} for v in edmCollections: events_new.getByLabel(v['label'], handles[v['name']]) products_new[v['name']] = handles[v['name']].product() # events_old.to(i) # products_old = {} # for v in edmCollections: # events_old.getByLabel(v['label'],handles[v['name']]) # products_old[v['name']] =handles[v['name']].product() print "new", products_new['pfMet'][0].pt( ) #, 'old', products_old['pfMet'][0].pt()
class Looper(object): '''Creates a set of analyzers, and schedules the event processing.''' def __init__( self, name, cfg_comp, sequence, nEvents=None, firstEvent=0, nPrint=0): '''Handles the processing of an event sample. An Analyzer is built for each Config.Analyzer present in sequence. The Looper can now be used to process an event, or a collection of events in the sample. name : name of the Looper, will be used as the output directory name cfg_comp: information for the input sample, see Config sequence: an ordered list of Config.Analyzer nPrint : number of events to print at the beginning ''' self.name = self._prepareOutput(name) self.outDir = self.name self.logger = logging.getLogger( self.name ) self.logger.addHandler(logging.FileHandler('/'.join([self.name, 'log.txt']))) self.logger.addHandler( logging.StreamHandler(sys.stdout) ) self.cfg_comp = cfg_comp self.classes = {} #TODO: should be a diclist? self.analyzers = map( self._buildAnalyzer, sequence ) self.nEvents = nEvents self.firstEvent = firstEvent self.nPrint = int(nPrint) # initialize FWLite chain on input file: # import pdb ; pdb.set_trace() try: self.events = Events( self.cfg_comp.files ) except RuntimeError: #import pdb ; pdb.set_trace() print 'cannot find any file matching pattern', self.cfg_comp.files raise def _prepareOutput(self, name): index = 0 tmpname = name while True: try: # print 'mkdir', self.name os.mkdir( tmpname ) break except OSError: index += 1 tmpname = '%s_%d' % (name, index) return tmpname def _buildAnalyzer(self, cfg_ana): obj = None className = cfg_ana.name.split('_')[0] theClass = None try: # obviously, can't load a module twice # so keep track of the needed classes, instead several instances are built theClass = self.classes[className] print 'found class', theClass obj = theClass( cfg_ana, self.cfg_comp, self.outDir ) except KeyError: file = None try: file, path, desc = imp.find_module( className ) mod = imp.load_module( className , file, path, desc ) # getting the analyzer class object theClass = mod.__dict__[ className ] self.classes[className] = theClass # creating an analyzer #if hasattr( cfg_ana, 'instanceName'): # cfg_ana.name = cfg_ana.instanceName print 'loading class', theClass print ' from', file obj = theClass( cfg_ana, self.cfg_comp, self.outDir ) finally: try: file.close() except AttributeError: print 'problem loading module', cfg_ana.name print 'please make sure that the module name is correct.' print 'if it is, is this module in your path, as defined below?' pprint.pprint( sorted( sys.path )) return obj def loop(self): '''Loop on a given number of events. At the beginning of the loop, Analyzer.beginLoop is called for each Analyzer. At each event, self.process is called. At the end of the loop, Analyzer.endLoop is called.''' nEvents = self.nEvents firstEvent = self.firstEvent iEv = firstEvent if nEvents is None or int (nEvents) > int (self.events.size()) : nEvents = self.events.size() else: nEvents = int(nEvents) eventSize = nEvents self.logger.warning('starting loop at event {firstEvent} to process {eventSize} events.'.format(firstEvent=firstEvent, eventSize=eventSize)) self.logger.warning( str( self.cfg_comp ) ) for analyzer in self.analyzers: analyzer.beginLoop() try: for iEv in range(firstEvent, firstEvent+eventSize): # if iEv == nEvents: # break if iEv%100 ==0: print 'event', iEv self.process( iEv ) if iEv<self.nPrint: print self.event except UserWarning: print 'Stopped loop following a UserWarning exception' for analyzer in self.analyzers: analyzer.endLoop() self.logger.warning('') self.logger.warning( self.cfg_comp ) self.logger.warning('') self.logger.warning( 'number of events processed: {nEv}'.format(nEv=iEv+1) ) def process(self, iEv ): '''Run event processing for all analyzers in the sequence. This function is called by self.loop, but can also be called directly from the python interpreter, to jump to a given event. TODO: add an example for event investigation. ''' self.event = Event( iEv ) self.iEvent = iEv self.events.to(iEv) for analyzer in self.analyzers: if not analyzer.beginLoopCalled: analyzer.beginLoop() if analyzer.process( self.events, self.event ) == False: return (False, analyzer.name) return (True, analyzer.name) def write(self): '''Writes all analyzers. See Analyzer.Write for more information.''' for analyzer in self.analyzers: analyzer.write() pass
for event in events: newIndicies = event.fileIndicies() if indicies != newIndicies: print "new file" indicies = newIndicies event.getByLabel ('Thing', thingHandle) thing = thingHandle.product() for loop in range (thing.size()): print thing.at (loop).a events.toBegin() for event in events: pass events.toBegin() for event in events: event.getByLabel ('Thing', thingHandle) thing = thingHandle.product() for loop in range (thing.size()): print thing.at (loop).a for i in xrange(events.size()): if not events.to(i): print "failed to go to index ",i exit(1) print "Python test succeeded!"
m21_multiplicity = ROOT.TH1F("m21_multiplicity","m21_multiplicity",len(binning)-1,array('d',binning)) m23_multiplicity = ROOT.TH1F("m23_multiplicity","m23_multiplicity",len(binning)-1,array('d',binning)) from files import * #events = Events(RelValZMM_13_CMSSW_7_4_1_MCRUN2_74_V9_gensim_740pre7_v1_PhilFixRecHitFlag[:1]) #prefix="RelValZMM_13_CMSSW_7_4_1-MCRUN2_74_V9_gensim_740pre7-v1_PhilFixRecHitFlag" #events = Events(RelValZMM_13_CMSSW_7_4_1_PU25ns_MCRUN2_74_V9_gensim_740pre7_v1_PhilFixRecHitFlag) #prefix="RelValZMM_13_CMSSW_7_4_1_PU25ns_MCRUN2_74_V9_gensim_740pre7_v1_PhilFixRecHitFlag" events = Events(RelValZMM_13_CMSSW_7_4_1_PU50ns_MCRUN2_74_V8_gensim_740pre7_v1_PhilFixRecHitFlag) prefix="RelValZMM_13_CMSSW_7_4_1_PU50ns_MCRUN2_74_V8_gensim_740pre7_v1_PhilFixRecHitFlag" nevents = 10 if small else events.size() for i in range(nevents): events.to(i) if i%10==0:print "At event %i/%i"%(i,nevents) # eaux=events.eventAuxiliary() # run=eaux.run() # event=eaux.event() # lumi=eaux.luminosityBlock() pfClusters = getProd('pfClusters') caloRecHits = getProd('caloRecHits') for i_c, c in enumerate(pfClusters): hitsAndFractions = c.hitsAndFractions() recHitMultiplicity = len(hitsAndFractions) if verbose:print "\nCluster",i_c,"energy",c.energy(),"recHitMultiplicity",recHitMultiplicity clusterE=0. energies=[0.,0.,0.] multiplicities=[0.,0.,0.]
import ROOT from DataFormats.FWLite import Events, Handle from PhysicsTools.PythonAnalysis import * events_new = Events(['step3_newCalib.root']) events_old = Events(['step3_RAW2DIGI_RECO.root']) edmCollections = [{ 'name': 'pfMet', 'label': ("pfMet"), 'edmType': "vector<reco::PFMET>" }] handles = {v['name']: Handle(v['edmType']) for v in edmCollections} for i in range(10): events_new.to(i) products_new = {} for v in edmCollections: events_new.getByLabel(v['label'], handles[v['name']]) products_new[v['name']] = handles[v['name']].product() events_old.to(i) products_old = {} for v in edmCollections: events_old.getByLabel(v['label'], handles[v['name']]) products_old[v['name']] = handles[v['name']].product() print "new", products_new['pfMet'][0].pt( ), 'old', products_old['pfMet'][0].pt()