| 2 |
|
import sys |
| 3 |
|
import os |
| 4 |
|
import ROOT |
| 5 |
– |
from ROOT import TFile |
| 5 |
|
from array import array |
| 6 |
|
from math import sqrt |
| 7 |
|
from copy import copy |
| 10 |
|
warnings.filterwarnings( action='ignore', category=RuntimeWarning, message='creating converter.*' ) |
| 11 |
|
from optparse import OptionParser |
| 12 |
|
from BetterConfigParser import BetterConfigParser |
| 14 |
– |
from samplesclass import sample |
| 15 |
– |
from mvainfos import mvainfo |
| 13 |
|
import pickle |
| 17 |
– |
from progbar import progbar |
| 18 |
– |
from printcolor import printc |
| 14 |
|
|
| 15 |
|
#CONFIGURE |
| 16 |
< |
|
| 16 |
> |
ROOT.gROOT.SetBatch(True) |
| 17 |
> |
print 'hello' |
| 18 |
|
#load config |
| 19 |
|
#os.mkdir(path+'/sys') |
| 20 |
|
argv = sys.argv |
| 23 |
|
help="update infofile") |
| 24 |
|
parser.add_option("-D", "--discr", dest="discr", default="", |
| 25 |
|
help="discriminators to be added") |
| 26 |
< |
parser.add_option("-P", "--path", dest="path", default="", |
| 27 |
< |
help="path to samples") |
| 26 |
> |
#parser.add_option("-I", "--inpath", dest="inpath", default="", |
| 27 |
> |
# help="path to samples") |
| 28 |
> |
#parser.add_option("-O", "--outpath", dest="outpath", default="", |
| 29 |
> |
# help="path where to store output samples") |
| 30 |
|
parser.add_option("-S", "--samples", dest="names", default="", |
| 31 |
|
help="samples you want to run on") |
| 32 |
|
parser.add_option("-C", "--config", dest="config", default=[], action="append", |
| 33 |
|
help="configuration file") |
| 34 |
|
(opts, args) = parser.parse_args(argv) |
| 35 |
+ |
|
| 36 |
+ |
from samplesclass import sample |
| 37 |
+ |
from mvainfos import mvainfo |
| 38 |
+ |
from progbar import progbar |
| 39 |
+ |
from printcolor import printc |
| 40 |
+ |
|
| 41 |
|
if opts.config =="": |
| 42 |
|
opts.config = "config" |
| 43 |
|
config = BetterConfigParser() |
| 51 |
|
samplesinfo=config.get('Directories','samplesinfo') |
| 52 |
|
|
| 53 |
|
#systematics |
| 50 |
– |
systematics=config.get('systematics','systematics') |
| 51 |
– |
systematics=systematics.split(' ') |
| 54 |
|
|
| 53 |
– |
#TreeVar Array |
| 54 |
– |
#MVA_Vars={} |
| 55 |
– |
#for systematic in systematics: |
| 56 |
– |
# MVA_Vars[systematic]=config.get('treeVars',systematic) |
| 57 |
– |
# MVA_Vars[systematic]=MVA_Vars[systematic].split(' ') |
| 55 |
|
|
| 56 |
< |
###################### |
| 57 |
< |
#Evaluate multi: Must Have same treeVars!!! |
| 56 |
> |
INpath = config.get('Directories','MVAin') |
| 57 |
> |
OUTpath = config.get('Directories','MVAout') |
| 58 |
|
|
| 62 |
– |
Apath=opts.path |
| 59 |
|
infofile = open(samplesinfo,'r') |
| 60 |
|
info = pickle.load(infofile) |
| 61 |
|
infofile.close() |
| 67 |
|
doinfo=bool(int(opts.update)) |
| 68 |
|
|
| 69 |
|
MVAlist=arglist.split(',') |
| 70 |
< |
MVAdir=config.get('Directories','vhbbpath') |
| 70 |
> |
|
| 71 |
|
|
| 72 |
|
#CONFIG |
| 73 |
|
#factory |
| 74 |
|
factoryname=config.get('factory','factoryname') |
| 75 |
+ |
|
| 76 |
+ |
#load the namespace |
| 77 |
+ |
VHbbNameSpace=config.get('VHbbNameSpace','library') |
| 78 |
+ |
ROOT.gSystem.Load(VHbbNameSpace) |
| 79 |
+ |
|
| 80 |
|
#MVA |
| 80 |
– |
#MVAnames=[] |
| 81 |
– |
#for MVA in MVAlist: |
| 82 |
– |
# print MVA |
| 83 |
– |
# MVAnames.append(config.get(MVA,'MVAname')) |
| 84 |
– |
#print Wdir+'/weights/'+factoryname+'_'+MVAname+'.info' |
| 85 |
– |
#MVAinfofiles=[] |
| 81 |
|
MVAinfos=[] |
| 82 |
+ |
MVAdir=config.get('Directories','vhbbpath') |
| 83 |
|
for MVAname in MVAlist: |
| 84 |
|
MVAinfofile = open(MVAdir+'/data/'+factoryname+'_'+MVAname+'.info','r') |
| 85 |
|
MVAinfos.append(pickle.load(MVAinfofile)) |
| 86 |
|
MVAinfofile.close() |
| 87 |
|
|
| 92 |
– |
treeVarSet=MVAinfos[0].varset |
| 93 |
– |
#variables |
| 94 |
– |
#TreeVar Array |
| 95 |
– |
MVA_Vars={} |
| 96 |
– |
for systematic in systematics: |
| 97 |
– |
MVA_Vars[systematic]=config.get(treeVarSet,systematic) |
| 98 |
– |
MVA_Vars[systematic]=MVA_Vars[systematic].split(' ') |
| 99 |
– |
#Spectators: |
| 100 |
– |
#spectators=config.get(treeVarSet,'spectators') |
| 101 |
– |
#spectators=spectators.split(' ') |
| 102 |
– |
#progbar quatsch |
| 88 |
|
longe=40 |
| 89 |
|
#Workdir |
| 90 |
|
workdir=ROOT.gDirectory.GetPath() |
| 106 |
– |
#os.mkdir(Apath+'/MVAout') |
| 91 |
|
|
| 108 |
– |
#Book TMVA readers: MVAlist=["MMCC_bla","CC5050_bla"] |
| 109 |
– |
readers=[] |
| 110 |
– |
for MVA in MVAlist: |
| 111 |
– |
readers.append(ROOT.TMVA.Reader("!Color:!Silent")) |
| 112 |
– |
|
| 113 |
– |
#define variables and specatators |
| 114 |
– |
MVA_var_buffer = [] |
| 115 |
– |
MVA_var_buffer4 = [] |
| 116 |
– |
for i in range(len( MVA_Vars['Nominal'])): |
| 117 |
– |
MVA_var_buffer.append(array( 'f', [ 0 ] )) |
| 118 |
– |
for reader in readers: |
| 119 |
– |
reader.AddVariable( MVA_Vars['Nominal'][i],MVA_var_buffer[i]) |
| 120 |
– |
#MVA_spectator_buffer = [] |
| 121 |
– |
#for i in range(len(spectators)): |
| 122 |
– |
# MVA_spectator_buffer.append(array( 'f', [ 0 ] )) |
| 123 |
– |
# for reader in readers: |
| 124 |
– |
# reader.AddSpectator(spectators[i],MVA_spectator_buffer[i]) |
| 125 |
– |
#Load raeder |
| 126 |
– |
for i in range(0,len(readers)): |
| 127 |
– |
readers[i].BookMVA(MVAinfos[i].MVAname,MVAdir+'/data/'+MVAinfos[i].getweightfile()) |
| 128 |
– |
#--> Now the MVA is booked |
| 92 |
|
|
| 93 |
|
#Apply samples |
| 94 |
|
infofile = open(samplesinfo,'r') |
| 95 |
|
Ainfo = pickle.load(infofile) |
| 96 |
|
infofile.close() |
| 97 |
|
|
| 98 |
+ |
|
| 99 |
+ |
class MvaEvaluater: |
| 100 |
+ |
def __init__(self, config, MVAinfo): |
| 101 |
+ |
self.varset = MVAinfo.varset |
| 102 |
+ |
#Define reader |
| 103 |
+ |
self.reader = ROOT.TMVA.Reader("!Color:!Silent") |
| 104 |
+ |
MVAdir=config.get('Directories','vhbbpath') |
| 105 |
+ |
self.systematics=config.get('systematics','systematics').split(' ') |
| 106 |
+ |
self.MVA_Vars={} |
| 107 |
+ |
self.MVAname = MVAinfo.MVAname |
| 108 |
+ |
for systematic in self.systematics: |
| 109 |
+ |
self.MVA_Vars[systematic]=config.get(self.varset,systematic) |
| 110 |
+ |
self.MVA_Vars[systematic]=self.MVA_Vars[systematic].split(' ') |
| 111 |
+ |
#define variables and specatators |
| 112 |
+ |
self.MVA_var_buffer = [] |
| 113 |
+ |
for i in range(len( self.MVA_Vars['Nominal'])): |
| 114 |
+ |
self.MVA_var_buffer.append(array( 'f', [ 0 ] )) |
| 115 |
+ |
self.reader.AddVariable( self.MVA_Vars['Nominal'][i],self.MVA_var_buffer[i]) |
| 116 |
+ |
self.reader.BookMVA(MVAinfo.MVAname,MVAdir+'/data/'+MVAinfo.getweightfile()) |
| 117 |
+ |
#--> Now the MVA is booked |
| 118 |
+ |
|
| 119 |
+ |
def setBranches(self,tree,job): |
| 120 |
+ |
#Set formulas for all vars |
| 121 |
+ |
self.MVA_formulas={} |
| 122 |
+ |
for systematic in self.systematics: |
| 123 |
+ |
if job.type == 'DATA' and not systematic == 'Nominal': continue |
| 124 |
+ |
self.MVA_formulas[systematic]=[] |
| 125 |
+ |
for j in range(len( self.MVA_Vars['Nominal'])): |
| 126 |
+ |
self.MVA_formulas[systematic].append(ROOT.TTreeFormula("MVA_formula%s_%s"%(j,systematic),self.MVA_Vars[systematic][j],tree)) |
| 127 |
+ |
|
| 128 |
+ |
def evaluate(self,MVAbranches,job): |
| 129 |
+ |
#Evaluate all vars and fill the branches |
| 130 |
+ |
for systematic in self.systematics: |
| 131 |
+ |
for j in range(len( self.MVA_Vars['Nominal'])): |
| 132 |
+ |
if job.type == 'DATA' and not systematic == 'Nominal': continue |
| 133 |
+ |
self.MVA_var_buffer[j][0] = self.MVA_formulas[systematic][j].EvalInstance() |
| 134 |
+ |
MVAbranches[self.systematics.index(systematic)] = self.reader.EvaluateMVA(self.MVAname) |
| 135 |
+ |
|
| 136 |
+ |
|
| 137 |
+ |
theMVAs = [] |
| 138 |
+ |
for mva in MVAinfos: |
| 139 |
+ |
theMVAs.append(MvaEvaluater(config,mva)) |
| 140 |
+ |
|
| 141 |
+ |
|
| 142 |
|
#eval |
| 143 |
|
for job in Ainfo: |
| 144 |
|
if eval(job.active): |
| 145 |
|
if job.name in namelist: |
| 146 |
|
#get trees: |
| 147 |
< |
input = TFile.Open(Apath+'/'+job.getpath(),'read') |
| 148 |
< |
outfile = TFile.Open(Apath+'/'+MVASubdir+job.prefix+job.identifier+'.root','recreate') |
| 147 |
> |
print INpath+'/'+job.prefix+job.identifier+'.root' |
| 148 |
> |
input = ROOT.TFile.Open(INpath+'/'+job.prefix+job.identifier+'.root','read') |
| 149 |
> |
print OUTpath+'/'+job.prefix+job.identifier+'.root' |
| 150 |
> |
outfile = ROOT.TFile.Open(OUTpath+'/'+job.prefix+job.identifier+'.root','recreate') |
| 151 |
|
input.cd() |
| 152 |
|
obj = ROOT.TObject |
| 153 |
|
for key in ROOT.gDirectory.GetListOfKeys(): |
| 163 |
|
nEntries = tree.GetEntries() |
| 164 |
|
outfile.cd() |
| 165 |
|
newtree = tree.CloneTree(0) |
| 166 |
+ |
|
| 167 |
|
|
| 168 |
< |
#MCs: |
| 169 |
< |
if job.type != 'DATA': |
| 170 |
< |
MVA_formulas={} |
| 171 |
< |
MVA_formulas4={} |
| 172 |
< |
for systematic in systematics: |
| 173 |
< |
#print '\t\t - ' + systematic |
| 174 |
< |
MVA_formulas[systematic]=[] |
| 175 |
< |
MVA_formulas4[systematic]=[] |
| 166 |
< |
#create TTreeFormulas |
| 167 |
< |
for j in range(len( MVA_Vars['Nominal'])): |
| 168 |
< |
MVA_formulas[systematic].append(ROOT.TTreeFormula("MVA_formula%s_%s"%(j,systematic),MVA_Vars[systematic][j],tree)) |
| 169 |
< |
MVA_formulas4[systematic].append(ROOT.TTreeFormula("MVA_formula4%s_%s"%(j,systematic),MVA_Vars['Nominal'][j]+'+('+MVA_Vars[systematic][j]+'-'+MVA_Vars['Nominal'][j]+')*4',tree))#HERE change |
| 170 |
< |
outfile.cd() |
| 171 |
< |
#Setup Branches |
| 172 |
< |
MVAbranches=[] |
| 173 |
< |
MVAbranches4=[] |
| 174 |
< |
for i in range(0,len(readers)): |
| 175 |
< |
MVAbranches.append(array('f',[0]*11)) |
| 176 |
< |
MVAbranches4.append(array('f',[0]*11)) |
| 177 |
< |
newtree.Branch(MVAinfos[i].MVAname,MVAbranches[i],'nominal:JER_up:JER_down:JES_up:JES_down:beff_up:beff_down:bmis_up:bmis_down:beff1_up:beff1_down/F') |
| 178 |
< |
newtree.Branch(MVAinfos[i].MVAname+'_4',MVAbranches4[i],'nominal:JER_up:JER_down:JES_up:JES_down:beff_up:beff_down:bmis_up:bmis_down:beff1_up:beff1_down/F') |
| 179 |
< |
print '\n--> ' + job.name +':' |
| 180 |
< |
#progbar setup |
| 181 |
< |
if nEntries >= longe: |
| 182 |
< |
step=int(nEntries/longe) |
| 183 |
< |
long=longe |
| 184 |
< |
else: |
| 185 |
< |
long=nEntries |
| 186 |
< |
step = 1 |
| 187 |
< |
bar=progbar(long) |
| 188 |
< |
#Fill event by event: |
| 189 |
< |
for entry in range(0,nEntries): |
| 190 |
< |
if entry % step == 0: |
| 191 |
< |
bar.move() |
| 192 |
< |
#load entry |
| 193 |
< |
tree.GetEntry(entry) |
| 194 |
< |
for systematic in systematics: |
| 195 |
< |
for j in range(len( MVA_Vars['Nominal'])): |
| 196 |
< |
MVA_var_buffer[j][0] = MVA_formulas[systematic][j].EvalInstance() |
| 197 |
< |
|
| 198 |
< |
for j in range(0,len(readers)): |
| 199 |
< |
MVAbranches[j][systematics.index(systematic)] = readers[j].EvaluateMVA(MVAinfos[j].MVAname) |
| 200 |
< |
|
| 201 |
< |
for j in range(len( MVA_Vars['Nominal'])): |
| 202 |
< |
MVA_var_buffer[j][0] = MVA_formulas4[systematic][j].EvalInstance() |
| 203 |
< |
|
| 204 |
< |
for j in range(0,len(readers)): |
| 205 |
< |
MVAbranches4[j][systematics.index(systematic)] = readers[j].EvaluateMVA(MVAinfos[j].MVAname) |
| 206 |
< |
#Fill: |
| 207 |
< |
newtree.Fill() |
| 208 |
< |
newtree.AutoSave() |
| 209 |
< |
outfile.Close() |
| 210 |
< |
|
| 211 |
< |
#DATA: |
| 212 |
< |
if job.type == 'DATA': |
| 213 |
< |
#MVA Formulas |
| 214 |
< |
MVA_formulas_Nominal = [] |
| 215 |
< |
#create TTreeFormulas |
| 216 |
< |
for j in range(len( MVA_Vars['Nominal'])): |
| 217 |
< |
MVA_formulas_Nominal.append(ROOT.TTreeFormula("MVA_formula%s_Nominal"%j, MVA_Vars['Nominal'][j],tree)) |
| 218 |
< |
outfile.cd() |
| 219 |
< |
MVAbranches=[] |
| 220 |
< |
for i in range(0,len(readers)): |
| 168 |
> |
#Set branch adress for all vars |
| 169 |
> |
for i in range(0,len(theMVAs)): |
| 170 |
> |
theMVAs[i].setBranches(tree,job) |
| 171 |
> |
outfile.cd() |
| 172 |
> |
#Setup Branches |
| 173 |
> |
MVAbranches=[] |
| 174 |
> |
for i in range(0,len(theMVAs)): |
| 175 |
> |
if job.type == 'Data': |
| 176 |
|
MVAbranches.append(array('f',[0])) |
| 177 |
|
newtree.Branch(MVAinfos[i].MVAname,MVAbranches[i],'nominal/F') |
| 223 |
– |
newtree.Branch(MVAinfos[i].MVAname+'_4',MVAbranches[i],'nominal/F') |
| 224 |
– |
#progbar |
| 225 |
– |
print '\n--> ' + job.name +':' |
| 226 |
– |
if nEntries >= longe: |
| 227 |
– |
step=int(nEntries/longe) |
| 228 |
– |
long=longe |
| 178 |
|
else: |
| 179 |
< |
long=nEntries |
| 180 |
< |
step = 1 |
| 181 |
< |
bar=progbar(long) |
| 182 |
< |
#Fill event by event: |
| 183 |
< |
for entry in range(0,nEntries): |
| 184 |
< |
if entry % step == 0: |
| 185 |
< |
bar.move() |
| 186 |
< |
#load entry |
| 187 |
< |
tree.GetEntry(entry) |
| 188 |
< |
#nominal: |
| 189 |
< |
for j in range(len( MVA_Vars['Nominal'])): |
| 190 |
< |
MVA_var_buffer[j][0] = MVA_formulas_Nominal[j].EvalInstance() |
| 179 |
> |
MVAbranches.append(array('f',[0]*11)) |
| 180 |
> |
newtree.Branch(theMVAs[i].MVAname,MVAbranches[i],'nominal:JER_up:JER_down:JES_up:JES_down:beff_up:beff_down:bmis_up:bmis_down:beff1_up:beff1_down/F') |
| 181 |
> |
MVA_formulas_Nominal = [] |
| 182 |
> |
print '\n--> ' + job.name +':' |
| 183 |
> |
#progbar setup |
| 184 |
> |
if nEntries >= longe: |
| 185 |
> |
step=int(nEntries/longe) |
| 186 |
> |
long=longe |
| 187 |
> |
else: |
| 188 |
> |
long=nEntries |
| 189 |
> |
step = 1 |
| 190 |
> |
bar=progbar(long) |
| 191 |
> |
#Fill event by event: |
| 192 |
> |
for entry in range(0,nEntries): |
| 193 |
> |
if entry % step == 0: |
| 194 |
> |
bar.move() |
| 195 |
> |
#load entry |
| 196 |
> |
tree.GetEntry(entry) |
| 197 |
|
|
| 198 |
< |
for j in range(0,len(readers)): |
| 199 |
< |
MVAbranches[j][0]= readers[j].EvaluateMVA(MVAinfos[j].MVAname) |
| 200 |
< |
newtree.Fill() |
| 201 |
< |
newtree.AutoSave() |
| 202 |
< |
outfile.Close() |
| 203 |
< |
|
| 198 |
> |
for i in range(0,len(theMVAs)): |
| 199 |
> |
theMVAs[i].evaluate(MVAbranches[i],job) |
| 200 |
> |
#Fill: |
| 201 |
> |
newtree.Fill() |
| 202 |
> |
newtree.AutoSave() |
| 203 |
> |
outfile.Close() |
| 204 |
> |
|
| 205 |
|
print '\n' |
| 206 |
|
|
| 207 |
|
#Update Info: |
