def createPlots(plotopts, rootopts): from ROOT import TH1D, TProfile, TH2D, TProfile2D plots = {} #creating histos for plotopt in plotopts: plots[plotopt] = {} for rootopt in rootopts: if (plotopt.profile): if (plotopt.i2d): plot = TProfile2D( str(hash(plotopt)) + str(hash(rootopt)), plotopt.display_name, plotopt.nbins[0], 0, 0, plotopt.nbins[1], 0, 0) else: plot = TProfile( str(hash(plotopt)) + str(hash(rootopt)), plotopt.display_name, plotopt.nbins, 0, 0) else: if (plotopt.i2d): plot = TH2D( str(hash(plotopt)) + str(hash(rootopt)), plotopt.display_name, plotopt.nbins[0], 0, 0, plotopt.nbins[1], 0, 0) else: plot = TH1D( str(hash(plotopt)) + str(hash(rootopt)), plotopt.display_name, plotopt.nbins, 0, 0) plot.SetBuffer(1000000) plots[plotopt][rootopt] = plot return plots
def create_residual(data, model, nbins=None, maxr=None, calcr=None, skipzero=False): """Create radial residual histogram.""" if nbins is None: nbins = data.GetXaxis().GetNbins() if maxr is None: maxr = data.GetXaxis().GetXmax() if calcr is None: calcr = lambda x, y: (x**2 + y**2)**0.5 data.SetBinErrorOption(kPoisson) res = TProfile('radialRes', '', nbins, 0.0, maxr) for xbin in range(data.GetXaxis().GetNbins()): for ybin in range(data.GetYaxis().GetNbins()): d = data.GetBinContent(xbin + 1, ybin + 1) if skipzero and d == 0.0: continue m = model.GetBinContent(xbin + 1, ybin + 1) if m < d: e = data.GetBinErrorLow(xbin + 1, ybin + 1) else: e = data.GetBinErrorUp(xbin + 1, ybin + 1) x = data.GetXaxis().GetBinCenter(xbin + 1) y = data.GetYaxis().GetBinCenter(ybin + 1) res.Fill(calcr(x, y), (d - m) / e) return res
def draw_vcal_time(self, bin_width=1000): vcals = self.get_vcal_values() h = TProfile('hvt', 'VCAL vs. Time', *self.get_event_bins(bin_width)) h.FillN(vcals.size, arange(vcals.size, dtype='d'), vcals.astype('d'), full(vcals.size, 1, 'd')) format_histo(h, x_tit='Cluster Number', y_tit='VCAL', y_off=1.5) self.Plotter.format_statbox(entries=1, x=.9) self.Plotter.draw_histo(h, lm=.12, rm=.08)
def staff(): FitParam = ROOT.FitParameters_t() f = TFile("FitParam.root", "RECREATE") tree = TTree('T', "Fitparameters from main program") tree.Branch("FitParam", FitParam, 'Drift_Velocity:Fit_Gradient') fname = "test.txt" hdv = TH1F("hdv", "Drift Velocity Distribution", 100, 0.002615, 0.002645) hfg = TH1F("hfg", "Track Angle Distribution", 100, 0, 0.3) hprof = TProfile("hprof", "Profile of Drift Velocity vs Track Angle", 100, 0.002615, 0.002645, 0, 0.3) histos = ['hdv', 'hfg', 'hprof'] for name in histos: exec('%sFill = %s.Fill' % (name, name)) for line in open(fname).readlines(): t = list(filter(lambda x: x, re.split(',', line))) FitParam.Drift_Velocity = float(t[0]) FitParam.Fit_Gradient = float(t[1]) hdv.Fill(float(t[0])) hfg.Fill(float(t[1])) hprof.Fill(float(t[0]), float(t[1])) tree.Fill() c1 = TCanvas("c1", "Drift Velocity Histogram", 200, 10, 700, 500) c1.SetGridx() c1.SetGridy() hdv.Print() hdv.Draw() c1.Modified() c1.Update() c2 = TCanvas("c2", "Angular Distribution Histogram", 200, 10, 700, 500) c2.SetGrid() hfg.Print() hfg.Draw() c2.Modified() c2.Update() c3 = TCanvas("c3", "Profile", 200, 10, 700, 500) hprof.Print() hprof.Draw() c3.Modified() c3.Update() tree.Print() tree.Write() for name in histos: exec('del %sFill' % name) del histos x = input("Enter any key to continue")
def initialize(self): from TrigEgammaDevelopments.helper import zee_etbins, default_etabins, nvtx_bins from ROOT import TH1F, TProfile import numpy as np et_bins = zee_etbins eta_bins = default_etabins for name in self._monList: self.storeSvc().mkdir(self._basepath + '/' + name + '/Efficiency') self.storeSvc().addHistogram( TH1F('et', 'E_{T} distribution;E_{T};Count', len(et_bins) - 1, np.array(et_bins))) self.storeSvc().addHistogram( TH1F('eta', '#eta distribution;#eta;Count', len(eta_bins) - 1, np.array(eta_bins))) self.storeSvc().addHistogram( TH1F("phi", "#phi distribution; #phi ; Count", 20, -3.2, 3.2)) self.storeSvc().addHistogram( TH1F('mu', '<#mu> distribution;<#mu>;Count', 16, 0, 80)) self.storeSvc().addHistogram( TH1F('nvtx', 'N_{vtx} distribution;N_{vtx};Count', len(nvtx_bins) - 1, np.array(nvtx_bins))) self.storeSvc().addHistogram( TH1F('match_et', 'E_{T} matched distribution;E_{T};Count', len(et_bins) - 1, np.array(et_bins))) self.storeSvc().addHistogram( TH1F('match_eta', '#eta matched distribution;#eta;Count', len(eta_bins) - 1, np.array(eta_bins))) self.storeSvc().addHistogram( TH1F("match_phi", "#phi matched distribution; #phi ; Count", 20, -3.2, 3.2)) self.storeSvc().addHistogram( TH1F('match_mu', '<#mu> matched distribution;<#mu>;Count', 16, 0, 80)) self.storeSvc().addHistogram( TH1F('match_nvtx', 'N_{vtx} matched distribution;N_{vtx};Count', len(nvtx_bins) - 1, np.array(nvtx_bins))) self.storeSvc().addHistogram( TProfile("eff_et", "#epsilon(E_{T}); E_{T} ; Efficiency", len(et_bins) - 1, np.array(et_bins))) self.storeSvc().addHistogram( TProfile("eff_eta", "#epsilon(#eta); #eta ; Efficiency", len(eta_bins) - 1, np.array(eta_bins))) self.storeSvc().addHistogram( TProfile("eff_phi", "#epsilon(#phi); #phi ; Efficiency", 20, -3.2, 3.2)) self.storeSvc().addHistogram( TProfile("eff_mu", "#epsilon(<#mu>); <#mu> ; Efficiency", 16, 0, 80)) self.storeSvc().addHistogram( TProfile("eff_nvtx", "#epsilon(N_{vtx}); N_{vtx} ; Efficiency", len(nvtx_bins) - 1, np.array(nvtx_bins))) self.init_lock() return StatusCode.SUCCESS
def plot_root(sample, base_name): met_pred, met_truth, met_reco, mt_pred, mt_reco = [ TH1F(n, '', 100, 0, 500) for n in ['pt_{}'.format(arguments.regressor), 'pt_truth', 'met_reco', 'mt_{}'.format(arguments.regressor), 'mt_reco']] res_pred, res_reco = [ TH1F(n, '', 100, -100, 100) for n in ['res_{}'.format(arguments.regressor), 'res_reco']] profile = TProfile('profile_pred_{}'.format(arguments.regressor), '', 100, 0, 500) map(met_pred.Fill, sample[met_pred_parameter]) map(met_truth.Fill, sample[met_truth_parameter]) map(met_reco.Fill, sample[met_reco_parameter]) map(mt_pred.Fill, sample[mt_pred_parameter]) map(mt_reco.Fill, sample[mt_reco_parameter]) map(res_pred.Fill, sample[met_pred_resolution]) map(res_reco.Fill, sample[met_reco_resolution]) map(profile.Fill, sample['pt(mc nuH)'], sample[met_pred_ratio]) root_file = TFile.Open('{}.root'.format(base_name), 'RECREATE') root_file.cd() met_pred.Write() mt_pred.Write() res_pred.Write() profile.Write() root_file.ls() root_file.Close() init_atlas_style() met_pred.SetName('Pred') met_reco.SetName('Reco') met_truth.SetName('Target') o1 = show_hists((met_pred, met_truth, met_reco), 'Missing ET', '{}_met.pdf'.format(base_name)) res_pred.SetName('Pred') res_reco.SetName('Reco') o2 = show_hists((res_pred, res_reco), 'Missing ET resolution', '{}_res.pdf'.format(base_name)) mt_pred.SetName('Pred') mt_reco.SetName('Reco') o3 = show_hists((mt_pred, mt_reco), 'Transverse mass', '{}_mt.pdf'.format(base_name)) profile.SetName('Profile') o3 = show_hists((profile,), 'Profile', '{}_profile.pdf'.format(base_name)) raw_input('Press any key...')
def bookProf(h,key=None,title='',nbinsx=100,xmin=0,xmax=1,ymin=None,ymax=None,option=""): if key==None : print 'missing key' return rkey = str(key) # in case somebody wants to use integers, or floats as keys if h.has_key(key): h[key].Reset() if ymin==None or ymax==None: h[key] = TProfile(key,title,nbinsx,xmin,xmax,option) else: h[key] = TProfile(key,title,nbinsx,xmin,xmax,ymin,ymax,option) h[key].SetDirectory(gROOT)
def initialize(self): from ROOT import TH2F, TH1F, TProfile keyWanted = ['probes','fakes'] for dirname in keyWanted: for pidname, pair in self._algDictNames.iteritems(): for etBinIdx in range( len(self._thresholdEtBins)-1 ): for etaBinIdx in range( len(self._thresholdEtaBins)-1 ): binningname = ('et%d_eta%d') % (etBinIdx,etaBinIdx) algname = pair[0] tgtname = pair[1] mumax = 100 mumin = 0 nmubins = (mumax-mumin)-1 etbins = zee_etbins etabins = default_etabins # create neural network histograms self.storeSvc().mkdir( self._basepath+'/'+dirname+'/'+pidname+'/'+algname+'/'+binningname ) self.storeSvc().addHistogram(TH2F('discriminantVsEt' , 'Et Vs discriminant' , 1000, -12, 7, len(etbins)-1 , np.array(etbins) ) ) self.storeSvc().addHistogram(TH2F('discriminantVsEta' , 'Eta Vs discriminant', 1000, -12, 7, len(etabins)-1, np.array(etabins) ) ) self.storeSvc().addHistogram(TH2F('discriminantVsNvtx', 'Offline Pileup as function of the discriminant;discriminant;nvtx;Count', \ 1000, -12,7,len(nvtx_bins)-1,np.array(nvtx_bins)) ) self.storeSvc().addHistogram(TH2F('discriminantVsMu' , 'Online Pileup as function of the discriminant;discriminant;nvtx;Count' , \ 1000, -12,7,nmubins,mumin,mumax) ) # create efficienci target histograms self.storeSvc().mkdir( self._basepath+'/'+dirname+'/'+pidname+'/'+tgtname+'/'+binningname ) self.storeSvc().addHistogram(TH1F('et','E_{T} distribution;E_{T};Count', len(etbins)-1, np.array(etbins))) self.storeSvc().addHistogram(TH1F('eta','#eta distribution;#eta;Count', len(etabins)-1, np.array(etabins))) self.storeSvc().addHistogram(TH1F("phi", "#phi distribution; #phi ; Count", 20, -3.2, 3.2)); self.storeSvc().addHistogram(TH1F('nvtx' ,'N_{vtx} distribution;N_{vtx};Count', len(nvtx_bins)-1, np.array(nvtx_bins))) self.storeSvc().addHistogram(TH1F('mu' ,'<#mu> distribution;<#mu>;Count', 16, 0, 80)) self.storeSvc().addHistogram(TH1F('match_et','E_{T} matched distribution;E_{T};Count', len(etbins)-1, np.array(etbins))) self.storeSvc().addHistogram(TH1F('match_eta','#eta matched distribution;#eta;Count', len(etabins)-1, np.array(etabins))) self.storeSvc().addHistogram(TH1F("match_phi", "#phi matched distribution; #phi ; Count", 20, -3.2, 3.2)); self.storeSvc().addHistogram(TH1F('match_nvtx' ,'N_{vtx} matched distribution;N_{vtx};Count', len(nvtx_bins)-1, np.array(nvtx_bins))) self.storeSvc().addHistogram(TH1F('match_mu' ,'<#mu> matched distribution;<#mu>;Count', 16, 0, 80)) self.storeSvc().addHistogram(TProfile("eff_et", "#epsilon(E_{T}); E_{T} ; Efficiency" , len(etbins)-1, np.array(etbins))) self.storeSvc().addHistogram(TProfile("eff_eta", "#epsilon(#eta); #eta ; Efficiency" , len(etabins)-1,np.array(etabins))) self.storeSvc().addHistogram(TProfile("eff_phi", "#epsilon(#phi); #phi ; Efficiency", 20, -3.2, 3.2)); self.storeSvc().addHistogram(TProfile("eff_nvtx", "#epsilon(N_{vtx}); N_{vtx} ; Efficiency", len(nvtx_bins)-1, np.array(nvtx_bins))); self.storeSvc().addHistogram(TProfile("eff_mu", "#epsilon(<#mu>); <#mu> ; Efficiency", 16, 0, 80)); self.init_lock() return StatusCode.SUCCESS
def createHistogram( self, title=None, profile=False ): ## Create an empty histogram for this variable with the given title # @param title the title of the new histogram # @param profile set if the histogram should be a TProfile instead # @return the new histogram title = title if title is not None else self.title name = 'h%s_%s' % ( self.name.replace(' ', '').replace('(', '').replace(')',''), uuid.uuid1() ) from ROOT import TH1D, TProfile if profile: h = TProfile( name, title, self.binning.nBins, 0., 1. ) else: h = TH1D( name, title, self.binning.nBins, 0., 1. ) self.binning.setupAxis( h.GetXaxis() ) self.applyToAxis( h.GetXaxis() ) return h
def create2dHist(varname, params, title): if "to_pt" in varname and "tagRate" in varname: h = TProfile(varname, title, 50, params["plotPtRange"][0], params["plotPtRange"][1]) h.GetXaxis().SetTitle("#tau_{vis} p_{T} [GeV]") h.GetYaxis().SetTitle("tagging efficiency") if "to_eta" in varname and "tagRate" in varname: h = TProfile(varname, title, 50, params["plotEtaRange"][0], params["plotEtaRange"][1]) h.GetXaxis().SetTitle("#tau_{vis} #eta") h.GetYaxis().SetTitle("tagging efficiency") h.Sumw2() return h
def retrieveProfile(rfile, location): from ROOT import TProfile obj = TProfile('', '', 1, 0, 1) try: rfile.GetObject(location, obj) return obj except: raise RuntimeError( "Can not retrieve the TProfile object %s from root file", location)
def get_hists(classifiers, rfile, name, marks): from ROOT import TProfile, TPolyMarker from numpy import linspace from array import array rfile = ROOT.TFile.Open(rfile) tree = rfile.Get(name) sig, bkg = 'classID=={}'.format(0), 'classID=={}'.format(1) hists = {} marks = {} if marks else None for cl in classifiers: name = '{}_{}'.format(cl, rfile.GetName().split('/', 1)[0]) nsig = float(tree.GetEntries(sig)) nbkg = float(tree.GetEntries(bkg)) # variable bin width bins = array('f', [1.0 / (-i * 0.5 - 1) + 1 for i in xrange(100)] + [1]) hist = TProfile('h_{}'.format(name), 'ROC curve ({})'.format(cl), 100, bins) hist.SetDirectory(0) # otherwise current file owns histogram if isinstance(marks, dict): xmark, ymark = array('f'), array('f') for i, cut in enumerate(linspace(-1, 1, 1001)): cutstr = '{}>{}'.format(cl, cut) eff_s = tree.GetEntries('{}&&{}'.format(sig, cutstr)) / nsig eff_b = 1 - tree.GetEntries('{}&&{}'.format(bkg, cutstr)) / nbkg hist.Fill(eff_s, eff_b) if isinstance(marks, dict): if cl == 'BDTB': window = -0.3 <= cut and cut <= 0.3 step = not i % 10 else: window = -0.9 <= cut and cut <= 0.9 step = not i % 50 if window and step: xmark.append(eff_s) ymark.append(eff_b) hists[cl] = hist if isinstance(marks, dict): marks[cl] = TPolyMarker(len(xmark), xmark, ymark) print '{}: {} marks'.format(cl, len(xmark)) for pt in zip(xmark, ymark): print pt, print return hists, marks
def pccPerLumiSection(options): """Extract PCC data from ROOT files and sort by lumisection""" c = chain(options['fileset'], options['scan']) rc = reducedChain(options['fileset'], options['scan']) name = options['name'] + '_perLS' f = openRootFileU(name) print '<<< Analyze', options['title'] histname = plotName(options['title'] + '_perLS', timestamp=False) histtitl = plotTitle() print '<<< Get Minimum' mini = int(rc.GetMinimum('LS')) print '<<< Get Maximum' maxi = int(rc.GetMaximum('LS')) print '<<< Fill Profile Histogram', histname hist = TProfile(histname, histtitl, maxi - mini + 1, mini - 0.5, maxi + 0.5) c.Draw(options['field'] + ':LS>>' + histname, '', 'goff') hist.Write('', TObject.kOverwrite) closeRootFile(f, name)
def pccPerTimeStamp(options): """Extract PCC data from ROOT files and sort by timestamps""" c = chain(options['fileset'], options['scan']) rc = chain(options['fileset'], options['scan']) name = options['name'] + '_' + options['scan'] + '_perTime' f = openRootFileU(options['name'] + '_perTime') print '<<< Analyze', options['scan'], options['name'] histname = plotName(name, timestamp=False) histtitl = plotTitle(options['scan']) print '<<< Get Minimum' mini = int(rc.GetMinimum(O['timename'][options['fileset']])) print '<<< Get Maximum' maxi = int(rc.GetMaximum(O['timename'][options['fileset']])) print '<<< Fill Profile Histogram', histname hist = TProfile(histname, histtitl, maxi - mini + 1, mini - 0.5, maxi + 0.5) c.Draw(options['field']+':'+O['timename'][options['fileset']]+'>>'+ \ histname, '', 'goff') hist.Write('', TObject.kOverwrite) closeRootFile(f, options['name'] + '_perTime')
def __init__(self, root_file_name): self.name = root_file_name self.root_file = TFile(root_file_name) tree = self.root_file.Get(tree_name) self.histograms = [] for key, value in d.iteritems(): if value[0] is "TH1D": self.histograms.append(TH1D(*value[1])) elif value[0] is "TProfile": self.histograms.append(TProfile(*value[1])) [tree.Project(key, formula[key], cuts[key]) for key in d.iterkeys()]
def FindAndIntegrateHVIs(self): T_Points = self.__members__['__T_POINTS__'] not_valid = ['PU01_AB'] for sensor_label in T_Points: time_data = T_Points[sensor_label] if sensor_label not in not_valid: # -> create dynamically TProfile object to keep i_hv vs. T curve const_temps = self.__const_temp_list__(time_data) if len(const_temps) == 0: continue first = min( map(float, const_temps) ) last = max( map(float, const_temps) ) bins = int( ((last-first) + TEMP_BIN_OFFSET) ) #name = 'IT_' + sensor_label name = sensor_label title = sensor_label #title = 'i_hv vs. T for sensor ' + sensor_label prof = TProfile(name, title, bins, first - 1.5, last + 1.5, I_HV_MIN, I_HV_MAX) if sensor_label not in self.__members__['__IT_HISTOS__']: self.__members__['__IT_HISTOS__'][sensor_label] = None self.__members__['__IT_HISTOS__'][sensor_label] = prof # -> for each const temp find and integrate hv current hvi_bank = self.__find_hvi_histo__(sensor_label) if hvi_bank == None: print ' --> Problem, hvi data not found for sensor: ', sensor_label continue ####################################################################### print ' --> Creating IT plot for sensor: ', sensor_label ####################################################################### # -> first get the pair (const_Temp, delta_t) bin_pointer = 1 time_jump = 0 for time in sorted(time_data): for temp_pair in time_data[time]: const_T = temp_pair[CONST_TEMP] delta_t = temp_pair[TIME_INTERVAL] time_in_bin = hvi_bank.GetBinCenter(bin_pointer) time_jump = time - time_in_bin bin_pointer += int(time_jump) for time_bin in range(bin_pointer, bin_pointer + delta_t): hvi = hvi_bank.GetBinContent(time_bin) if hvi: self.__members__['__IT_HISTOS__'][sensor_label].Fill(const_T, hvi) self.__members__['__IT_HISTOS__'][sensor_label].SetStats(kFALSE) self.__members__['__IT_HISTOS__'][sensor_label].SetOption("P") self.__members__['__IT_HISTOS__'][sensor_label].SetMarkerSize(0.8) self.__members__['__IT_HISTOS__'][sensor_label].GetXaxis().SetTitle('Temperature deg') self.__members__['__IT_HISTOS__'][sensor_label].GetXaxis().SetLabelSize(0.03) self.__members__['__IT_HISTOS__'][sensor_label].GetYaxis().SetTitle('HV current mA') self.__members__['__IT_HISTOS__'][sensor_label].GetYaxis().SetLabelSize(0.03)
def initialize(self): basepath = self.getProperty( "Basepath" ) doJpsiee = self.getProperty( "DoJpisee" ) sg = self.getStoreGateSvc() #et_bins = zee_etbins eta_bins = default_etabins nvtx_bins.extend(high_nvtx_bins) #eta_bins = [0,0.6,0.8,1.15,1.37,1.52,1.81,2.01,2.37,2.47] et_bins = jpsiee_etbins if doJpsiee else [4.,7.,10.,15.,20.,25.,30.,35.,40.,45.,50.,60.,80.,150.] for group in self.__groups: # Get the chain object chain = group.chain() for dirname in ( self.__triggerLevels if (type(chain) is Chain or type(chain) is TDT) else ['Selector'] ): sg.mkdir( basepath+'/'+chain.name()+'/Efficiency/'+dirname ) sg.addHistogram(TH1F('et','E_{T} distribution;E_{T};Count', len(et_bins)-1, np.array(et_bins))) sg.addHistogram(TH1F('eta','#eta distribution;#eta;Count', len(eta_bins)-1, np.array(eta_bins))) sg.addHistogram(TH1F("phi", "#phi distribution; #phi ; Count", 20, -3.2, 3.2)); sg.addHistogram(TH1F('mu' ,'<#mu> distribution;<#mu>;Count', 20, 0, 100)) sg.addHistogram(TH1F('nvtx' ,'N_{vtx} distribution;N_{vtx};Count', len(nvtx_bins)-1, np.array(nvtx_bins))) sg.addHistogram(TH1F('match_et','E_{T} matched distribution;E_{T};Count', len(et_bins)-1, np.array(et_bins))) sg.addHistogram(TH1F('match_eta','#eta matched distribution;#eta;Count', len(eta_bins)-1, np.array(eta_bins))) sg.addHistogram(TH1F("match_phi", "#phi matched distribution; #phi ; Count", 20, -3.2, 3.2)); sg.addHistogram(TH1F('match_mu' ,'<#mu> matched distribution;<#mu>;Count', 20, 0, 100)) sg.addHistogram(TH1F('match_nvtx' ,'N_{vtx} matched distribution;N_{vtx};Count', len(nvtx_bins)-1, np.array(nvtx_bins))) sg.addHistogram(TProfile("eff_et", "#epsilon(E_{T}); E_{T} ; Efficiency" , len(et_bins)-1, np.array(et_bins))) sg.addHistogram(TProfile("eff_eta", "#epsilon(#eta); #eta ; Efficiency" , len(eta_bins)-1,np.array(eta_bins))) sg.addHistogram(TProfile("eff_phi", "#epsilon(#phi); #phi ; Efficiency", 20, -3.2, 3.2)); sg.addHistogram(TProfile("eff_mu", "#epsilon(<#mu>); <#mu> ; Efficiency", 20, 0, 100)); sg.addHistogram(TProfile("eff_nvtx", "#epsilon(N_{vtx}); N_{vtx} ; Efficiency", len(nvtx_bins)-1, np.array(nvtx_bins))); sg.addHistogram( TH2F('match_etVsEta', "Passed;E_{T};#eta;Count", len(et_bins)-1, np.array(et_bins), len(eta_bins)-1, np.array(eta_bins)) ) sg.addHistogram( TH2F('etVsEta' , "Total;E_{T};#eta;Count", len(et_bins)-1, np.array(et_bins), len(eta_bins)-1, np.array(eta_bins)) ) sg.addHistogram( TProfile2D('eff_etVsEta' , "Total;E_{T};#eta;Count", len(et_bins)-1, np.array(et_bins), len(eta_bins)-1, np.array(eta_bins)) ) self.init_lock() return StatusCode.SUCCESS
def create_residual(data, model, nbins=None, calcphi=None, skipzero=False): """Create angular residual histogram.""" if nbins is None: nbins = data.GetXaxis().GetNbins() if calcphi is None: calcphi = lambda x, y: atan(x / y) data.SetBinErrorOption(kPoisson) res = TProfile('angularRes', '', nbins, -0.5 * pi, 0.5 * pi) for xbin in range(data.GetXaxis().GetNbins()): for ybin in range(data.GetYaxis().GetNbins()): d = data.GetBinContent(xbin + 1, ybin + 1) if skipzero and d == 0.0: continue m = model.GetBinContent(xbin + 1, ybin + 1) if m < d: e = data.GetBinErrorLow(xbin + 1, ybin + 1) else: e = data.GetBinErrorUp(xbin + 1, ybin + 1) x = data.GetXaxis().GetBinCenter(xbin + 1) y = data.GetYaxis().GetBinCenter(ybin + 1) res.Fill(calcphi(x, y), (d - m) / e) return res
def plotting_init(data, trainvar, histo_dict, masses, weights='totalWeight'): """ Initializes the plotting Parameters: ----------- data : pandas DataFrame Data to be used for creating the TProfiles trainvar : str Name of the training variable. histo_dict : dict Dictionary containing the info for plotting for a given trainvar masses : list List of masses to be used [weights='totalWeight'] : str What column to be used for weight in the data. Returns: -------- canvas : ROOT.TCanvas instance canvas to be plotted on profile : ROOT.TProfile instance profile for the fitting """ canvas = TCanvas('canvas', 'TProfile plot', 200, 10, 700, 500) canvas.GetFrame().SetBorderSize(6) canvas.GetFrame().SetBorderMode(-1) signal_data = data.loc[data['target'] == 1] gen_mHH_values = np.array(signal_data['gen_mHH'].values, dtype=np.float) trainvar_values = np.array(signal_data[trainvar].values, dtype=np.float) weights = np.array(signal_data[weights].values, dtype=np.float) sanity_check = len(gen_mHH_values) == len(trainvar_values) == len(weights) assert sanity_check title = 'Profile of ' + str(trainvar) + ' vs gen_mHH' num_bins = (len(masses) - 1) xlow = masses[0] xhigh = (masses[(len(masses) - 1)] + 100.0) ylow = histo_dict["min"] yhigh = histo_dict["max"] profile = TProfile('profile', title, num_bins, xlow, xhigh, ylow, yhigh) mass_bins = np.array(masses, dtype=float) profile.SetBins((len(mass_bins) - 1), mass_bins) profile.GetXaxis().SetTitle("gen_mHH (GeV)") profile.GetYaxis().SetTitle(str(trainvar)) for x, y, w in zip(gen_mHH_values, trainvar_values, weights): profile.Fill(x, y, w) profile.Draw() canvas.Modified() canvas.Update() return canvas, profile
def createProfile(t_corrList, t_select, l_histoList, nBins, dBins): d_profileBin = {} h_str, tFile, c_x, c_y, xMin, xMax, yMin, yMax, varBins = l_histoList PythonUtils.Info(' CREATING PROFILES: ' + h_str + ' ') for bin in t_select: PythonUtils.Info('Creating Profiles: ' + h_str + ' in bin: ' + bin[0] + ' -> ' + bin[1]) d_profile = {} for i in range(len(t_corrList)): dName = h_str + '_' + bin[0] + '_' + bin[1] + '_' + t_corrList[i][0] d_profile[dName] = TProfile(dName, dName, int(nBins), dBins, float(yMin), float(yMax)) d_profileBin[bin[0] + bin[1]] = d_profile return d_profileBin
def test_fill_profile(): np.random.seed(0) w1D = np.empty(1E6) w1D.fill(2.) data1D = np.random.randn(1E6, 2) data2D = np.random.randn(1E6, 3) data3D = np.random.randn(1E4, 4) a = TProfile('th1d', 'test', 1000, -5, 5) rnp.fill_profile(a, data1D) assert_true(a.Integral() !=0) a_w = TProfile('th1dw', 'test', 1000, -5, 5) rnp.fill_profile(a_w, data1D, w1D) assert_true(a_w.Integral() != 0) assert_equal(a_w.Integral(), a.Integral()) b = TProfile2D('th2d', 'test', 100, -5, 5, 100, -5, 5) rnp.fill_profile(b, data2D) assert_true(b.Integral() != 0) c = TProfile3D('th3d', 'test', 10, -5, 5, 10, -5, 5, 10, -5, 5) rnp.fill_profile(c, data3D) assert_true(c.Integral() != 0) # array and weights lengths do not match assert_raises(ValueError, rnp.fill_profile, c, data3D, np.ones(10)) # weights is not 1D assert_raises(ValueError, rnp.fill_profile, c, data3D, np.ones((data3D.shape[0], 1))) # array is not 2D assert_raises(ValueError, rnp.fill_profile, c, np.ones(10)) # length of second axis is not one more than dimensionality of the profile for h in (a, b, c): assert_raises(ValueError, rnp.fill_profile, h, np.random.randn(1E4, 5)) # wrong type assert_raises(TypeError, rnp.fill_profile, TH1D("test", "test", 1, 0, 1), data1D)
def dqm_getSingleHist_json(server, run, dataset, hist, rootContent=False): postfix = "?rootcontent=1" if rootContent else "" datareq = urllib2.Request(('%s/jsonfairy/archive/%s/%s/%s%s') % (server, run, dataset, hist, postfix)) datareq.add_header('User-agent', ident) # Get data data = eval(re.sub(r"\bnan\b", "0", urllib2.build_opener(X509CertOpen()).open(datareq).read()), { "__builtins__": None }, {}) histo = data['hist'] # Now convert into real ROOT histogram object if 'TH1' in histo['type']: # The following assumes a TH1F object contents = histo['bins']['content'] nbins = len(contents) xmin = histo['xaxis']['first']['value'] xmax = histo['xaxis']['last']['value'] roothist = TH1F(histo['stats']['name'],histo['title'],nbins,xmin,xmax) for xx in range(1,nbins+1): roothist.SetBinContent(xx, contents[xx-1]) roothist.SetBinError(xx, histo['bins']['error'][xx-1]) roothist.SetEntries(histo['stats']['entries']) stats=array('d') stats.append(histo['stats']['entries']) stats.append(histo['stats']['entries']) stats.append(histo['stats']['entries']*histo['stats']['mean']['X']['value']) stats.append((histo['stats']['rms']['X']['value']*histo['stats']['rms']['X']['value']+histo['stats']['mean']['X']['value']*histo['stats']['mean']['X']['value'])*histo['stats']['entries']) roothist.PutStats(stats) elif(histo['type']=='TProfile'): contents = histo['bins']['content'] nbins = len(contents) xmin = histo['xaxis']['first']['value'] xmax = histo['xaxis']['last']['value'] roothist = TProfile(histo['stats']['name'],histo['title'],nbins,xmin,xmax) roothist.SetErrorOption("g") for xx in range(0,nbins): if(histo['bins']['error'][xx]!=0): ww=1./(histo['bins']['error'][xx]*histo['bins']['error'][xx]) else: ww=0. roothist.Fill(xmin+(2*xx+1)*((xmax-xmin)/(nbins*2.0)), contents[xx],ww) # roothist.SetBinContent(xx, contents[xx-1]) # roothist.SetBinError(xx, histo['bins']['error'][xx-1]) roothist.SetEntries(histo['stats']['entries']) stats=array('d') for i in range(0,6): stats.append(i) roothist.GetStats(stats) stats[0]=(histo['stats']['entries']) stats[1]=(histo['stats']['entries']) stats[2]=(histo['stats']['entries']*histo['stats']['mean']['X']['value']) stats[3]=((histo['stats']['rms']['X']['value']*histo['stats']['rms']['X']['value']+histo['stats']['mean']['X']['value']*histo['stats']['mean']['X']['value'])*histo['stats']['entries']) roothist.PutStats(stats) elif 'TH2' in histo['type']: contents = histo['bins']['content'] nbinsx = histo['xaxis']['last']['id'] xmin = histo['xaxis']['first']['value'] xmax = histo['xaxis']['last']['value'] nbinsy = histo['yaxis']['last']['id'] ymin = histo['yaxis']['first']['value'] ymax = histo['yaxis']['last']['value'] roothist = TH2F(histo['stats']['name'],histo['title'],nbinsx,xmin,xmax,nbinsy,ymin,ymax) for xx in range(1,nbinsx+1): for yy in range(1,nbinsy+1): roothist.SetBinContent(xx,yy, contents[yy-1][xx-1]) roothist.SetEntries(histo['stats']['entries']) stats=array('d') stats.append(histo['stats']['entries']) stats.append(histo['stats']['entries']) stats.append(histo['stats']['entries']*histo['stats']['mean']['X']['value']) stats.append((histo['stats']['rms']['X']['value']*histo['stats']['rms']['X']['value']+histo['stats']['mean']['X']['value']*histo['stats']['mean']['X']['value'])*histo['stats']['entries']) stats.append(histo['stats']['entries']*histo['stats']['mean']['Y']['value']) stats.append((histo['stats']['rms']['Y']['value']*histo['stats']['rms']['Y']['value']+histo['stats']['mean']['Y']['value']*histo['stats']['mean']['Y']['value'])*histo['stats']['entries']) roothist.PutStats(stats) elif(histo['type']=='TProfile2D'): contents = histo['bins']['content'] nbinsx = histo['xaxis']['last']['id'] xmin = histo['xaxis']['first']['value'] xmax = histo['xaxis']['last']['value'] nbinsy = histo['yaxis']['last']['id'] ymin = histo['yaxis']['first']['value'] ymax = histo['yaxis']['last']['value'] roothist = TProfile2D(histo['stats']['name'],histo['title'],nbinsx,xmin,xmax,nbinsy,ymin,ymax) for xx in range(0,nbinsx): for yy in range(0,nbinsy): roothist.Fill(xmin+(2*xx+1)*((xmax-xmin)/(nbinsx*2.0)),ymin+(2*yy+1)*((ymax-ymin)/(nbinsy*2.0)),0,1) for xx in range(1,nbinsx+1): for yy in range(1,nbinsy+1): roothist.SetBinContent(xx,yy, contents[yy-1][xx-1]) roothist.SetEntries(histo['stats']['entries']) return roothist
def generator(nuslice_tree, rootfile, pset): n_bins = pset.n_bins drift_distance = pset.DriftDistance bin_width = drift_distance/n_bins half_bin_width = bin_width/2. xvals = np.arange(half_bin_width, drift_distance, bin_width) xerrs = np.array([half_bin_width] * len(xvals)) dist_to_anode_bins = n_bins dist_to_anode_low = 0. dist_to_anode_up = drift_distance profile_bins = n_bins profile_option = 's' # errors are the standard deviation dy_spreads = [None] * n_bins dy_means = [None] * n_bins dy_hist = TH2D("dy_hist", "#Delta y", dist_to_anode_bins, dist_to_anode_low, dist_to_anode_up, pset.dy_bins, pset.dy_low, pset.dy_up) dy_hist.GetXaxis().SetTitle("distance from anode (cm)") dy_hist.GetYaxis().SetTitle("y_flash - y_TPC (cm)") dy_prof = TProfile("dy_prof", "Profile of dy_spreads in #Delta y", profile_bins, dist_to_anode_low, dist_to_anode_up, pset.dy_low*2, pset.dy_up*2, profile_option) dy_prof.GetXaxis().SetTitle("distance from anode (cm)") dy_prof.GetYaxis().SetTitle("y_flash - y_TPC (cm)") dy_h1 = TH1D("dy_h1", "", profile_bins, dist_to_anode_low, dist_to_anode_up) dy_h1.GetXaxis().SetTitle("distance from anode (cm)") dy_h1.GetYaxis().SetTitle("y_flash - y_TPC (cm)") dz_spreads = [None] * n_bins dz_means = [None] * n_bins dz_hist = TH2D("dz_hist", "#Delta z", dist_to_anode_bins, dist_to_anode_low, dist_to_anode_up, pset.dz_bins, pset.dz_low, pset.dz_up) dz_hist.GetXaxis().SetTitle("distance from anode (cm)") dz_hist.GetYaxis().SetTitle("z_flash - z_TPC (cm)") dz_prof = TProfile("dz_prof", "Profile of dz_spreads in #Delta z", profile_bins, dist_to_anode_low, dist_to_anode_up, pset.dz_low*2.5, pset.dz_up*2.5, profile_option) dz_prof.GetXaxis().SetTitle("distance from anode (cm)") dz_prof.GetYaxis().SetTitle("z_flash - z_TPC (cm)") dz_h1 = TH1D("dz_h1", "", profile_bins, dist_to_anode_low, dist_to_anode_up) dz_h1.GetXaxis().SetTitle("distance from anode (cm)") dz_h1.GetYaxis().SetTitle("z_flash - z_TPC (cm)") rr_spreads = [None] * n_bins rr_means = [None] * n_bins rr_hist = TH2D("rr_hist", "PE Spread", dist_to_anode_bins, dist_to_anode_low, dist_to_anode_up, pset.rr_bins, pset.rr_low, pset.rr_up) rr_hist.GetXaxis().SetTitle("distance from anode (cm)") rr_hist.GetYaxis().SetTitle("RMS flash (cm)") rr_prof = TProfile("rr_prof", "Profile of PE Spread", profile_bins, dist_to_anode_low, dist_to_anode_up, pset.rr_low, pset.rr_up, profile_option) rr_prof.GetXaxis().SetTitle("distance from anode (cm)") rr_prof.GetYaxis().SetTitle("RMS flash (cm)") rr_h1 = TH1D("rr_h1", "", profile_bins, dist_to_anode_low, dist_to_anode_up) rr_h1.GetXaxis().SetTitle("distance from anode (cm)") rr_h1.GetYaxis().SetTitle("RMS flash (cm)") if detector == "sbnd": pe_spreads = [None] * n_bins pe_means = [None] * n_bins pe_hist = TH2D("pe_hist", "Uncoated/Coated Ratio", dist_to_anode_bins, dist_to_anode_low, dist_to_anode_up, pset.pe_bins, pset.pe_low, pset.pe_up) pe_hist.GetXaxis().SetTitle("distance from anode (cm)") pe_hist.GetYaxis().SetTitle("ratio_{uncoated/coated}") pe_prof = TProfile("pe_prof", "Profile of Uncoated/Coated Ratio", profile_bins, dist_to_anode_low, dist_to_anode_up, pset.pe_low, pset.pe_up, profile_option) pe_prof.GetXaxis().SetTitle("distance from anode (cm)") pe_prof.GetYaxis().SetTitle("ratio_{uncoated/coated}") pe_h1 = TH1D("pe_h1", "", profile_bins, dist_to_anode_low, dist_to_anode_up) pe_h1.GetXaxis().SetTitle("distance from anode (cm)") pe_h1.GetYaxis().SetTitle("ratio_{uncoated/coated}") match_score_scatter = TH2D("match_score_scatter", "Scatter plot of match scores", dist_to_anode_bins, dist_to_anode_low, dist_to_anode_up, pset.score_hist_bins, pset.score_hist_low, pset.score_hist_up*(3./5.)) match_score_scatter.GetXaxis().SetTitle("distance from anode (cm)") match_score_scatter.GetYaxis().SetTitle("match score (arbitrary)") match_score_hist = TH1D("match_score", "Match Score", pset.score_hist_bins, pset.score_hist_low, pset.score_hist_up) match_score_hist.GetXaxis().SetTitle("match score (arbitrary)") for e in nuslice_tree: slice = e.charge_x dy_hist.Fill(slice, e.flash_y - e.charge_y) dy_prof.Fill(slice, e.flash_y - e.charge_y) dz_hist.Fill(slice, e.flash_z - e.charge_z) dz_prof.Fill(slice, e.flash_z - e.charge_z) rr_hist.Fill(slice, e.flash_r) rr_prof.Fill(slice, e.flash_r) if detector == "sbnd": pe_hist.Fill(slice, e.flash_ratio) pe_prof.Fill(slice, e.flash_ratio) # fill histograms for match score calculation from profile histograms for ib in list(range(0, profile_bins)): ibp = ib + 1 dy_h1.SetBinContent(ibp, dy_prof.GetBinContent(ibp)) dy_h1.SetBinError(ibp, dy_prof.GetBinError(ibp)) dy_means[int(ib)] = dy_prof.GetBinContent(ibp) dy_spreads[int(ib)] = dy_prof.GetBinError(ibp) dz_h1.SetBinContent(ibp, dz_prof.GetBinContent(ibp)) dz_h1.SetBinError(ibp, dz_prof.GetBinError(ibp)) dz_means[int(ib)] = dz_prof.GetBinContent(ibp) dz_spreads[int(ib)] = dz_prof.GetBinError(ibp) rr_h1.SetBinContent(ibp, rr_prof.GetBinContent(ibp)) rr_h1.SetBinError(ibp, rr_prof.GetBinError(ibp)) rr_means[int(ib)] = rr_prof.GetBinContent(ibp) rr_spreads[int(ib)] = rr_prof.GetBinError(ibp) if detector == "sbnd": pe_h1.SetBinContent(ibp, pe_prof.GetBinContent(ibp)) pe_h1.SetBinError(ibp, pe_prof.GetBinError(ibp)) pe_means[int(ib)] = pe_prof.GetBinContent(ibp) pe_spreads[int(ib)] = pe_prof.GetBinError(ibp) for e in nuslice_tree: slice = e.charge_x # calculate match score isl = int(slice/bin_width) score = 0. if dy_spreads[isl] <= 1.e-8: print("Warning zero spread.\n", f"slice: {slice}. isl: {isl}. dy_spreads[isl]: {dy_spreads[isl]} ") dy_spreads[isl] = dy_spreads[isl+1] if dz_spreads[isl] <= 1.e-8: print("Warning zero spread.\n", f"slice: {slice}. isl: {isl}. dz_spreads[isl]: {dz_spreads[isl]} ") dz_spreads[isl] = dz_spreads[isl+1] if rr_spreads[isl] <= 1.e-8: print("Warning zero spread.\n", f"slice: {slice}. isl: {isl}. rr_spreads[isl]: {rr_spreads[isl]} ") rr_spreads[isl] = rr_spreads[isl+1] if detector == "sbnd" and pe_spreads[isl] <= 1.e-8: print("Warning zero spread.\n", f"slice: {slice}. isl: {isl}. pe_spreads[isl]: {pe_spreads[isl]} ") pe_spreads[isl] = pe_spreads[isl+1] score += abs(abs(e.flash_y-e.charge_y) - dy_means[isl])/dy_spreads[isl] score += abs(abs(e.flash_z-e.charge_z) - dz_means[isl])/dz_spreads[isl] score += abs(e.flash_r-rr_means[isl])/rr_spreads[isl] if detector == "sbnd" and pset.UseUncoatedPMT: score += abs(e.flash_ratio-pe_means[isl])/pe_spreads[isl] match_score_scatter.Fill(slice, score) match_score_hist.Fill(score) metrics_filename = 'fm_metrics_' + detector + '.root' hfile = gROOT.FindObject(metrics_filename) if hfile: hfile.Close() hfile = TFile(metrics_filename, 'RECREATE', 'Simple flash matching metrics for ' + detector.upper()) dy_hist.Write() dy_prof.Write() dy_h1.Write() dz_hist.Write() dz_prof.Write() dz_h1.Write() rr_hist.Write() rr_prof.Write() rr_h1.Write() if detector == "sbnd": pe_hist.Write() pe_prof.Write() pe_h1.Write() match_score_scatter.Write() match_score_hist.Write() hfile.Close() canv = TCanvas("canv") dy_hist.Draw() crosses = TGraphErrors(n_bins, array('f', xvals), array('f', dy_means), array('f', xerrs), array('f', dy_spreads)) crosses.SetLineColor(9) crosses.SetLineWidth(3) crosses.Draw("Psame") canv.Print("dy.pdf") canv.Update() dz_hist.Draw() crosses = TGraphErrors(n_bins, array('f', xvals), array('f', dz_means), array('f', xerrs), array('f', dz_spreads)) crosses.SetLineColor(9) crosses.SetLineWidth(3) crosses.Draw("Psame") canv.Print("dz.pdf") canv.Update() rr_hist.Draw() crosses = TGraphErrors(n_bins, array('f', xvals), array('f', rr_means), array('f', xerrs), array('f', rr_spreads)) crosses.SetLineColor(9) crosses.SetLineWidth(3) crosses.Draw("Psame") canv.Print("rr.pdf") canv.Update() if detector == "sbnd": pe_hist.Draw() crosses = TGraphErrors(n_bins, array('f', xvals), array('f', pe_means), array('f', xerrs), array('f', pe_spreads)) crosses.SetLineColor(9) crosses.SetLineWidth(3) crosses.Draw("Psame") canv.Print("pe.pdf") canv.Update() match_score_scatter.Draw() canv.Print("match_score_scatter.pdf") canv.Update() match_score_hist.Draw() canv.Print("match_score.pdf") canv.Update() sleep(20)
def plotPulls(optunf="Bayes", ntest=10, leff=True, loufl=False, optfun="exp", opttfun="", gmean=-1.0, nrebin=4): if opttfun == "": opttfun = optfun if optfun == "blobel": gmean = 0.0 funttxt, funtxt = funtxts(opttfun, optfun, leff, loufl) global histos, canv, canv2 histos = [] canv = TCanvas("canv", "thruth vs reco pulls", 600, 800) canv.Divide(1, 3) canv2 = TCanvas("canv2", "P(chi^2)", 600, 800) canv2.Divide(2, 3) if optunf == "BasisSplines": bininfo = BinInfo(nrebin) unfoldtester = UnfoldTester(optunf, nrebin) else: bininfo = BinInfo() unfoldtester = UnfoldTester(optunf) trainer = Trainer(bininfo, opttfun, optfun) tester = Tester(bininfo, optfun) hbininfo = bininfo.create(optfun) dx = hbininfo["mhi"] for sigma, ipad in [[0.01 * dx, 1], [0.03 * dx, 2], [0.1 * dx, 3]]: txt = optunf + ", smear mu, s.d.= " + str(gmean) + ", " + str( sigma) + ", train: " + funttxt + ", test: " + funtxt + ", " + str( ntest) + " tests" hPulls = TProfile("pulls", txt, hbininfo["tbins"], hbininfo["tlo"], hbininfo["thi"]) hPulls.SetErrorOption("s") hPulls.SetYTitle("Thruth reco pull") histos.append(hPulls) hChisq = TH1D("chisq", "P(chi^2) rec " + txt, 10, 0.0, 1.0) hChisqm = TH1D("chisqm", "P(chi^2) mea " + txt, 10, 0.0, 1.0) histos.append(hChisq) histos.append(hChisqm) measurement = createMeasurement(gmean, sigma, leff, optfun) response = trainer.train(measurement, loufl=loufl) for itest in range(ntest): print "Test", itest unfold, hTrue, hMeas = unfoldtester.rununfoldtest( tester, measurement, response) unfold.PrintTable(cout, hTrue, 2) hReco = unfold.Hreco(2) nbin = hReco.GetNbinsX() if hbininfo["nrebin"] > 1: hTrue = hTrue.Rebin(nrebin) for ibin in range(nbin + 1): truevalue = hTrue.GetBinContent(ibin) recvalue = hReco.GetBinContent(ibin) error = hReco.GetBinError(ibin) if error > 0.0: pull = (recvalue - truevalue) / error hPulls.Fill(hReco.GetBinCenter(ibin), pull) chisq = unfold.Chi2(hTrue, 2) hChisq.Fill(TMath.Prob(chisq, hTrue.GetNbinsX())) chisqm = unfold.Chi2measured() pchisqm = TMath.Prob(chisqm, hMeas.GetNbinsX() - hReco.GetNbinsX()) print "Chisq measured=", chisqm, "P(chi^2)=", pchisqm hChisqm.Fill(pchisqm) canv.cd(ipad) gStyle.SetErrorX(0) hPulls.SetMinimum(-3.0) hPulls.SetMaximum(3.0) hPulls.SetMarkerSize(1.0) hPulls.SetMarkerStyle(20) hPulls.SetStats(False) hPulls.Draw() canv2.cd(ipad * 2 - 1) hChisq.Draw() canv2.cd(ipad * 2) hChisqm.Draw() fname = "RooUnfoldTestPulls_" + optunf + "_" + opttfun + "_" + optfun if loufl: fname += "_oufl" canv.Print(fname + ".pdf") fname = "RooUnfoldTestChisq_" + optunf + "_" + opttfun + "_" + optfun if loufl: fname += "_oufl" canv2.Print(fname + ".pdf") return
diffProf = [] inHists = [] inProf = [] for itarg in range(target.shape[1]): hist = TH1F('diff{}'.format(itarg), 'T_{{{0}}}-O_{{{0}}}'.format(itarg), 100,meanDiff[itarg]-3*stdDiff[itarg],meanDiff[itarg]+3*stdDiff[itarg]) diffHists.append(hist) hist = TH2F('vs{}'.format(itarg), 'O_{{{0}}} vs T_{{{0}}}'.format(itarg), 400,minTarget[itarg],maxTarget[itarg], 400,minOutput[itarg],maxOutput[itarg]) vsHists.append(hist) hist = TProfile('prof{}'.format(itarg), 'Prof(O_{{{0}}}) vs T_{{{0}}}'.format(itarg), 400,minTarget[itarg],maxTarget[itarg]) diffProf.append(hist) hist = TH2F('input{}'.format(itarg), 'O_{{{0}}} vs I_{{{0}}}'.format(itarg), 400,minInput[itarg],maxInput[itarg], 400,minOutput[itarg],maxOutput[itarg]) inHists.append(hist) hist = TProfile('inProf{}'.format(itarg), 'Prof(O_{{{0}}}) vs I_{{{0}}}'.format(itarg), 400,minInput[itarg],maxInput[itarg]) inProf.append(hist) # Filling the old fashioned way... for irow in range(diff.shape[0]): for ivar in range(diff.shape[1]):
#!/usr/bin/env python # coding: utf-8 # In[1]: from ROOT import TCanvas, TFile, TProfile, TNtuple, TH1F, TH2F from ROOT import gROOT, gBenchmark, gRandom, gSystem from array import array # In[2]: hfile = gROOT.FindObject('py-hsimple.root') if hfile: hfile.Close() hfile = TFile('py-hsimple.root', 'RECREATE', 'Demo ROOT file with histograms') # In[3]: hpx = TH1F('hpx', 'This is the px distribution', 100, -4, 4) hpxpy = TH2F('hpxpy', 'py vs px', 40, -4, 4, 40, -4, 4) hprof = TProfile('hprof', 'Profile of pz versus px', 100, -4, 4, 0, 20) ntuple = TNtuple('ntuple', 'Demo ntuple', 'px:py:pz:random:i') # In[ ]: # In[4]: gRandom.SetSeed() rannor, rndm = gRandom.Rannor, gRandom.Rndm # In[5]: _px = array('d', [0]) _py = array('d', [0]) for i in range(25000): # Generate random values. rannor(_px, _py) px, py = _px[0], _py[0] pz = px * px + py * py random = rndm(1) # Fill histograms.
# control histograms if (args.forest_type == 'Lya'): forest_inf = 1040. forest_sup = 1200. elif (args.forest_type == 'SiIV'): forest_inf = 1270. forest_sup = 1380. elif (args.forest_type == 'CIV'): forest_inf = 1410. forest_sup = 1520. hdelta = TProfile2D('hdelta', 'delta mean as a function of lambda-lambdaRF', 36, 3600., 7200., 16, forest_inf, forest_sup, -5.0, 5.0) hdelta_RF = TProfile('hdelta_RF', 'delta mean as a function of lambdaRF', 320, forest_inf, forest_sup, -5.0, 5.0) hdelta_OBS = TProfile('hdelta_OBS', 'delta mean as a function of lambdaOBS', 1800, 3600., 7200., -5.0, 5.0) hdelta_RF_we = TProfile( 'hdelta_RF_we', 'delta mean weighted as a function of lambdaRF', 320, forest_inf, forest_sup, -5.0, 5.0) hdelta_OBS_we = TProfile( 'hdelta_OBS_we', 'delta mean weighted as a function of lambdaOBS', 1800, 3600., 7200., -5.0, 5.0) hivar = TH1D('hivar', ' ivar ', 10000, 0.0, 10000.) hsnr = TH1D('hsnr', ' snr per pixel ', 100, 0.0, 100.) hdelta_RF_we.Sumw2() hdelta_OBS_we.Sumw2()
c1.GetFrame().SetBorderMode(-1) # Create a new ROOT binary machine independent file. # Note that this file may contain any kind of ROOT objects, histograms, # pictures, graphics objects, detector geometries, tracks, events, etc.. # This file is now becoming the current directory. hfile = gROOT.FindObject('hsimple.root') if hfile: hfile.Close() hfile = TFile('hsimple.root', 'RECREATE', 'Demo ROOT file with histograms') # Create some histograms, a profile histogram and an ntuple hpx = TH1F('hpx', 'This is the px distribution', 100, -4, 4) hpxpy = TH2F('hpxpy', 'py vs px', 40, -4, 4, 40, -4, 4) hprof = TProfile('hprof', 'Profile of pz versus px', 100, -4, 4, 0, 20) ntuple = TNtuple('ntuple', 'Demo ntuple', 'px:py:pz:random:i') # Set canvas/frame attributes. hpx.SetFillColor(48) gBenchmark.Start('hsimple') # Initialize random number generator. gRandom.SetSeed() gauss, rndm = gRandom.Gaus, gRandom.Rndm # For speed, bind and cache the Fill member functions, histos = ['hpx', 'hpxpy', 'hprof', 'ntuple'] for name in histos: exec '%sFill = %s.Fill' % (name, name)
data_chain = TChain('events') data_list = open(args.inFile, 'r') data_files = data_list.readlines() for i in data_files: data_chain.Add(i.strip()) outfile = TFile(args.outFile, "recreate") # Book histos # we want to make 15 pt bins covering the range 20 - 500 (spacing of 480/15 = 32 GeV) n_bins = 99 x_low = 5 x_high = 500 pt_prof = TProfile("ptprof", "profile of deltapt versus pt", n_bins, x_low, x_high, 0, 1) tau32_prof = TProfile("tau32prof", "profile of tau32 vs. jet pt", n_bins, x_low, x_high, 0, 1) tau31_prof = TProfile("tau31prof", "profile of tau31 vs. jet pt", n_bins, x_low, x_high, 0, 1) tau21_prof = TProfile("tau21prof", "profile of tau21 vs. jet pt", n_bins, x_low, x_high, 0, 1) nevts = data_chain.GetEntries() for i in range(nevts): data_chain.GetEntry(i) hlt_n_jets = data_chain.jet_num fj_n_jets = data_chain.fj_jet_num n_jets = min(hlt_n_jets, fj_n_jets)
#create branch addresses for reading data off of root files pchannel, sample0, sample1, sample2, sample3, sample4, sample5 = (array( 'd', [0]), ) * 7 nbytes = 0 #create list of TProfiles prof0 = [None] * len(fn) prof1 = [None] * len(fn) prof2 = [None] * len(fn) prof3 = [None] * len(fn) prof4 = [None] * len(fn) prof5 = [None] * len(fn) for i in range(len(fn)): prof0[i] = TProfile("hprof0_" + str(i), "sample0", 640, 0, 640, 3500, 7000, "s") prof1[i] = TProfile("hprof1_" + str(i), "sample1", 640, 0, 640, 3500, 7000, "s") prof2[i] = TProfile("hprof2_" + str(i), "sample2", 640, 0, 640, 3500, 7000, "s") prof3[i] = TProfile("hprof3_" + str(i), "sample3", 640, 0, 640, 3500, 7000, "s") prof4[i] = TProfile("hprof4_" + str(i), "sample4", 640, 0, 640, 3500, 7000, "s") prof5[i] = TProfile("hprof5_" + str(i), "sample5", 640, 0, 640, 3500, 7000, "s") #create list of error histograms for normalization hsig0 = [None] * len(fn) hsig1 = [None] * len(fn) hsig2 = [None] * len(fn)