def SaveGraph_2D(FileName, outputFile): myfile = TFile( FileName ) print "\nnow loading [%s]" % FileName ######################################### # -- check the scenario (data or MC) -- # ######################################### Scenario = "" GraphName_Base = "" if "data_25ns" in FileName: Scenario = "Data" GraphName_Base = Scenario + "_" + FileName.split("_data_25ns_")[1:][0].split(".root")[:1][0] elif "mc" in FileName: Scenario = "MC" GraphName_Base = Scenario + "_" + FileName.split("_mc_")[1:][0].split(".root")[:1][0] TreeName = "muonEffs" ######################### # -- sub-directory 1 -- # ######################### Path1 = "%s" % TreeName Dir1 = myfile.GetDirectory( Path1 ) print "now in %s" % Path1 if Dir1.GetListOfKeys().GetEntries() > 2: print "More than 2 directories under %s" % Path1 sys.exit() ######################### # -- sub-directory 2 -- # ######################### Path2 = "%s/%s/fit_eff_plots" % ( TreeName, Dir1.GetListOfKeys().At(0).GetName() ) Dir2 = myfile.GetDirectory( Path2 ) print "now in %s" % Path2 i_absetabin = 0 List_Graphs = [] for key in Dir2.GetListOfKeys(): if "pt_PLOT_eta_bin" in key.GetName(): # print key.GetName() canvas = key.ReadObj() graph = canvas.GetPrimitive("hxy_fit_eff").Clone() name_before = canvas.GetName() name_after = GraphName_Base + "_abseta%s" % (i_absetabin) graph.SetName( name_after ) i_absetabin += 1 print "\tgraph: %s -> %s" % (name_before, name_after) List_Graphs += [graph] outputFile.cd() for graph in List_Graphs: graph.Write() myfile.Close()
def plotHists(root_filename, topology): print(">>> Plotting Hists") try: test_file = open(root_filename, "r") except: raise Exception("Error opening .root file. TERMINATING.") root_file = TFile(root_filename, "READ") for slot_num in range(topology[0]): Slot = root_file.GetDirectory("Slot" + str(slot_num)) #print(Slot) if Slot == None: pass else: print("Slot: ", slot_num) for channel_num in range(topology[1]): print("amp_shape" + str(slot_num) + "_" + str(channel_num)) plot = False try: hist = (TH2F)( root_file.GetDirectory("Slot" + str(slot_num)). GetDirectory("Channel" + str(channel_num)).Get("amp_shape" + str(slot_num) + "_" + str(channel_num))) plot = True except: pass if plot: x_bins = hist.GetNbinsX() y_bins = hist.GetNbinsY() #print("xbins: ", x_bins) #print("ybins: ", y_bins) x = [] y = [] for i in range(x_bins): for j in range(y_bins): if hist.GetBinContent(i, j) > 0: print("Contents bin x: ", i, " y: ", j, " - ", hist.GetBinContent(i, j)) for k in range(int(hist.GetBinContent(i, j))): x.append(i) y.append(j) if x_bins > 0 and y_bins > 0: plt.hist2d(x, y, bins=[x_bins, y_bins], range=[[0, 200], [0.9, 1]]) plt.show() del hist #input(">>> ") root_file.Close()
def PrintFitCanvases(FileName): myfile = TFile( FileName ) print "\nnow loading [%s]" % FileName ######################################### # -- check the scenario (data or MC) -- # ######################################### Scenario = "" DirName = "" if "data_25ns" in FileName: Scenario = "Data" DirName = Scenario + "_" + FileName.split("_data_25ns_")[1:][0].split(".root")[:1][0] elif "mc" in FileName: Scenario = "MC" DirName = Scenario + "_" + FileName.split("_mc_")[1:][0].split(".root")[:1][0] if DirName not in os.listdir("./"): os.mkdir( DirName ) TreeName = "muonEffs" ######################### # -- sub-directory 1 -- # ######################### Path1 = "%s" % TreeName Dir1 = myfile.GetDirectory( Path1 ); print "now in %s" % Path1 if Dir1.GetListOfKeys().GetEntries() > 2: print "More than 2 directories under %s" % Path1 sys.exit() ######################### # -- sub-directory 2 -- # ######################### Path2 = "%s/%s" % ( TreeName, Dir1.GetListOfKeys().At(0).GetName() ) Dir2 = myfile.GetDirectory( Path2 ) print "now in %s" % Path2 for key in Dir2.GetListOfKeys(): FolderName = key.GetName() if "_eff" not in FolderName: Path3 = Path2 + "/%s" % key.GetName() Dir3 = myfile.GetDirectory( Path3 ) for key2 in Dir3.GetListOfKeys(): if( key2.GetName() == "fit_canvas" ): canvas = key2.ReadObj() canvas.SaveAs( "./%s/%s.pdf" % (DirName, FolderName ) ) myfile.Close()
def setUp(self): """Create dictionaries needed by combiners.""" dirname = os.path.join(os.path.dirname(__file__), 'fixtures') orfdata = TFile( os.path.abspath(os.path.join(dirname, 'dqm_data.root')), 'read') orfref = TFile(os.path.abspath(os.path.join(dirname, 'dqm_ref.root')), 'read') # valid ROOT files assert (not orfdata.IsZombie()) assert (not orfref.IsZombie()) self.tdir = tempfile.mkdtemp() self.rfdata = TFile(os.path.join(self.tdir, 'fdata.root'), 'recreate') self.rfref = TFile(os.path.join(self.tdir, 'fref.root'), 'recreate') hist_recipes = [ (get_avg_trend, 'Vetra/NoiseMon/ADCCMSuppressed', ('RMSNoise_vs_ChipChannel', 'AvgRMSNoise_trend')), (get_avg_hist, 'Vetra/NoiseMon/ADCCMSuppressed', ('RMSNoise_vs_ChipChannel', 'AvgRMSNoise_all')), (get_avg_hist, 'Vetra/NoiseMon/ADCCMSuppressed', ('RMSNoise_vs_ChipChannel', 'AvgRMSNoise_R', 'r')), (get_avg_hist, 'Vetra/NoiseMon/ADCCMSuppressed', ('RMSNoise_vs_ChipChannel', 'AvgRMSNoise_Phi', 'p')), # (get_avg_hist, 'Vetra/VeloPedestalSubtractorMoni', # ('Ped_Sub_ADCs_Profile', 'Ped_Sub_ADCs_all')) ] # histograms: make, save, and cleanup for recipe in hist_recipes: href = recipe[0](orfref.GetDirectory(recipe[1]), *recipe[2]) self.rfref.WriteTObject(href) del href hdata = recipe[0](orfdata.GetDirectory(recipe[1]), *recipe[2]) self.rfdata.WriteTObject(hdata) del hdata self.rfref.Close() self.rfdata.Close() # Write DQ database to temp directory (rather than run directory) Config().dq_db_file_path = os.path.join(self.tdir, Config().dq_db) configfile = os.path.join(os.path.dirname(__file__), 'analysis_config_test.py') with open(configfile, 'r') as inputFile: exec(inputFile.read()) config = AnalysisConfigWrapper( (analysis_config_branches, analysis_config_leaves)) self.mycombiner = config.getTrunk(orfdata.GetName(), orfref.GetName()) # Results to compare against self.results = {"score": Score(70.62594356001006), "lvl": ERROR}
def make_fractions_single(output_dir, channel, variable, components_dict, category='inclusive', systematic='nominal'): '''This funciton aims at producing a root file containing all histograms needed for datacards. To do so, provide a dict of components (class Component) that have the ROOT histograms to be used. Gives also the output directory and the variable name, so that you can make datacards for different variables.''' rootfilename = '_'.join(['htt', channel, 'for_FF_fractions']) rootfile = TFile('{}/{}.root'.format(output_dir, rootfilename), 'UPDATE') rootdirname = '_'.join([channels_names[channel], variable, category]) rootdir = rootfile.GetDirectory(rootdirname) if not rootdir: rootdir = TDirectoryFile(rootdirname, rootdirname) rootdir.cd() for key, component in components_dict.iteritems(): histname = '_'.join([key, systematic]) if systematic == 'nominal': histname = key else: histname = histname.replace('up', 'Up') histname = histname.replace('down', 'Down') if rootdir.Get(histname): continue hist = component.histogram.Clone(histname) if histname[:len("fakes_")] == "fakes_": hist.Scale(-1) hist.SetTitle(key) hist.Write() rootfile.Close()
def rewtOneHist(dataset, hwts): fileName = condor_dir + "/" + dataset + ".root" if not os.path.exists(fileName): print "WARNING: didn't find ", fileName return print "About to reweight histogram in " + fileName inFile = TFile(fileName, "UPDATE") if inFile.IsZombie() or not inFile.GetNkeys(): return inFile.cd() h = inFile.Get(str(arguments.histToBeReWeighted)).Clone() if not h: print " Could not find hist named " + arguments.histToBeReWeighted + " in " + inFile.GetName( ) return h.SetDirectory(0) newName = h.GetName() + str(arguments.suffixRename) h.SetName(newName) dir = arguments.histToBeReWeighted dir = dir[:dir.rfind("/")] print "Will write hist to directory " + dir inFile.cd(dir) tdir = inFile.GetDirectory(dir) tdir.Delete(newName + ";*") for i in range(1, h.GetNbinsX() + 1): val = h.GetBinContent(i) err = h.GetBinError(i) binCtr = h.GetBinCenter(i) wt = hwts.GetBinContent(hwts.FindBin(binCtr)) h.SetBinContent(i, val * wt) h.SetBinError(i, err * wt) h.Write() inFile.Close()
def addBranchToDirectory(): print ">>> Add branch to directory." file = TFile("tree.root", 'update') # make directory if it does not exist dir = file.GetDirectory("dir1") if not dir: print ">>> created dir1" dir = file.mkdir("dir1") # make this directory the current one: everything you write will be saved here dir.cd() # make new tree with a branch tree = TTree("tree2", "tree2") n = array('d', [0]) #n = numpy.zeros(1, dtype=float) tree.Branch("normal5", n, 'normal5/D') # fill tree for i in xrange(10000): n[0] = gRandom.Gaus(3, 2) tree.Fill() file.Write("", TFile.kOverwrite) file.Close()
def save(self, s_graphs): """ Save TGraph in TFile and as *.pdf. """ graphs = self._get_graphs(s_graphs) # Open TFile rootfile = TFile(self.s_rootfile, 'UPDATE') # Go into directory if it is defined if self.directory: cwd = getcwd() # Change directory in rootfile if not rootfile.GetDirectory(self.directory): rootfile.mkdir(self.directory) rootfile.cd(self.directory) # Change directory on filesystem if not path.exists(self.directory): makedirs(self.directory) chdir(self.directory) self._canvas.SaveAs('{0}.pdf'.format(self.name)) for graph in graphs: graph.Write() # Go back to original working directories if self.directory: rootfile.cd() chdir(cwd) # Close TFile rootfile.Close() self._clear()
def add_points(graph, directory, layer, usePU): ipt = graph.GetN() # List runs for root, directories, files in os.walk(directory): for rundir in sorted(directories): if "run_" in rundir: # start to process run run = rundir[4:] #print "processing run ", run lumi = 0 lumi_err = 0 # Get informations for a given run frun = TFile(directory + "/" + rundir + "/withMasking/rootfile/SiStripHitEffHistos_run" + run + ".root") fdir = frun.GetDirectory("SiStripHitEff") # for efficiency hfound = fdir.Get("found") htotal = fdir.Get("all") if htotal == None: print ' Missing histogram in file ' + frun.GetName() continue # lumi if usePU == 0: hlumi = fdir.Get("instLumi") else: hlumi = fdir.Get("PU") if hlumi == None: print ' Missing lumi/pu histogram in file ' + frun.GetName( ) continue lumi = hlumi.GetMean() lumi_err = hlumi.GetRMS() #print "lumi (avg+/-rms): ", lumi, "+/-", lumi_err # efficiency for a given layer found = hfound.GetBinContent(layer) total = htotal.GetBinContent(layer) if total > 0: eff = found / total else: eff = 0 #print run, eff, lumi, lumi_err # remove run without lumi informations if lumi > 1: eff_vs_lumi.SetPoint(ipt, lumi, eff) low = TEfficiency.Bayesian(total, found, .683, 1, 1, False) up = TEfficiency.Bayesian(total, found, .683, 1, 1, True) if eff - low > 0.01: print 'large error bar for run', run, 'layer', layer, 'eff:', '{:.4f}'.format( eff), 'err:', '{:.4f}'.format(eff - low) #if lumi_err > lumi/3.: print 'wide lumi range for run', run, 'layer', layer, 'eff:', '{:.4f}'.format(eff), 'lumi/pu:', '{:.4f}'.format(lumi), 'rms:', '{:.4f}'.format(lumi_err) eff_vs_lumi.SetPointError(ipt, lumi_err, lumi_err, eff - low, up - eff) ipt += 1 frun.Close()
def compare(self, filename1, filename2, st_test): if not 'TFile' in globals(): from ROOT import TFile f1 = TFile(filename1) f2 = TFile(filename2) conn = sqlite3.connect(self.db_name) c = conn.cursor() ## Create Directory and HistogramComparison structure in the DB dir_DQMData = f1.GetDirectory("DQMData") dir_Run = None for elem in dir_DQMData.GetListOfKeys(): elem_name = elem.GetName() if elem_name.startswith('Run '): dir_Run = dir_DQMData.Get(elem_name) fid, tid, dir_id = self.walk_through(c, dir_Run, f1, f2, st_test) c.execute('''DELETE FROM Directory WHERE from_histogram_id IS NULL AND till_histogram_id IS NULL''') c.execute('''INSERT INTO RootFileComparison(filename1, filename2, directory_id) VALUES (?, ?, ?)''', (basename(filename1), basename(filename2), dir_id)) root_file_comparison_id = c.lastrowid conn.commit() conn.close() f1.Close() f2.Close() return root_file_comparison_id
def get_content(root_file_name): """Returns all file (histogram) names, which are found in <root_file_name>.""" from ROOT import TFile root_file = TFile(root_file_name) root_directory = root_file.GetDirectory("DQMData") filename_set = set() collect_directory_filenames(root_directory, filename_set) root_file.Close() return filename_set
def skimTree(sample, filename): # Unweighted input inName = origin + '/' + sample + '/' + filename if not os.path.exists(inName): print '- WARNING: file', inName, 'does not exist, continuing' return True # Weighted output if not os.path.exists(target + '/' + sample): os.mkdir(target + '/' + sample) outName = target + '/' + sample + '/' + filename if os.path.exists(outName): print '- WARNING: weighted file exists, overwriting' #return True outFile = TFile(outName, 'RECREATE') outFile.cd() # Open old file inFile = TFile(inName, 'READ') # Looping over file content for key in inFile.GetListOfKeys(): obj = key.ReadObj() # Histograms if obj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', obj.GetName() outFile.cd() obj.Write() # Tree elif obj.IsA().InheritsFrom('TTree'): newTree = obj.CopyTree(skimString if obj.GetName() == "Events" else "") outFile.cd() newTree.Write(obj.GetName(), TObject.kOverwrite) if verbose: print ' + TTree:', obj.GetName() # Directories elif obj.IsFolder(): subdir = obj.GetName() if verbose: print ' \ Directory', subdir, ':' outFile.mkdir(subdir) outFile.cd(subdir) for subkey in inFile.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', subobj.GetName() outFile.cd(subdir) subobj.Write() outFile.cd('..') outFile.Close()
def saveHist(hist, channel, directory='', addStat=False): # Blind # if BLIND and 'data_obs' in hist and 'SR' in channel: # rando = TRandom3() # hist['data_obs'].Reset() # hist['data_obs'].SetMarkerStyle(21) # for i in range(hist['data_obs'].GetNbinsX()): #this wiggles the pseudodata with a Poison #-> different from Asimov dataset (-t -1 option), will give different obs/expected limits but thats ok # hist['data_obs'].SetBinContent(i+1, rando.Poisson( hist['BkgSum'].GetBinContent(i+1) )) # hist['data_obs'].SetBinContent(i+1, hist['BkgSum'].GetBinContent(i+1) ) # Sanity check # smax = max(hist, key=lambda x: hist[x].Integral()) # for s in hist.keys(): # for i in range(hist[s].GetNbinsX()): # if not hist[s].GetBinContent(i+1)>0.: hist[s].SetBinContent(i+1, 1.e-4) # Sanity check # if math.isnan(hist[s].GetBinContent(i+1)) or math.isinf(hist[s].GetBinContent(i+1)): print "WARNING: in channel", channel, "bkg", s, "bin", i+1, "is nan or inf" # #print "checking", s, i, hist[s].GetBinContent(i+1) outFile = TFile("rootfiles_"+options.name+"/"+channel+".root", "RECREATE" if len(directory)==0 else "UPDATE") outFile.cd() if len(directory) > 0: if not outFile.GetDirectory(directory): outFile.mkdir(directory) outFile.cd(directory) for s in sorted(hist.keys()): hist[s].Write(hist[s].GetName().replace('Up', '').replace('Down', '')) #outFile.cd("..") # Statistical MC uncertainty if addStat: nbins = hist['data_obs'].GetNbinsX() #CMS_stat_Z0b_bin57 for s in sorted(hist.keys()): if 'data' in s: continue dirname = channel+"/Sys_"+s #if outFile.GetDirectory(dirname): outFile.rmdir(dirname) outFile.mkdir(dirname) outFile.cd(dirname) for k in range(1, nbins+1): sysname = "CMS_stat_%s_%s_bin%d" % (channel, s, k) histUp = hist[s].Clone(sysname+"Up") histUp.SetBinContent(k, histUp.GetBinContent(k) + histUp.GetBinError(k)) histUp.Write() histDown = hist[s].Clone(sysname+"Down") histDown.SetBinContent(k, max(histDown.GetBinContent(k) - histDown.GetBinError(k), 1.e-6)) histDown.Write() outFile.cd("..") outFile.Close() print "Histograms saved in file rootfiles_"+options.name+"/"+channel+".root"
def add_points(graph, directory, subdir, layer): ipt = graph.GetN() labels = [] # List runs for root, directories, files in os.walk(directory): for rundir in sorted(directories): if "run_" in rundir: # start to process run run = rundir[4:] #print "processing run ", run # for efficiency frun = TFile(directory + "/" + rundir + "/" + subdir + "/rootfile/SiStripHitEffHistos_run" + run + ".root") fdir = frun.GetDirectory("SiStripHitEff") hfound = fdir.Get("found") htotal = fdir.Get("all") if htotal == None: print ' Missing histogram in file ' + frun.GetName() continue # efficiency for a given layer found = hfound.GetBinContent(int(layer)) total = htotal.GetBinContent(int(layer)) if total > 0: eff = found / total else: eff = 0 #print run, eff graph.SetPoint(ipt, ipt + 1, eff) labels.append(run) low = TEfficiency.Bayesian(total, found, .683, 1, 1, False) up = TEfficiency.Bayesian(total, found, .683, 1, 1, True) #eff_vs_run.SetPointError(ipt, 0, 0, eff-low, up-eff) ipt += 1 frun.Close() axis = graph.GetXaxis() for i in range(graph.GetN()): axis.SetBinLabel(axis.FindBin(i + 1), labels[i]) #print i, axis.FindBin(i+1), labels[i] return labels
def scaleFiles(inFileName, lumi): """docstring for scaleQCD""" if os.path.exists(inFileName + '_Scaled.root'): os.remove(inFileName + '_Scaled.root') outfile = TFile(inFileName + '_Scaled.root', "RECREATE") else: outfile = TFile(inFileName + '_Scaled.root', "RECREATE") infile = TFile(inFileName + '.root', "READ") scale = lumi * scaleFactor(inFileName) listDir = [] for k in infile.GetListOfKeys(): name = k.GetName() listDir.append(name) for j in listDir: if not 'RUNATree' in j: outfile.mkdir(j) outfile.cd(j) dir = infile.GetDirectory(j) for q in dir.GetListOfKeys(): name = q.GetName() h = infile.Get(j + '/' + name) try: hOut = h.Clone() #hOut.Scale( scale ) if not isinstance(h, TTree): hOut.Scale(scale) hOut.Write() except AttributeError: pass outfile.cd('/') outfile.Write() outfile.Close() infile.Close()
def addHistToDirectory(): print ">>> Add histogram to directory." # reopen tree file file = TFile("tree.root", 'update') # make directory if it does not exist dir = file.GetDirectory("dir1") if not dir: print ">>> created dir1" dir = file.mkdir("dir1") # make this directory the current one: everything you write will be saved here dir.cd() # declare histogram hist = TH1D("normal4", "Hist in folder", 50, -1, 9) # write histogram for i in xrange(10000): hist.Fill(gRandom.Gaus(4, 3)) file.Write("", TFile.kOverwrite) file.Close()
class make_monitoring_plots: def __init__(self): self.CANVAS_WIDTH = 1200 self.CANVAS_HEIGHT = 800 self.VERBOSE = 1 # initialize lists used to store data self.histlist_filename = None self.macrolist_filename = None self.hists_to_plot = [] self.macros_to_run = [] # name of file that containes the histogram - should get rid of this? self.rootfile_name = None self.root_file = None # the actual ROOT file self.base_root_dir = "" self.output_directory = "." # the canvas we plot on self.c1 = TCanvas("c1","",self.CANVAS_WIDTH,self.CANVAS_HEIGHT) def __del__(self): del self.c1 del self.hists_to_plot del self.macros_to_run if self.root_file: self.root_file.Close() #del self.root_file ########################################################## ## Helper functions ########################################################## def plot_hist(self, h): #c1.Clear() h.SetStats(0) h.Draw() def plot_2dhist(self, h): # by request, plot certain histograms with a logarithmic Z scale LOGZ_HISTS = [ "cdc_raw_int_vs_n", "cdc_raw_t_vs_n", "cdc_ped_vs_n", "cdc_windata_ped_vs_n" ] if h.GetName() in LOGZ_HISTS: self.c1.SetLogz(1) h.SetStats(0) h.Draw("COLZ") def ClearPad(self, pad): #gROOT.SetStyle("Plain") # reset style self.c1.Clear() self.c1.SetLogx(0) self.c1.SetLogy(0) self.c1.SetLogz(0) def print_canvas_png(self, fullpath): #print "Making plot = " + self.output_directory + "/" + fullpath.replace("/","_") + ".png" # tmp self.c1.Print( self.output_directory + "/" + fullpath.replace("/","_") + ".png" ) def SumHistContents(self, the_file, hist_path): h = the_file.Get(hist_path) if(h == None): logging.warn("Could not load " + hist_path) return -1 sum = 0 for bin in range(h.GetNbinsX()+1): sum += (bin-1)*h.GetBinContent(bin) return sum ########################################################## # These functions are still under development - they work but are slooooow # function to see if a histogram "in_hnamepath" matches the path definition given by "hnamepath_def" # we make the following assumptions for the path definiton: # - if the path does not begin with a '/', then we assume that this specifies a histogram name # - if the path does begin with a '/', the we assume that this specifies a full path # - we allow the "*" wildcard in the path definition # NOTE: apparently this is very slow, need to optimize def match_hnamepath(self, hnamepath_def, in_hnamepath): if len(hnamepath_def) == 0: return False if hnamepath_def[0] != '/': # match based on histogram name return hnamepath_def == in_hnamepath else: # translate '*' wildcard into regex language hnamepath_def.replace('*', '.*') result = re.match(hnamepath_def, in_hnamepath) if result is None: return False else: return True def match_hnamepaths(self, hnamepath_defs, in_hnamepath): for hnamepath_def in hnamepath_defs: if self.match_hnamepath(hnamepath_def, in_hnamepath): return True return False ############################################################ # parse file containing items, one on each line, and turn it into a list def ParseFile(self, filename): data = [] with open(filename) as f: for line in f: name = line.strip() if name == "": continue if name[0] == '#': continue data.append(name) return data def PlotHistsRecursive(self, the_dir, path, hists_to_plot): # loop over all keys in the current directory, ROOT-style key_iter = TIter(the_dir.GetListOfKeys()) key = key_iter() while( key ): obj = key.ReadObj() obj_pathname = path+"/"+key.GetName() # if the object is a histogram, then see if we should plot it if(isinstance(obj,TH1)): if self.VERBOSE>1: logging.info("matching hname = %s, hnamepath = %s" %(obj.GetName(),obj_pathname)) #if not match_hnamepaths(hists_to_sum, path+"/"+obj.GetName()): # match either histogram names or full path names if (obj.GetName() not in hists_to_plot) and (obj_pathname not in hists_to_plot): key = key_iter() continue # plot histogram if(isinstance(obj,TH2)): self.plot_2dhist(obj) else: self.plot_hist(obj) # save image to disk self.print_canvas_png("_"+obj_pathname) ## name hack for backward compatability #print_canvas_pdf() # if the object is a directory, access what's inside if(isinstance(obj, TDirectory)): self.PlotHistsRecursive(obj, obj_pathname, hists_to_plot) # END OF LOOP - move to next item in the directory key = key_iter() del key_iter def SavePlots(self, root_dir, dir_path, hists_to_plot, macros_to_run): # plot individual histograms if(len(hists_to_plot) > 0): # since we select histograms by their full path or just their name # we have to search through the directory tree, so the # plotting logic is inside this function self.PlotHistsRecursive(root_dir,dir_path,hists_to_plot) # plot RootSpy macros # the basic algorithm is for each macro, first build a clean slate, then execute the macro if(len(macros_to_run) > 0): for macro_file in macros_to_run: if os.path.isfile(macro_file): if self.VERBOSE>0: logging.info("running macro = " + macro_file) # run the macro inside CINT self.ClearPad(self.c1) root_dir.cd() try: # reset interpreter to handle a succession of unnamed scripts #gROOT.Reset() ## currently dealing with ROOT6 bug - sdobbs, Feb. 6, 2017 #gROOT.ProcessLine(".x " + macro_file) img_fname = macro_file.split('/')[-1] if img_fname[-2:] == ".C": img_fname = img_fname[0:-2] img_fname = self.output_directory + "/" + img_fname.replace("/","_") os.system("python run_single_root_command.py -F %s -O %s %s"%(self.rootfile_name,img_fname,macro_file)) except: logging.error("Error processing "+macro_file) # save the canvas - the name depends just on the file name img_fname = macro_file.split('/')[-1] #if img_fname[-2:] == ".C": # img_fname = img_fname[0:-2] #self.print_canvas_png(img_fname) else: logging.info("could not find macro = " + macro_file + " !") """ ### this was needed when we were adding together histograms, but I don't think that we need it anymore def extract_macro_hists(macro): if VERBOSE>1: logging.info("Extracting histograms needed for macros...") macro_hists = [] if not os.path.isfile(macro): # this file doesn't exist - should we say something here? return macro_hists # read through the file and extract the histograms tagged for RootSpy summing f = open(macro) for line in f: tokens = line.strip().split() #print str(tokens) # histograms are tagged as "// hnamepath: /path/to/a/hist" if (len(tokens) < 3): continue if ( (tokens[0] == "//") and (tokens[1] == "hnamepath:") ): hnamepath = " ".join(tokens[2:]) if VERBOSE>1: print hnamepath hname = hnamepath.split('/')[-1] if hname not in macro_hists: macro_hists.append(hname) return macro_hists """ def MakePlots(self): ## some sanity checks if self.rootfile_name is None: logging.critical("No ROOT file set!") return if self.histlist_filename is None and self.macrolist_filename is None: logging.critical("No files containing the histograms or macros to plot set!") return # decide which histograms/macros we should make plots of if self.histlist_filename: self.hists_to_plot = self.ParseFile(self.histlist_filename) else: self.hists_to_plot = [] if self.macrolist_filename: self.macros_to_run = self.ParseFile(self.macrolist_filename) else: self.macros_to_run = [] ## more sanity checks if len(self.hists_to_plot) == 0 and len(self.macros_to_run) == 0: logging.critical("No histograms or macro to save!") return # make the plots self.root_file = TFile(self.rootfile_name) # should handle bad files better? if(self.root_file is None): logging.critical("Could not open file: " + self.rootfile_name) return self.ClearPad(self.c1) self.c1.SetCanvasSize(self.CANVAS_WIDTH,self.CANVAS_HEIGHT) self.SavePlots(self.root_file.GetDirectory(self.base_root_dir), self.base_root_dir, self.hists_to_plot, self.macros_to_run)
def merge(files, target): hist = {} inFile = TFile(files[0][0], "READ") inFile.cd() for key in inFile.GetListOfKeys(): obj = key.ReadObj() # Copy and rescale histograms if obj.IsA().InheritsFrom("TH1"): hist[obj.GetName()] = weight(files, obj.GetName()) elif obj.IsA().InheritsFrom("TTree"): print "Skip tree", obj.GetName() # do nothing # Directories elif obj.IsFolder(): subdir = obj.GetName() print "In directory", subdir inFile.cd(subdir) for subkey in inFile.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom("TH1"): if 'Eff' in subdir: effh.append(subobj.GetName()) elif 'Gen' in subdir: gens.append(subobj.GetName()) elif not 'Counter' in subdir: plotHist([subobj]) inFile.cd("..") inFile.Close() print "Now plotting efficiency histograms", effh for j, h in enumerate(effh): name = h.split("_", 1)[0].replace( "Eff", "") #if not 'HEEP_E' in h else h.replace("Eff", "") num = TH1F() den = TH1F() files = {} for i, s in enumerate(sign): files[s] = TFile(NTUPLEDIR + sample[s]['files'][0] + ".root", "READ") files[s].cd() tnum = files[s].Get("Eff/" + h) tden = files[s].Get("Leptons/" + name) tnum.Multiply(tden) if i == 0: num = tnum.Clone("Numerator") den = tden.Clone("Denominator") else: num.Add(tnum) den.Add(tden) #files[s].Close() num.Divide(den) num.SetName(h) plotHist([num]) print "Now plotting gen signal histograms", effh for j, h in enumerate(gens): files = {} sigh = [] for i, s in enumerate(sigp): files[s] = TFile(NTUPLEDIR + sample[s]['files'][0] + ".root", "READ") files[s].cd() sigh.append(files[s].Get("Gen/" + h)) sigh[-1].SetTitle(s) plotHist(sigh)
def save_pyunfold_root_file(config, num_groups=4, outfile=None, formatted_df_file=None, res_mat_file=None, res_mat_err_file=None): paths = get_paths() unfolding_dir = os.path.join(paths.comp_data_dir, config, 'unfolding') # Bin Definitions binname = 'bin0' # ROOT Output if outfile is None: outfile = os.path.join( unfolding_dir, 'pyunfold_input_{}-groups.root'.format(num_groups)) check_output_dir(outfile) if os.path.exists(outfile): os.remove(outfile) fout = TFile(outfile, 'UPDATE') # Check if bin directory exists, quit if so, otherwise create it! if not fout.GetDirectory(binname): pdir = fout.mkdir(binname, 'Bin number 0') else: fout.Close() print('\n=========================\n') raise ValueError('Directory {} already exists!\nEither try another ' 'bin number or delete {} and start again. ' 'Exiting...\n'.format(binname, outfile)) # Go to home of ROOT file fout.cd(binname) if formatted_df_file is None: formatted_df_file = os.path.join( unfolding_dir, 'unfolding-df_{}-groups.hdf'.format(num_groups)) df_flux = pd.read_hdf(formatted_df_file) counts = df_flux['counts'].values if 'counts_err' in df_flux: counts_err = df_flux['counts_err'].values else: counts_err = None efficiencies = df_flux['efficiencies'].values efficiencies_err = df_flux['efficiencies_err'].values cbins = len(counts) + 1 carray = np.arange(cbins, dtype=float) ebins = len(counts) + 1 earray = np.arange(ebins, dtype=float) cbins -= 1 ebins -= 1 # Load response matrix array if res_mat_file is None: res_mat_file = os.path.join( unfolding_dir, 'response_{}-groups.txt'.format(num_groups)) response_array = np.loadtxt(res_mat_file) if res_mat_err_file is None: res_mat_err_file = os.path.join( unfolding_dir, 'response_err_{}-groups.txt'.format(num_groups)) response_err_array = np.loadtxt(res_mat_err_file) # Measured effects distribution ne_meas = TH1F('ne_meas', 'effects histogram', ebins, earray) ne_meas.GetXaxis().SetTitle('Effects') ne_meas.GetYaxis().SetTitle('Counts') ne_meas.SetStats(0) ne_meas.Sumw2() # Prepare Combined Weighted Histograms - To be Normalized by Model After Filling # Isotropic Weights of Causes - For Calculating Combined Species Efficiency eff = TH1F('Eff', 'Non-Normed Combined Efficiency', cbins, carray) eff.GetXaxis().SetTitle('Causes') eff.GetYaxis().SetTitle('Efficiency') eff.SetStats(0) eff.Sumw2() # Isotropic Weighted Mixing Matrix - For Calculating Combined Species MM response = TH2F('MM', 'Weighted Combined Mixing Matrix', cbins, carray, ebins, earray) response.GetXaxis().SetTitle('Causes') response.GetYaxis().SetTitle('Effects') response.SetStats(0) response.Sumw2() for ci in range(0, cbins): # Fill measured effects histogram ne_meas.SetBinContent(ci + 1, counts[ci]) if counts_err is None: ne_meas.SetBinError(ci + 1, np.sqrt(counts[ci])) else: ne_meas.SetBinError(ci + 1, counts_err[ci]) # Fill response matrix entries for ek in range(0, ebins): response.SetBinContent(ci + 1, ek + 1, response_array[ek][ci]) response.SetBinError(ci + 1, ek + 1, response_err_array[ek][ci]) # Fill efficiency histogram from response matrix eff.SetBinContent(ci + 1, efficiencies[ci]) eff.SetBinError(ci + 1, efficiencies_err[ci]) # Write measured effects histogram to file ne_meas.Write() # Write the cause and effect arrays to file CARRAY = TH1F('CARRAY', 'Cause Array', cbins, carray) CARRAY.GetXaxis().SetTitle('Causes') EARRAY = TH1F('EARRAY', 'Effect Array', ebins, earray) EARRAY.GetXaxis().SetTitle('Effects') CARRAY.Write() EARRAY.Write() # Write efficiencies histogram to file eff.Write() # Write response matrix to file response.Write() fout.Write() fout.Close()
sys.exit() data_obs = dataHist.Clone("data_obs") rebinnedData = data_obs.Rebin(len(binning) - 1, "", binning) ## input to combine , open root file if template: myfile = TFile("%s%s.root" % (plotDirectory, myfilename), "update") # i have to get the nominal histogram from root file first and get the integration value if systematics == '': myDatahist = rebinnedData.Clone("nominal") mydataDir = "%s/data_obs/" % channel if myfile.GetDirectory(mydataDir): gDirectory.cd(mydataDir) gDirectory.Delete("*;*") myDatahist.Write() else: gDirectory.mkdir(mydataDir) gDirectory.cd(mydataDir) gDirectory.Delete("*;*") myDatahist.Write() # create directory only if it does not exist ### ele channel for iprocess in template_category.keys(): myfile.cd() mydir = "%s/%s/" % (channel, iprocess) #print "%s/%s/"%(channel,iprocess)
def produce(self): from ROOT import TFile, TChain, TH1 from os.path import exists as pathExists from os.path import split as splitPath outFilePath = "%s/%s.%s.%s.root" % (self.outPath, "".join( self.flags), "processed", self.name) #if pathExists(outFilePath): # return outFile = TFile( "%s/%s.%s.%s.root" % (self.outPath, "".join(self.flags), "processed", self.name), "recreate") for section in self.config.sections(): trees = None if section.startswith("dileptonTree:"): treeProducerName = self.config.get(section, "treeProducerName") trees = self._getDileptonTrees(section) treeName = "DileptonTree" subDirName = "%s%s" % (section.split("dileptonTree:")[1], treeProducerName) if not trees == None: outDir = None srcTree = {} for object in trees: srcTree[object] = TChain("%s%s" % (object, treeName)) processors = self.config.get(section, "%sProcessors" % object).split() filter = " and ".join(processors) if self.config.has_option(section, "%sFilter" % object): filter = self.config.get(section, "%sFilter" % object) ### Quick and dirty workaround to prefer certain primary datasets (double muon > double electron > emu) ### To be in synch with ETH group ### Remove duplication of loops and conditions on path if this is to be removed again for treePath in trees[object]: ### Use events from dimuon primary dataset first if not "DoubleMuon" in treePath: continue #srcFile = TFile(filePath,"r") #srcTree = srcFile.Get(treePath) filePath = "%s.root" % treePath.split(".root")[0] inFile = TFile(filePath, "READ") makeCounterSum = eval( self.config.get("general", "counterSum")) print "Add counter sum: %s" % makeCounterSum if not self.counterSum and makeCounterSum: if not outFile.GetDirectory( "%sCounters" % section.split("dileptonTree:")[1]): outFile.mkdir( "%sCounters" % section.split("dileptonTree:")[1]) outFile.cd("%sCounters" % section.split("dileptonTree:")[1]) task = None if "vtxWeighter" in processors: t = self.config.get("general", "tasks") if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t else: task = t else: for t in self.tasks: if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t self.counterSum = inFile.Get( "%sCounters/analysis paths" % task).Clone() else: pass inFile.Close() srcTree[object].Add(treePath) print "adding", treePath for treePath in trees[object]: ### Then take ee primary dataset if not "DoubleElectron" in treePath: continue #srcFile = TFile(filePath,"r") #srcTree = srcFile.Get(treePath) filePath = "%s.root" % treePath.split(".root")[0] inFile = TFile(filePath, "READ") makeCounterSum = eval( self.config.get("general", "counterSum")) print "Add counter sum: %s" % makeCounterSum if not self.counterSum and makeCounterSum: if not outFile.GetDirectory( "%sCounters" % section.split("dileptonTree:")[1]): outFile.mkdir( "%sCounters" % section.split("dileptonTree:")[1]) outFile.cd("%sCounters" % section.split("dileptonTree:")[1]) task = None if "vtxWeighter" in processors: t = self.config.get("general", "tasks") if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t else: task = t else: for t in self.tasks: if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t self.counterSum = inFile.Get( "%sCounters/analysis paths" % task).Clone() else: pass inFile.Close() srcTree[object].Add(treePath) print "adding", treePath for treePath in trees[object]: ### Now the rest, but avoid taking a tree twice if "DoubleElectron" in treePath or "DoubleMuon" in treePath: continue #srcFile = TFile(filePath,"r") #srcTree = srcFile.Get(treePath) filePath = "%s.root" % treePath.split(".root")[0] inFile = TFile(filePath, "READ") makeCounterSum = eval( self.config.get("general", "counterSum")) print "Add counter sum: %s" % makeCounterSum if not self.counterSum and makeCounterSum: if not outFile.GetDirectory( "%sCounters" % section.split("dileptonTree:")[1]): outFile.mkdir( "%sCounters" % section.split("dileptonTree:")[1]) outFile.cd("%sCounters" % section.split("dileptonTree:")[1]) task = None if "vtxWeighter" in processors: t = self.config.get("general", "tasks") if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t else: task = t else: for t in self.tasks: if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t self.counterSum = inFile.Get( "%sCounters/analysis paths" % task).Clone() else: pass inFile.Close() srcTree[object].Add(treePath) print "adding", treePath srcTree[object].SetBranchStatus("*", 1) for processorName in processors: if processorName == "vtxWeighter": srcTree[object].SetBranchStatus("weight", 0) #### old code if (self.treeProcessors[processorName].__class__. __name__ == SimpleSelector.__name__ and not self.config.has_option( section, "%sFilter" % object)): print "Requirements met, applying simple selection boosting =)" expression = self.treeProcessors[ processorName].getExpression(object) print "Cutting tree down to: '%s'" % (expression) srcTree[object] = srcTree[object].CopyTree( expression) ###### self.treeProcessors[processorName].prepareSrc( srcTree[object], object, self.treeProcessors) for object in trees: processors = self.config.get(section, "%sProcessors" % object).split() filter = " and ".join(processors) if self.config.has_option(section, "%sFilter" % object): filter = self.config.get(section, "%sFilter" % object) if not outDir: outDir = outFile.mkdir(subDirName) outFile.cd(subDirName) destTree = srcTree[object].CloneTree(0) destTree.SetAutoSave(5000000000) #print processors for processorName in processors: self.treeProcessors[processorName].prepareDest( destTree, object) #~ print "%s: %d" % (str(processorName), self.treeProcessors[processorName].nEntries) endOfLine = 1000 for i in srcTree[object]: if endOfLine < 1: pass #continue endOfLine -= 1 processingResults = {} ### old code for processorName in processors: processingResults[ processorName] = self.treeProcessors[ processorName].processEvent( srcTree[object], object) if filter == "" or eval(filter, processingResults): destTree.Fill() #### #srcFile.Close() outFile.Write() #from pprint import pprint #pprint( trees) outFile.Purge() outFile.Close()
def saveHist(hist, channel, analysis, addStat=False): #if not 'XZh' in channel or not 'monoB' in channel: return True # Blind #if options.blind: hist['data_obs'] = hist['BkgSum'].Clone("data_obs") # Re-normalize signals #for s in hist.keys(): #if 'bbDM' in s or 'ttDM' in s: #print "scaling", s, "by", xsections[sample[s]['files'][0][:-3]] #hist[s].Scale( 1./xsections[sample[s]['files'][0][:-3]] ) #if 'bbDM' in s: #hist[s].Scale( kfactors4F5F[sample[s]['files'][0][:-3]] ) # Normalize to lumi #for s in hist.keys(): # hist[s].Scale(3000/LUMI) # Fix name #hist['data_obs'].SetName("data_obs") # Merge Z->ll and Z->nunu together if 'DYJetsToNuNu_HT' in hist: if 'DYJetsToLL_HT' in hist: hist['DYJets_HT'] = hist['DYJetsToLL_HT'].Clone('DYJets_HT') hist['DYJets_HT'].Add(hist['DYJetsToNuNu_HT']) #hist['DYJetsToLL_HT'].SetName("DYJets_HT") elif 'DYJetsToLL' in hist: hist['DYJets'] = hist['DYJetsToLL'].Clone('DYJets') hist['DYJets'].Add(hist['DYJetsToNuNu']) #hist['DYJetsToLL'].SetName("DYJets") #hist.pop('DYJetsToNuNu_HT') # Merge Others #hist['Others'] = copy.deepcopy( hist['BkgSum'] ) #hist['Others'].SetFillColor(920) #hist['Others'].SetName("Others") #hist['Others'].Reset() #for i, s in enumerate(othr): # hist['Others'].Add( hist[s] ) # Sanity check # smax = max(hist, key=lambda x: hist[x].Integral()) # for i in range(hist[smax].GetNbinsX()):#FIXME for s in hist.keys(): if not hist[s].GetBinContent(i + 1) > 0.: hist[s].SetBinContent(i + 1, 1.e-6) # Sanity check nbins = hist['data_obs'].GetNbinsX() #CMS_stat_Z0b_bin57 outFile = TFile("rootfiles/" + analysis + "Hist.root", "UPDATE") outFile.cd() if outFile.GetDirectory(channel): outFile.rmdir(channel) outFile.mkdir(channel) outFile.cd(channel) #hist['data_obs'].Write("data_obs") #hist['Others'].Write() for s in hist.keys(): #if not 'DYJetsToLL' in s and not 'DYJetsToNuNu' in s: hist[s].Write() outFile.cd("..") # Statistical MC uncertainty if addStat: for s in hist.keys(): if 'data' in s: continue dirname = channel + "/Sys_" + s if outFile.GetDirectory(dirname): outFile.rmdir(dirname) outFile.mkdir(dirname) outFile.cd(dirname) for k in range(1, nbins + 1): sysname = "CMS_stat_%s_%s_bin%d" % (channel, s, k) histUp = hist[s].Clone(sysname + "Up") histUp.SetBinContent( k, histUp.GetBinContent(k) + histUp.GetBinError(k)) histUp.Write() histDown = hist[s].Clone(sysname + "Down") histDown.SetBinContent( k, max( histDown.GetBinContent(k) - histDown.GetBinError(k), 1.e-6)) histDown.Write() outFile.cd("..") outFile.Close() print "Histograms saved in file rootfiles/" + analysis + "Hist.root"
def produce(self): from ROOT import TFile, TChain, TH1 from os.path import exists as pathExists from os.path import split as splitPath outFilePath = "%s/%s.%s.%s.root" % (self.outPath, "".join( self.flags), "processed", self.name) #if pathExists(outFilePath): # return outFile = TFile( "%s/%s.%s.%s.root" % (self.outPath, "".join(self.flags), "processed", self.name), "recreate") for section in self.config.sections(): trees = None if section.startswith("dileptonTree:"): treeProducerName = self.config.get(section, "treeProducerName") trees = self._getDileptonTrees(section) treeName = "DileptonTree" subDirName = "%s%s" % (section.split("dileptonTree:")[1], treeProducerName) if "PFHTHLT" in subDirName: subDirName = "%sFinalTrees" % subDirName.split( treeProducerName)[0] if section.startswith("isoTree:"): treeProducerName = self.config.get(section, "treeProducerName") trees = self._getIsoTrees(section) treeName = "Iso" subDirName = "%s%s" % (section.split("isoTree:")[1], treeProducerName) if not trees == None: outDir = None srcTree = {} for object in trees: srcTree[object] = TChain("%s%s" % (object, treeName)) processors = self.config.get(section, "%sProcessors" % object).split() filter = " and ".join(processors) if self.config.has_option(section, "%sFilter" % object): filter = self.config.get(section, "%sFilter" % object) for treePath in trees[object]: #srcFile = TFile(filePath,"r") #srcTree = srcFile.Get(treePath) filePath = "%s.root" % treePath.split(".root")[0] inFile = TFile(filePath, "READ") makeCounterSum = eval( self.config.get("general", "counterSum")) print "Add counter sum: %s" % makeCounterSum if not self.counterSum and makeCounterSum: if not outFile.GetDirectory( "%sCounters" % section.split("dileptonTree:")[1]): outFile.mkdir( "%sCounters" % section.split("dileptonTree:")[1]) outFile.cd("%sCounters" % section.split("dileptonTree:")[1]) task = None if "vtxWeighter" in processors: t = self.config.get("general", "tasks") if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t else: task = t else: for t in self.tasks: if ".%s." % t in splitPath(filePath)[1]: assert task == None, "unable to disambiguate tasks '%s' matches both '%s' and '%s'" ( filePath, task, t) task = t self.counterSum = inFile.Get( "%sCounters/analysis paths" % task).Clone() ## also add 3D weights #outFile.mkdir("%sWeightSummer" % section.split("dileptonTree:")[1]) #outFile.cd("%sWeightSummer" % section.split("dileptonTree:")[1]) ## task has been defined above #self.weightSum = inFile.Get("%sWeightSummer/Weights"%task).Clone() else: pass #need to cope with different lumis :( #h = inFile.Get("%sCounters/analysis paths"%task) #print inFile, "%sCounters/analysis paths"%task, h #self.counterSum.Add( h,1. ) inFile.Close() srcTree[object].Add(treePath) print "adding", treePath srcTree[object].SetBranchStatus("*", 1) ### signal code if (self.treeProcessors[filter].__class__.__name__ == SimpleSelector.__name__ and self.config.has_option(section, "%sFilter" % object)): expression = self.treeProcessors[filter].getExpression( object) print "Cutting tree down to: '%s'" % (expression) outFile.Write() outFile.Close() srcTree[object] = srcTree[object].CopyTree(expression) outFile = TFile( "%s/%s.%s.%s.root" % (self.outPath, "".join( self.flags), "processed", self.name), "UPDATE") ##### for processorName in processors: if processorName == "vtxWeighter": srcTree[object].SetBranchStatus("weight", 0) #### default code #~ if (self.treeProcessors[processorName].__class__.__name__ == SimpleSelector.__name__ and not self.config.has_option(section,"%sFilter"%object)): #~ print "Requirements met, applying simple selection boosting =)" #~ expression = self.treeProcessors[processorName].getExpression(object) #~ print "Cutting tree down to: '%s'" % (expression) #~ srcTree[object] = srcTree[object].CopyTree(expression) ###### self.treeProcessors[processorName].prepareSrc( srcTree[object], object, self.treeProcessors) for object in trees: processors = self.config.get(section, "%sProcessors" % object).split() filter = " and ".join(processors) if self.config.has_option(section, "%sFilter" % object): filter = self.config.get(section, "%sFilter" % object) if not outDir: outDir = outFile.mkdir(subDirName) outFile.cd(subDirName) destTree = srcTree[object].CloneTree(0) destTree.SetAutoSave(5000000000) #print processors for processorName in processors: self.treeProcessors[processorName].prepareDest( destTree, object) #~ print "%s: %d" % (str(processorName), self.treeProcessors[processorName].nEntries) endOfLine = 1000 for i in srcTree[object]: if endOfLine < 1: pass #continue endOfLine -= 1 processingResults = {} ### default code #~ for processorName in processors: #~ processingResults[processorName] = self.treeProcessors[processorName].processEvent(srcTree[object], object) #~ if filter == "" or eval(filter, processingResults): #~ destTree.Fill() #### ### signal code keep = False for processorName in processors: keep = self.treeProcessors[ processorName].processEvent( srcTree[object], object) if keep: destTree.Fill() #### #srcFile.Close() outFile.Write() #from pprint import pprint #pprint( trees) outFile.Purge() outFile.Close()
def SaveGraph_1D(FileName, outputFile): myfile = TFile( FileName ) print "\nnow loading [%s]" % FileName ######################################### # -- check the scenario (data or MC) -- # ######################################### Scenario = "" GraphName = "" if "data_25ns" in FileName: Scenario = "Data" GraphName = Scenario + "_" + FileName.split("_data_25ns_")[1:][0].split(".root")[:1][0] elif "mc" in FileName: Scenario = "MC" GraphName = Scenario + "_" + FileName.split("_mc_")[1:][0].split(".root")[:1][0] ######################### # -- Make graph name -- # ######################### # print "GraphName will be [%s]" % GraphName TreeName = "muonEffs" ######################### # -- sub-directory 1 -- # ######################### Path1 = "%s" % TreeName Dir1 = myfile.GetDirectory( Path1 ); print "now in %s" % Path1 if Dir1.GetListOfKeys().GetEntries() > 2: print "More than 2 directories under %s" % Path1 sys.exit() ######################### # -- sub-directory 2 -- # ######################### Path2 = "%s/%s/fit_eff_plots" % ( TreeName, Dir1.GetListOfKeys().At(0).GetName() ) Dir2 = myfile.GetDirectory( Path2 ) print "now in %s" % Path2 if Dir2.GetListOfKeys().GetEntries() > 1: print "More than 1 directory under %s" % Path2 sys.exit() ############################ # -- Get canvas & graph -- # ############################ canvas = Dir2.GetListOfKeys().At(0).ReadObj() graph = canvas.GetPrimitive("hxy_fit_eff").Clone(); name_before = canvas.GetName() graph.SetName( GraphName ) print "\tgraph: %s -> %s" % (name_before, GraphName) ############## # -- Save -- # ############## outputFile.cd() graph.Write() myfile.Close()
# QCD in SR = TF * (data - nonQCDBkg from CR) #---------------------------------------- qcdTFDirInFile = "%s/TF"%histDirInFile qcdShapeDirInFile = "%s/Shape"%histDirInFile transferFactor = 1.0 if sample =="QCD_DD" and "Semi" in ttbarDecayMode: toPrint("Determining QCD Transfer factor from CR", "") #transferFactor = getQCDTransFact(year, channel, nBJets, outputFile, qcdTFDirInFile) print "Transfer factor = ", transferFactor for hist in histogramsToMake: if not histogramInfo[hist][5]: continue toPrint("Determining QCD shape from CR", "") dataMinusOtherBkg = getShapeFromCR(year, channel, nJetSel, nBJets, histogramInfo[hist], outputFile, qcdShapeDirInFile) histograms.append(dataMinusOtherBkg) print histogramInfo[hist][1] histograms[-1].Scale(transferFactor) #----------------------------------- # Write final histograms in the file #----------------------------------- if not outputFile.GetDirectory(histDirInFile): outputFile.mkdir(histDirInFile) outputFile.cd(histDirInFile) for h in histograms: toPrint("Integral of Histogram %s = "%h.GetName(), h.Integral()) outputFile.cd(histDirInFile) gDirectory.Delete("%s;*"%(h.GetName())) h.Write() toPrint("Path of output root file", outFileFullPath) outputFile.Close()
class StoreGate(Logger): def __init__(self, outputFile, **kw): Logger.__init__(self, **kw) if not outputFile.endswith('.root'): outputFile += '.root' from Gaugi.utilities import retrieve_kw # Use this property to rebuild the storegate from a root file self._restoreStoreGate = retrieve_kw(kw, 'restoreStoreGate', False) filterDirs = retrieve_kw(kw, 'filterDirs', None) #Create TFile object to hold everything from ROOT import TFile from Gaugi import expandPath outputFile = expandPath(outputFile) if self._restoreStoreGate: import os.path if not os.path.exists(outputFile): raise ValueError("File '%s' does not exist" % outputFile) self._file = TFile(outputFile, "read") else: self._file = TFile(outputFile, "recreate") self._currentDir = "" self._objects = dict() self._dirs = list() import os self._outputFile = os.path.abspath(outputFile) if self._restoreStoreGate: retrievedObjs = self.__restore(self._file, filterDirs=filterDirs) for name, obj in retrievedObjs: self._dirs.append(name) self._objects[name] = obj def local(self): return self._outputFile #Save objects and delete storegate def __del__(self): self._dirs = None #for val in self._objects.itervalues(): # print "deleting", val # val.Delete() self._objects = None import gc gc.collect() if not self._restoreStoreGate: self._file.Close() def write(self): self._file.Write() #Create a folder def mkdir(self, theDir): fullpath = (theDir).replace('//', '/') if not fullpath in self._dirs: self._dirs.append(fullpath) self._file.mkdir(fullpath) self._file.cd(fullpath) self._currentDir = fullpath self._logger.verbose('Created directory with name %s', theDir) #Go to the pointed directory def cd(self, theDir): self._currentDir = '' self._file.cd() fullpath = (theDir).replace('//', '/') if fullpath in self._dirs: self._currentDir = fullpath if self._file.cd(fullpath): return True self._logger.error("Couldn't cd to folder %s", fullpath) return False def addHistogram(self, obj): feature = obj.GetName() fullpath = (self._currentDir + '/' + feature).replace('//', '/') if not fullpath.startswith('/'): fullpath = '/' + fullpath if not fullpath in self._dirs: self._dirs.append(fullpath) self._objects[fullpath] = obj #obj.Write() self._logger.debug('Saving object type %s into %s', type(obj), fullpath) def addObject(self, obj): feature = obj.GetName() fullpath = (self._currentDir + '/' + feature).replace('//', '/') if not fullpath.startswith('/'): fullpath = '/' + fullpath if not fullpath in self._dirs: self._dirs.append(fullpath) self._objects[fullpath] = obj obj.Write() self._logger.debug('Saving object type %s into %s', type(obj), fullpath) def histogram(self, feature): fullpath = (feature).replace('//', '/') if not fullpath.startswith('/'): fullpath = '/' + fullpath if fullpath in self._dirs: obj = self._objects[fullpath] self._logger.verbose('Retrieving object type %s into %s', type(obj), fullpath) return obj else: #None object if doesnt exist into the store self._logger.warning('Object with path %s doesnt exist', fullpath) return None def getDir(self, path): return self._file.GetDirectory(path) # Use this to set labels into the histogram def setLabels(self, feature, labels): histo = self.histogram(feature) if not histo is None: try: if (len(labels) > 0): for i in range(min(len(labels), histo.GetNbinsX())): bin = i + 1 histo.GetXaxis().SetBinLabel(bin, labels[i]) for i in range( histo.GetNbinsX(), min(len(labels), histo.GetNbinsX() + histo.GetNbinsY())): bin = i + 1 - histo.GetNbinsX() histo.GetYaxis().SetBinLabel(bin, labels[i]) except: self._logger.fatal("Can not set the labels! abort.") else: self._logger.warning( "Can not set the labels because this feature (%s) does not exist into the storage", feature) def collect(self): self._objects.clear() self._dirs = list() def getObjects(self): return self._objects def getDirs(self): return self._dirs def merge(self, sg): if isinstance(sg, StoreGate): sg = [sg] if isinstance(sg, (list, tuple)): sg = StoreGateCollection(sg) if not isinstance(sg, StoreGateCollection): raise TypeError(type(sg)) from ROOT import TH1, TH2 for s in sg: for path, obj in s.getObjects().iteritems(): if isinstance(obj, (TH1, TH2)): if path in self._objects: mobj = self.histogram(path) if mobj: mobj.Add(obj) # Use this method to retrieve the dirname and root object def __restore(self, d, basepath="/", filterDirs=None): """ Generator function to recurse into a ROOT file/dir and yield (path, obj) pairs Taken from: https://root.cern.ch/phpBB3/viewtopic.php?t=11049 """ try: for key in d.GetListOfKeys(): kname = key.GetName() if key.IsFolder(): if filterDirs and kname not in filterDirs: continue for i in self.__restore(d.Get(kname), basepath + kname + "/"): yield i else: yield basepath + kname, d.Get(kname) except AttributeError as e: self._logger.debug("Ignore reading object of type %s.", type(d))
def processFile(sample_name, verbose=False): sample = sample_name.replace(ANALYSIS + ".", "").replace(".root", "") isMC = not '2016' in sample # Unweighted input ref_file_name = origin + '/' + sample_name if not os.path.exists(ref_file_name): print ' WARNING: file', ref_file_name, 'does not exist, continuing' return True # Weighted output new_file_name = target + '/' + sample + '.root' #if os.path.exists(new_file_name): # print ' WARNING: weighted file exists, overwriting' #return True new_file = TFile(new_file_name, 'RECREATE') new_file.cd() # Open old file ref_file = TFile(ref_file_name, 'READ') ref_hist = ref_file.Get('Events') try: totalEntries = ref_hist.GetBinContent(1) except: print ' ERROR: nEvents not found in file', sample exit(1) # Open stitching file stitch_file = TFile("stitching.root", 'READ') stitch_num = {} if sample.startswith('DY'): for i in range(len(binsNb)): stitch_num[i] = stitch_file.Get("nEvents_%s_nB%d" % (sample, i)) stitch_den = stitch_file.Get('nEvents') # Cross section XS = xsection[sample]['xsec'] * xsection[sample]['kfactor'] * xsection[ sample]['br'] Leq = LUMI * XS / totalEntries if totalEntries > 0 else 0. print sample, ": Leq =", (Leq if isMC else "Data") # Variables declaration stitchWeight = array('f', [1.0]) eventWeightLumi = array('f', [1.0]) # global event weight with lumi # Looping over file content for key in ref_file.GetListOfKeys(): obj = key.ReadObj() # Histograms if obj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', obj.GetName() new_file.cd() if isMC: obj.Scale(LUMI * XS / totalEntries) obj.Write() # Tree elif obj.IsA().InheritsFrom('TTree'): nev = obj.GetEntriesFast() new_file.cd() new_tree = obj.CopyTree("") # New branches stitchWeightBranch = new_tree.Branch('stitchWeight', stitchWeight, 'stitchWeight/F') eventWeightLumiBranch = new_tree.Branch('eventWeightLumi', eventWeightLumi, 'eventWeightLumi/F') # looping over events for event in range(0, obj.GetEntries()): if verbose and (event % 10000 == 0 or event == nev - 1): print ' = TTree:', obj.GetName( ), 'events:', nev, '\t', int(100 * float(event + 1) / float(nev)), '%\r', #print '.',#*int(20*float(event)/float(nev)),#printProgressBar(event, nev) obj.GetEntry(event) # Initialize eventWeightLumi[0] = stitchWeight[0] = 1. # Weights if isMC: # MC stitching if sample.startswith( 'DY') and 'LL' in sample and not 'BJets' in sample: nB = min(int(obj.LheNb), binsNb[-1]) bin = stitch_den.FindBin( min(obj.LheHT, binsHT[-1] - 1), min(obj.LheV_pt, binsV_pt[-1] - 1), min(obj.LheNj, binsNj[-1])) nS = stitch_num[nB].GetBinContent(bin) nT = stitch_den.GetBinContent(bin) stitchWeight[0] = nS / nT # if sample=='DYJetsToLL' or sample=='WJetsToLNu': # if obj.LheHT > 100.: stitchWeight[0] = 0. # else: stitchWeight[0] = 0.843 eventWeightLumi[0] = obj.eventWeight * obj.bTagWeight eventWeightLumi[0] *= LUMI * XS / totalEntries # Fill the branches stitchWeightBranch.Fill() eventWeightLumiBranch.Fill() new_file.cd() new_tree.Write() if verbose: print ' ' # Directories elif obj.IsFolder(): subdir = obj.GetName() if verbose: print ' \ Directory', subdir, ':' new_file.mkdir(subdir) new_file.cd(subdir) for subkey in ref_file.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', subobj.GetName() new_file.cd(subdir) if isMC: subobj.Scale(LUMI * XS / totalEntries) subobj.Write() new_file.cd('..') new_file.Close()
def processFile(sample, origin, target, verbose=False): #isSignal = True if "signal" in sample or "Zprime" in sample else False isSignal = True if mcType == "signal" else False if not os.path.exists(origin): print 'Origin directory', origin, 'does not exist, aborting...' sys.exit() if not os.path.exists(target): print 'Target directory', target, 'does not exist, creating it now' os.makedirs(target) ## Unweighted input #ref_file_name = origin + '/' + sample_name #if not os.path.exists(ref_file_name): # print ' WARNING: file', ref_file_name, 'does not exist, continuing' # return True # first loop over all files to get nGenEvents totalEntries = 0. file_list = [origin + "/" + sample + ".root"] ## this is the original line ### this here is for big ntuples: #file_list = [] #j = 0 #while True: # if os.path.exists(origin + "/" + sample + "_flatTuple_{}.root".format(j)): # file_list.append(origin + "/" + sample + "_flatTuple_{}.root".format(j)) # j += 1 # else: # print "found {} files for sample:".format(j), sample # break #if j == 0: # print ' WARNING: files for sample', sample , 'do not exist, continuing' # return True ### end big ntuples if isMC: for infile_name in file_list: infile = TFile(infile_name, 'READ') try: evtHist = infile.Get('Events') nEvents = evtHist.GetBinContent(1) totalEntries += nEvents #print "sample:",sample,"nEvents:", nEvents except: print ' ERROR: nEvents not found in file', sample exit(1) infile.Close() print "totalEntries =", totalEntries # Cross section XS = getXsec(sample.replace(year + '_', '')) print "XS = ", XS Leq = LUMI * XS / totalEntries if totalEntries > 0 else 0. #if isSignal: ## commented out since totalEntries now takes care of btagging weights in case of signal # signName = sample.replace('MC_signal_', 'ZpBB') # if '2016' in signName: # yr = '2016' # elif '2017' in signName: # yr = '2017' # elif '2018' in signName: # yr = '2018' # signName = signName.replace(yr,'') # print "number of generated events:", SAMPLE[signName]['genEvents'][yr] # Leq = LUMI*XS/SAMPLE[signName]['genEvents'][yr] print sample, ": Leq =", (Leq if isMC else "Data") # Open old files now to plug in weights for ref_file_name in file_list: print "working on file:", ref_file_name # Weighted output new_file_name = ref_file_name.replace(origin, target) new_file = TFile(new_file_name, 'RECREATE') new_file.cd() ref_file = TFile(ref_file_name, 'READ') # Variables declaration eventWeightLumi = array('f', [1.0]) # global event weight with lumi # get tree tree = ref_file.Get("tree") nev = tree.GetEntriesFast() new_file.cd() new_tree = tree.CopyTree("") # New branches eventWeightLumiBranch = new_tree.Branch('eventWeightLumi', eventWeightLumi, 'eventWeightLumi/F') # looping over events for event in range(0, tree.GetEntries()): if verbose and (event % 10000 == 0 or event == nev - 1): print ' = TTree:', tree.GetName(), 'events:', nev, '\t', int( 100 * float(event + 1) / float(nev)), '%\r', tree.GetEntry(event) # Initialize eventWeightLumi[0] = 1. # Weights if isMC: eventWeightLumi[0] = tree.GenWeight * Leq #if isSignal: eventWeightLumi[0] = Leq ## FIXME FIXME check if this is sufficient!! FIXME FIXME if isSignal: eventWeightLumi[0] = tree.BTagAK4Weight_deepJet * Leq # Fill the branches eventWeightLumiBranch.Fill() new_file.cd() new_tree.Write("", TObject.kOverwrite) if verbose: print ' ' # Looping over additional file content for key in ref_file.GetListOfKeys(): obj = key.ReadObj() # Histograms if obj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', obj.GetName() new_file.cd() obj.Write() # Tree elif obj.IsA().InheritsFrom('TTree'): continue #nev = obj.GetEntriesFast() #new_file.cd() #new_tree = obj.CopyTree("") ## New branches #eventWeightLumiBranch = new_tree.Branch('eventWeightLumi', eventWeightLumi, 'eventWeightLumi/F') ## looping over events #for event in range(0, obj.GetEntries()): # if verbose and (event%10000==0 or event==nev-1): print ' = TTree:', obj.GetName(), 'events:', nev, '\t', int(100*float(event+1)/float(nev)), '%\r', # obj.GetEntry(event) # # Initialize # eventWeightLumi[0] = 1. # # Weights # if isMC: # eventWeightLumi[0] = obj.GenWeight * Leq # if isSignal: eventWeightLumi[0] = Leq # # Fill the branches # eventWeightLumiBranch.Fill() #new_file.cd() #new_tree.Write() #if verbose: print ' ' # Directories elif obj.IsFolder(): subdir = obj.GetName() if verbose: print ' \ Directory', subdir, ':' new_file.mkdir(subdir) new_file.cd(subdir) for subkey in ref_file.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', subobj.GetName() new_file.cd(subdir) subobj.Write() new_file.cd('..') ref_file.Close() new_file.Close()
def processFile(sample_name, verbose=False): sample = sample_name.replace(ANALYSIS + ".", "").replace(".root", "") isMC = not '2016' in sample # Unweighted input ref_file_name = origin + '/' + sample_name if not os.path.exists(ref_file_name): print ' WARNING: file', ref_file_name, 'does not exist, continuing' return True # Weighted output new_file_name = target + '/' + sample + '.root' #if os.path.exists(new_file_name): # print ' WARNING: weighted file exists, overwriting' #return True new_file = TFile(new_file_name, 'RECREATE') new_file.cd() # Open old file ref_file = TFile(ref_file_name, 'READ') ref_hist = ref_file.Get('Events') try: totalEntries = ref_hist.GetBinContent(1) except: print ' ERROR: nEvents not found in file', sample exit(1) old_tree = ref_file.Get("tree") #check if the tree already has the lumi weights hasLumiWeights = any(True for x in old_tree.GetListOfBranches() if "eventWeightLumi" in x.GetName()) # Cross section XS = xsection[sample]['xsec'] * xsection[sample]['kfactor'] * xsection[ sample]['br'] Leq = LUMI * XS / totalEntries if totalEntries > 0 else 0. print sample, ": Leq =", (Leq if isMC else "Data") for key in ref_file.GetListOfKeys(): obj = key.ReadObj() # Histograms if obj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', obj.GetName() new_file.cd() if isMC and not hasLumiWeights: obj.Scale(LUMI * XS / totalEntries) obj.Write() # Tree elif obj.IsA().InheritsFrom('TTree'): continue # Directories elif obj.IsFolder(): subdir = obj.GetName() if verbose: print ' \ Directory', subdir, ':' new_file.mkdir(subdir) new_file.cd(subdir) for subkey in ref_file.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', subobj.GetName() new_file.cd(subdir) if isMC and not hasLumiWeights: subobj.Scale(LUMI * XS / totalEntries) subobj.Write() new_file.cd('..') # Variables declaration #dummy = array('f', [1.0]) #example variable mTb_massless = array('f', [1.0]) #example variable mTb_mass = array('f', [1.0]) #example variable min_DeltaR = array('f', [1.0]) max_DeltaR = array('f', [1.0]) minDphiJet1BJet = array('f', [1.0]) minDphiJet2BJet = array('f', [1.0]) topdRMass = array('f', [1.0]) WdRMass = array('f', [1.0]) Dphi_Wb = array('f', [1.0]) Dphi_topb = array('f', [1.0]) Dphi_WMET = array('f', [1.0]) Dphi_topMET = array('f', [1.0]) pt_bjet = array('f', [1.0]) DeltaR_bb = array('f', [1.0]) cosTheta_bb = array('f', [1.0]) HT3 = array('f', [1.0]) sphericity = array('f', [1.0]) aplanarity = array('f', [1.0]) circularity = array('f', [1.0]) isotropy = array('f', [1.0]) C = array('f', [1.0]) D = array('f', [1.0]) stitchWeight = array('f', [1.0]) eventWeightLumi = array('f', [1.0]) # global event weight with lumi nev = old_tree.GetEntriesFast() new_file.cd() #we are not going to copy the entire old tree tname = "Ftree" new_tree = TTree(tname, tname) if copytree: tname = "tree" new_tree = old_tree.CopyTree("") #define new branches you want to add here #!!!Attention: if run twice, this will create a new branch with the same name as the old one mTb_massBranch = new_tree.Branch('mTb_mass', mTb_mass, 'mTb_mass/F') mTb_masslessBranch = new_tree.Branch('mTb_massless', mTb_massless, 'mTb_massless/F') minDphiJet1BJetBranch = new_tree.Branch('minDphiJet1BJet', minDphiJet1BJet, 'minDphiJet1BJet/F') minDphiJet2BJetBranch = new_tree.Branch('minDphiJet2BJet', minDphiJet2BJet, 'minDphiJet2BJet/F') min_DeltaRBranch = new_tree.Branch('min_DeltaR', min_DeltaR, 'min_DeltaR/F') max_DeltaRBranch = new_tree.Branch('max_DeltaR', max_DeltaR, 'max_DeltaR/F') topdRMassBranch = new_tree.Branch('topdRMass', topdRMass, 'topdRMass/F') WdRMassBranch = new_tree.Branch('WdRMass', WdRMass, 'WdRMass/F') Dphi_WbBranch = new_tree.Branch('Dphi_Wb', Dphi_Wb, 'Dphi_Wb/F') Dphi_topbBranch = new_tree.Branch('Dphi_topb', Dphi_topb, 'Dphi_topb/F') Dphi_WMETBranch = new_tree.Branch('Dphi_WMET', Dphi_WMET, 'Dphi_WMET/F') Dphi_topMETBranch = new_tree.Branch('Dphi_topMET', Dphi_topMET, 'Dphi_topMET/F') pt_bjetBranch = new_tree.Branch('pt_bjet', pt_bjet, 'pt_bjet/F') DeltaR_bbBranch = new_tree.Branch('DeltaR_bb', DeltaR_bb, 'DeltaR_bb/F') cosTheta_bbBranch = new_tree.Branch('cosTheta_bb', cosTheta_bb, 'cosTheta_bb/F') HT3Branch = new_tree.Branch('HT3', HT3, 'HT3/F') sphericityBranch = new_tree.Branch('sphericityFT', sphericity, 'sphericityFT/F') aplanarityBranch = new_tree.Branch('aplanarityFT', aplanarity, 'aplanarityFT/F') circularityBranch = new_tree.Branch('circularityFT', circularity, 'circularityFT/F') isotropyBranch = new_tree.Branch('isotropyFT', isotropy, 'isotropyFT/F') CBranch = new_tree.Branch('CFT', C, 'CFT/F') DBranch = new_tree.Branch('DFT', D, 'DFT/F') if not (hasLumiWeights ): #only do lumi branches if they don't exist already stitchWeightBranch = new_tree.Branch('stitchWeight', stitchWeight, 'stitchWeight/F') eventWeightLumiBranch = new_tree.Branch('eventWeightLumi', eventWeightLumi, 'eventWeightLumi/F') # looping over events for event in range(0, old_tree.GetEntries()): if verbose and (event % 10000 == 0 or event == nev - 1): print ' = TTree:', old_tree.GetName(), 'events:', nev, '\t', int( 100 * float(event + 1) / float(nev)), '%\r', old_tree.GetEntry(event) #not necessarily elegant but should do the trick, if I have a lot of time fix to use 4-vector array csv = [ old_tree.Jet1_csv, old_tree.Jet2_csv, old_tree.Jet3_csv, old_tree.Jet4_csv ] id_csv = csv.index(max(csv)) id2_csv = heapq.nlargest(2, xrange(len(csv)), key=csv.__getitem__)[1] jets = [ (old_tree.Jet1_pt, old_tree.Jet1_eta, old_tree.Jet1_phi, old_tree.Jet1_E), (old_tree.Jet2_pt, old_tree.Jet2_eta, old_tree.Jet2_phi, old_tree.Jet2_E), (old_tree.Jet3_pt, old_tree.Jet3_eta, old_tree.Jet3_phi, old_tree.Jet3_E), (old_tree.Jet4_pt, old_tree.Jet4_eta, old_tree.Jet4_phi, old_tree.Jet4_E), ] # print jets # print jets[id_csv] minDphiJet1BJet[0] = Return_minDphiJetBJet(jets, id_csv)[0] minDphiJet2BJet[0] = Return_minDphiJetBJet(jets, id_csv)[1] topdRMass[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[0] WdRMass[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[1] Dphi_Wb[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[2] Dphi_topb[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[3] Dphi_WMET[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[4] Dphi_topMET[0] = Return_Top(jets, id_csv, old_tree.MET_phi)[5] jets_EtaPhi = [ (old_tree.Jet1_eta, old_tree.Jet1_phi), (old_tree.Jet2_eta, old_tree.Jet2_phi), (old_tree.Jet3_eta, old_tree.Jet3_phi), (old_tree.Jet4_eta, old_tree.Jet4_phi), (old_tree.Jet5_eta, old_tree.Jet5_phi), (old_tree.Jet6_eta, old_tree.Jet6_phi), ] min_DeltaR[0] = Return_DeltaR(jets_EtaPhi, 1)[0] max_DeltaR[0] = Return_DeltaR(jets_EtaPhi, 2)[1] HT3[0] = 0 for i, j in enumerate(jets): if (i != 0 and i != 1): if (j[0] > 0): HT3[0] += j[0] if (csv[id_csv] >= 0 and csv[id2_csv] >= 0): DeltaR_bb[0] = math.sqrt( math.pow((jets_EtaPhi[id_csv][0] - jets_EtaPhi[id2_csv][0]), 2) + math.pow((jets_EtaPhi[id_csv][1] - jets_EtaPhi[id2_csv][1]), 2)) cosTheta_bb[0] = math.fabs( math.tanh( (jets_EtaPhi[id_csv][1] - jets_EtaPhi[id2_csv][1]) / 2)) else: DeltaR_bb[0] = -9 cosTheta_bb[0] = -9 if max(csv) >= 0: mTbs = Return_mTbs(jets[id_csv], old_tree.MET_pt, old_tree.MET_phi) mTb_mass[0] = mTbs['mTb_mass'] mTb_massless[0] = mTbs['mTb_massless'] pt_bjet[0] = jets[id_csv][0] else: mTb_mass[0] = mTb_massless[0] = -99 pt_bjet[0] = -9 if not (hasLumiWeights): eventWeightLumi[0] = stitchWeight[0] = 1 #Event shape variables, need 4vectors jets4vec = getJet4Vectors(old_tree) if len(jets4vec) > 0: eventshape = ROOT.EventShapeVariables(jets4vec) #actually (r) with r=2 for normal and r=1 infrared safe defintion aplanarity[0] = eventshape.aplanarity() sphericity[0] = eventshape.sphericity() circularity[0] = eventshape.circularity() isotropy[0] = eventshape.isotropy() C[0] = eventshape.C() D[0] = eventshape.D() else: sphericity[0] = -99 aplanarity[0] = -99 sphericity_AZ[0] = -99 aplanarity_AZ[0] = -99 circularity[0] = -99 isotropy[0] = -99 C[0] = -99 D[0] = -99 if isMC: # MC stitching if sample == 'DYJetsToLL' or sample == 'WJetsToLNu' or sample == 'W1JetsToLNu' or sample == 'W2JetsToLNu' or sample == 'W3JetsToLNu' or sample == 'W4JetsToLNu': if old_tree.LheHT > 70.: stitchWeight[0] = 0. if not (hasLumiWeights): eventWeightLumi[ 0] = old_tree.eventWeight * old_tree.bTagWeight * old_tree.TopWeight eventWeightLumi[0] *= LUMI * XS / totalEntries #fill the new branches of the tree if not (hasLumiWeights): if copytree: stitchWeightBranch.Fill() eventWeightLumiBranch.Fill() if copytree: #dummyBranch.Fill() mTb_massBranch.Fill() mTb_masslessBranch.Fill() min_DeltaRBranch.Fill() max_DeltaRBranch.Fill() minDphiJet1BJetBranch.Fill() minDphiJet2BJetBranch.Fill() topdRMassBranch.Fill() WdRMassBranch.Fill() Dphi_WbBranch.Fill() Dphi_topbBranch.Fill() Dphi_WMETBranch.Fill() Dphi_topMETBranch.Fill() pt_bjetBranch.Fill() DeltaR_bbBranch.Fill() cosTheta_bbBranch.Fill() HT3Branch.Fill() sphericityBranch.Fill() aplanarityBranch.Fill() circularityBranch.Fill() isotropyBranch.Fill() CBranch.Fill() DBranch.Fill() else: new_tree.Fill() new_file.cd() new_tree.Write(tname, TObject.kOverwrite) if verbose: print ' ' new_file.Close()
def skimTree(sample, filename): # Unweighted input inName = origin + '/' + sample + '/' + filename if not os.path.exists(inName): print '- WARNING: file', inName, 'does not exist, continuing' return True # Weighted output if not os.path.exists(target + '/' + sample): os.mkdir(target + '/' + sample) outName = target + '/' + sample + '/' + filename if os.path.exists(outName): print '- WARNING: weighted file exists, overwriting' #return True outFile = TFile(outName, 'RECREATE') outFile.cd() # Open old file inFile = TFile(inName, 'READ') # Looping over file content for key in inFile.GetListOfKeys(): obj = key.ReadObj() # Histograms if obj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', obj.GetName() outFile.cd() obj.Write() # Tree elif obj.IsA().InheritsFrom('TTree'): outFile.cd() newTree = obj.CopyTree(skimString if obj.GetName() == "Events" else "") ### absPhoton_eta = array('f', [1.0]) absPhoton_etaBranch = newTree.Branch('absPhoton_eta', absPhoton_eta, 'absPhoton_eta/F') for event in range(0, obj.GetEntries()): obj.GetEntry(event) absPhoton_eta[0] = abs(obj.Photon_eta[obj.iPhoton]) if hasattr( obj, "Photon_eta") else -1. absPhoton_etaBranch.Fill() ### newTree.Write(obj.GetName(), TObject.kOverwrite) if verbose: print ' + TTree:', obj.GetName() # Directories elif obj.IsFolder(): subdir = obj.GetName() if verbose: print ' \ Directory', subdir, ':' outFile.mkdir(subdir) outFile.cd(subdir) for subkey in inFile.GetDirectory(subdir).GetListOfKeys(): subobj = subkey.ReadObj() if subobj.IsA().InheritsFrom('TH1'): if verbose: print ' + TH1:', subobj.GetName() outFile.cd(subdir) subobj.Write() outFile.cd('..') outFile.Close()