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):
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()
