def test_base_adder_neg(self): wave_neg = vector('short')(10,-1000) wave_max = vector('short')(10,32767) self.rda.AddRawDigits(self.wave1,wave_neg) self.assertEqual(wave_neg.size(),10) self.assertEqual(wave_neg,wave_max) self.assertEqual(self.orig_wave1,self.wave1)
def draw_pulse(): #draw a single pulse of photoelectrons using the hits for a given event ievt = 7 cell = "03x03" #tree.Print() #get the hits from the tree hitTime = std.vector(float)() hitNphot = std.vector(int)() tree.SetBranchAddress("phot_"+cell+"_OpDet_hits_time", hitTime) tree.SetBranchAddress("phot_"+cell+"_OpDet_hits_nphot", hitNphot) tree.GetEntry(ievt) nhits = hitTime.size() can = ut.box_canvas() gHits = TGraph(nhits) for i in xrange(nhits): gHits.SetPoint(i, hitTime.at(i), hitNphot.at(i)) gHits.Draw("A*l") ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
def main(): #open the input inp = TFile.Open("../../data/lmon.root") tree = inp.Get("DetectorTree") #get the branches for MC particle pdg = std.vector(int)() px = std.vector(float)() py = std.vector(float)() pz = std.vector(float)() en = std.vector(float)() tree.SetBranchAddress("gen_pdg", pdg) tree.SetBranchAddress("gen_px", px) tree.SetBranchAddress("gen_py", py) tree.SetBranchAddress("gen_pz", pz) tree.SetBranchAddress("gen_en", en) ievt = 2 # event number to read #load the event tree.GetEntry(ievt) #loop over MC particles, all vectors are of the same size for i in xrange(pdg.size()): print i, pdg.at(i), px.at(i), py.at(i), pz.at(i), en.at(i)
def load_croppedset_sparse_dualflow_nomc(io, producer="croppedadc", threshold=10.0): # get crop set ev_crops = io.get_data(larcv.kProductImage2D, producer) crop_v = ev_crops.Image2DArray() ncrops = crop_v.size() nsets = ncrops / 3 print "Number of sets=", nsets, " ncrops=", ncrops thresh_v = std.vector('float')(3, threshold) cuton_v = std.vector('int')(3, 1) # we are making a batch. collect the sparse arrays data = {"pixadc": []} for iset in xrange(nsets): # get instance, convert to numpy array, nfeatures per flow sparsedata = larcv.SparseImage(crop_v, iset * 3, iset * 3 + 2, thresh_v, cuton_v) sparse_np = larcv.as_ndarray(sparsedata, larcv.msg.kNORMAL) data["pixadc"].append(sparse_np) #print "nfeatures: ",nfeatures return data
def __init__(self,readname=None,writename=None,ttreetype='F',inival=-900.,size='1') : self.__readname=readname self.__writename=writename self.__ttreetype=ttreetype self.__inival = inival if (self.__ttreetype=='I' or self.__ttreetype=='i') and self.__inival==-900. : self.__inival=0 self.__size = size #figure out the array type self.__arraytype = get_array_type(ttreetype) #figure out the array length self.__arraylength = get_array_length(size) #Set the array to read into if readname!=None : if ttreetype!='vi' : if self.__arraylength>1 : self.__readArray = array(self.__arraytype,self.__arraylength*[self.__inival]) else : self.__readArray = array(self.__arraytype,[self.__inival]) else : self.__readArray = std.vector(std.vector('int'))() #Set the array to write into if writename!=None : #If we're just copying over, use the same array to read and write if readname!=None : self.__writeArray = self.__readArray elif self.__arraylength>1 : self.__writeArray = array(self.__arraytype,self.__arraylength*[self.__inival]) else : self.__writeArray = array(self.__arraytype,[self.__inival])
def test03NamespaceInTemplates( self ): """Templated data members need to retain namespaces of arguments""" PR_NS_A = ROOT.PR_NS_A p = std.pair( std.vector( PR_NS_A.PR_ST_B ), std.vector( PR_NS_A.PR_NS_D.PR_ST_E ) )() self.assert_( "vector<PR_NS_A::PR_ST_B>" in type(p.first).__name__ ) self.assert_( "vector<PR_NS_A::PR_NS_D::PR_ST_E>" in type(p.second).__name__ )
def test_base_adder_list(self): waveList = vector(vector('short'))() waveList.push_back(self.wave1) waveList.push_back(self.wave2) self.rda.AddRawDigits(waveList,self.wave3) self.assertEqual(self.wave2.size(),10) self.assertEqual(self.wave3,self.wave1pwave2) self.assertEqual(self.orig_wave1,self.wave1) self.assertEqual(self.orig_wave2,self.wave2)
def test_base_adder_list(self): waveList = vector(vector('short'))() waveList.push_back(self.wave1) waveList.push_back(self.wave2) self.rda.AddRawDigits(waveList,self.wave3) self.assertEqual(self.wave2.size(),10) for x in range(0,10): self.assertEqual(self.wave3[x],self.wave1pwave2[x]) self.assertEqual(self.orig_wave1[x],self.wave1[x]) self.assertEqual(self.orig_wave2[x],self.wave2[x])
def __init__(self, name, tree): #hit representation in the tree self.pdg = std.vector(int)() self.en = std.vector(float)() self.hx = std.vector(float)() self.hy = std.vector(float)() self.hz = std.vector(float)() self.prim = std.vector(int)() self.conv = std.vector(int)() self.edep = std.vector(float)() self.nsec = std.vector(int)() tree.SetBranchAddress(name + "_HitPdg", self.pdg) tree.SetBranchAddress(name + "_HitEn", self.en) tree.SetBranchAddress(name + "_HitX", self.hx) tree.SetBranchAddress(name + "_HitY", self.hy) tree.SetBranchAddress(name + "_HitZ", self.hz) tree.SetBranchAddress(name + "_HitPrim", self.prim) tree.SetBranchAddress(name + "_HitConv", self.conv) tree.SetBranchAddress(name + "_HitEdep", self.edep) tree.SetBranchAddress(name + "_HitNsec", self.nsec) #interface to the hit self.hit = self.Hit()
def setUp(self): self.rda = RawDigitAdder_HardSaturate(False) self.wave3 = vector('short')() self.wave3 += [0,-1,10,-2,0] self.wave1 = vector('short')() self.wave1 += [0,1,0,3,9,4,1,2,0,1] self.wave2 = vector('short')() self.wave2 += [1,1,8,22,15,2,0,0,1,3] self.wave1pwave2 = vector('short')() self.wave1pwave2 += [1,2,8,25,24,6,1,2,1,4] self.orig_wave1=self.wave1 self.orig_wave2=self.wave2 self.orig_wave3=self.wave3
def main(basedir=None): #production directory if basedir is None: basedir = ".." #input infile = basedir + "/lmon.root" #output outfile = basedir + "/HCal.csv" #lmon input inp = TFile.Open(infile) tree = inp.Get("DetectorTree") #load the tree gROOT.ProcessLine("struct EntryD {Double_t v;};") ucal_edep_EMC = rt.EntryD() ucal_edep_HAC1 = rt.EntryD() ucal_edep_HAC2 = rt.EntryD() ucal_edep_layers = std.vector(float)() tree.SetBranchAddress("ucal_edep_EMC", AddressOf(ucal_edep_EMC, "v")) tree.SetBranchAddress("ucal_edep_HAC1", AddressOf(ucal_edep_HAC1, "v")) tree.SetBranchAddress("ucal_edep_HAC2", AddressOf(ucal_edep_HAC2, "v")) tree.SetBranchAddress("ucal_edep_layers", ucal_edep_layers) #output txt csv out = open(outfile, "write") #file header tree.GetEntry(0) nlay = ucal_edep_layers.size() col = ["ucal_edep_EMC", "ucal_edep_HAC1", "ucal_edep_HAC2"] for i in range(nlay): col.append("ucal_edep_layer" + str(i)) strcol = "" for i in col: strcol += "," + i out.write(strcol + "\n") #event loop for iev in xrange(tree.GetEntriesFast()): tree.GetEntry(iev) lin = str(iev + 1) lin += "," + str(ucal_edep_EMC.v) lin += "," + str(ucal_edep_HAC1.v) lin += "," + str(ucal_edep_HAC2.v) for i in xrange(nlay): lin += "," + str(ucal_edep_layers.at(i)) out.write(lin + "\n") out.close()
def __init__( self, input_larcv_files, input_ana_files, npairs=20000, use_triplets=True ): self.input_larcv_files = input_larcv_files self.input_ana_files = input_ana_files # load chain self.match_v = std.vector("larflow::FlowMatchMap")() self.tchain = rt.TChain("flowmatchdata") for fin in input_ana_files: print "adding ana file: ",fin self.tchain.Add( fin ) self.tchain.SetBranchAddress( "matchmap", rt.AddressOf(self.match_v)) print "chain has ",self.tchain.GetEntries()," entries" self.params = {"has_truth":True, "verbose":False, "npairs":npairs, "matchtree":self.tchain, "match_v":self.match_v} self.nworkers = 1 self.feeder = LArCVServer(1,"larmatchfeed", load_larmatch_data, self.input_larcv_files, self.nworkers, io_tickbackward=False, func_params=self.params)
def vec(vv): from ROOT import std import array return array.array('d', vv) vvv = std.vector("double")() for v in vv: vvv.push_back(v) return vvv
def stdVector(*args): '''Make a std::vector from a python list''' from ROOT import std floatType = False for i in args: floatType |= isinstance(i, float) if floatType: vec = std.vector(float)() for i in args: vec.push_back(i) return vec else: vec = std.vector(int)() for i in args: vec.push_back(i) return vec
def process_entry(self,entry_num): """ perform all actions -- send, receive, process, store -- for entry. we must: 1) split full image into 3D-correlated crops for larflow 2) package up into messages 3) send, then get reply """ # timing ttotal = time.time() tread = time.time() # get the entries ok = self._inlarcv.read_entry(entry_num) if not ok: raise RuntimeError("could not read larcv entry %d"%(entry_num)) ev_wholeview = self._inlarcv.get_data(larcv.kProductImage2D, self._adc_producer) wholeview_v = ev_wholeview.Image2DArray() tread = time.time()-tread tsplit = time.time() roi_v = std.vector("larcv::ROI")() crop_v = std.vector("larcv::Image2D")() self._split_algo.process( wholeview_v, crop_v, roi_v ) tsplit = time.time()-tsplit print("split whole image into {} crops in {} secs".format(crop_v.size(),tsplit)) flow_v = self.sendreceive_crops(crop_v, self._inlarcv.event_id().run(), self._inlarcv.event_id().subrun(), self._inlarcv.event_id().event()) self.store_replies(flow_v, crop_v) self._outlarcv.set_id( self._inlarcv.event_id().run(), self._inlarcv.event_id().subrun(), self._inlarcv.event_id().event()) self._outlarcv.save_entry() return True
def main(basedir=None): #production directory if basedir is None: basedir = ".." #input infile = basedir + "/lmon.root" #output outfile = basedir + "/HCal.csv" #lmon input inp = TFile.Open(infile) tree = inp.Get("DetectorTree") #load the tree gROOT.ProcessLine("struct EntryD {Double_t v;};") hcal_edep_EM = rt.EntryD() hcal_edep_HAD = rt.EntryD() hcal_edep_layers = std.vector(float)() tree.SetBranchAddress("hcal_edep_EM", AddressOf(hcal_edep_EM, "v")) tree.SetBranchAddress("hcal_edep_HAD", AddressOf(hcal_edep_HAD, "v")) tree.SetBranchAddress("hcal_edep_layers", hcal_edep_layers) tree.GetEntry(0) nlay = hcal_edep_layers.size() #output DataFrame col = ["hcal_edep_EM", "hcal_edep_HAD"] lnam = {} for i in range(nlay): n = "hcal_edep_layer"+str(i) lnam[i] = n col.append(n) df = DataFrame(columns=col) #event loop for iev in xrange(tree.GetEntriesFast()): tree.GetEntry(iev) #print hcal_edep_EM.v, hcal_edep_HAD.v df.loc[iev+1, "hcal_edep_EM"] = hcal_edep_EM.v df.loc[iev+1, "hcal_edep_HAD"] = hcal_edep_HAD.v for i in xrange(nlay): #print "i", i, hcal_edep_layers.at(i) df.loc[iev+1, lnam[i]] = hcal_edep_layers.at(i) #print df df.to_csv(outfile)
def test_hs_adder_hardsaturate(self): hs_wave1pwave2 = vector('short')() hs_wave1pwave2 += [1,2,8,20,20,6,1,2,1,4] self.rda.SetSaturationPoint(20) self.rda.AddRawDigits(self.wave1,self.wave2,self.wave3) self.assertEqual(self.wave3.size(),10) self.assertEqual(self.wave3,hs_wave1pwave2) self.assertEqual(self.orig_wave1,self.wave1) self.assertEqual(self.orig_wave2,self.wave2)
def MGTWFFromNpArray(npArr): """ Convert a numpy array back into an MGTWaveform. """ from ROOT import MGTWaveform, std vec = std.vector("double")() for adc in npArr: vec.push_back(adc) mgtwf = MGTWaveform() mgtwf.SetData(vec) return mgtwf
def run_convert(basedir, beam): print "Converting for:", beam infile = basedir + "/lmon_p"+str(beam)+".root" outfile = basedir + "/HCal_p"+str(beam)+".h5" #lmon input inp = TFile.Open(infile) tree = inp.Get("DetectorTree") #load the tree ucal_edep_EMC = rt.EntryD() ucal_edep_HAC1 = rt.EntryD() ucal_edep_HAC2 = rt.EntryD() ucal_edep_layers = std.vector(float)() tree.SetBranchAddress("ucal_edep_EMC", AddressOf(ucal_edep_EMC, "v")) tree.SetBranchAddress("ucal_edep_HAC1", AddressOf(ucal_edep_HAC1, "v")) tree.SetBranchAddress("ucal_edep_HAC2", AddressOf(ucal_edep_HAC2, "v")) tree.SetBranchAddress("ucal_edep_layers", ucal_edep_layers) tree.GetEntry(0) nlay = ucal_edep_layers.size() #output DataFrame col = ["ucal_edep_EMC", "ucal_edep_HAC1", "ucal_edep_HAC2"] for i in range(nlay): col.append( "ucal_edep_layer"+str(i) ) df_inp = [] #event loop for iev in xrange(tree.GetEntriesFast()): tree.GetEntry(iev) lin = [] lin.append(ucal_edep_EMC.v) lin.append(ucal_edep_HAC1.v) lin.append(ucal_edep_HAC2.v) for i in xrange(nlay): lin.append(ucal_edep_layers.at(i)) df_inp.append(lin) df = DataFrame(df_inp, columns=col) print df out = HDFStore(outfile) out["hcal"] = df out.close() inp.Close()
def main(): inp = TFile.Open("../lmon.root") tree = inp.Get("DetectorTree") #tree.Print() gen_pdg = std.vector(int)() gen_en = std.vector(float)() tree.SetBranchAddress("gen_pdg", gen_pdg) tree.SetBranchAddress("gen_en", gen_en) tree.GetEntry(0) ngen = gen_pdg.size() for i in range(ngen): print i, gen_pdg.at(i), gen_en.at(i)
def test2WriteNonTObjectDerived( self ): """Test writing of an std::vector<double> into a pickle file""" v = std.vector( 'double' )() for i in range( Nvec ): v.push_back( i*i ) pickle.dump( v, self.out1 ) cPickle.dump( v, self.out2 )
def eval_point(self, point): l = self.args.ndim #l = len(point) #if not l==self.args.ndim: # print "dim(point) != dim(phasespace) !!" # sys.exit(1) v = std.vector(Double)(l) for i in range(l): v[i] = point[i] return self.kde.density(v) * self.kde_norm
def createMorph(obs, nuis_var, norm, up, down): pdf_list = RooArgList() pdf_list.add(down) pdf_list.add(up) pdf_list.add(norm) # nominal pdf nref_points = std.vector('double')() nref_points.push_back(-1) nref_points.push_back(1) nnuis_points = std.vector('int')() nnuis_points.push_back(2) par_list = RooArgList() par_list.add(nuis_var) morph = ROOT.RooStarMomentMorph("morph", "morph", par_list, obs, pdf_list, nnuis_points, nref_points, ROOT.RooStarMomentMorph.Linear) return morph
def test3TemplateInstantiationWithVectorOfFloat(self): """Test template instantiation with a std::vector< float >""" gROOT.LoadMacro("Template.C+") MyTemplatedClass = ROOT.MyTemplatedClass # the following will simply fail if there is a naming problem (e.g. std::, # allocator<int>, etc., etc.); note the parsing required ... b = MyTemplatedClass(std.vector(float))() for i in range(5): b.m_b.push_back(i) self.assertEqual(round(b.m_b[i], 5), float(i))
def fill( self ): v = std.vector( 'PR_ValClass*' )() n = fillVect( v ) self.assertEqual( n, len(v) ) self.assertEqual( v[0].m_val, "aap" ) m = {} for i in range( n ): m[i] = v[i] self.assertEqual( len(m), len(v) ) return m
def visualize2d_larlite_shower(larlite_shower): cm_per_tick = larutil.LArProperties.GetME().DriftVelocity() * 0.5 shr = larlite_shower shrlen = shr.Length() # get projections: vertex vtx_v = std.vector("double")(3) vtx_v[0] = shr.ShowerStart().X() vtx_v[1] = shr.ShowerStart().Y() vtx_v[2] = shr.ShowerStart().Z() # get projections: end end_v = std.vector("double")(3) end_v[0] = vtx_v[0] + shrlen * shr.Direction().X() end_v[1] = vtx_v[1] + shrlen * shr.Direction().Y() end_v[2] = vtx_v[2] + shrlen * shr.Direction().Z() # wire coordintes vtx = [larutil.Geometry.GetME().WireCoordinate(vtx_v, p) for p in range(3)] end = [larutil.Geometry.GetME().WireCoordinate(end_v, p) for p in range(3)] shower_traces = {} for p in range(3): shower_trace = { "type": "scatter", "x": [vtx[p], end[p]], "y": [3200 + vtx_v[0] / cm_per_tick, 3200 + end_v[0] / cm_per_tick], "mode": "lines", "line": { "color": "rgb(255,155,255)" }, } shower_traces[p] = shower_trace return shower_traces
def make_scin_edep(inlist, outfile): #input tree = TChain("DetectorTree") for i in inlist: tree.Add(i) scin_istrip = std.vector(int)() scin_ilay = std.vector(int)() scin_edep = std.vector(float)() tree.SetBranchAddress("bpc_scin_istrip", scin_istrip) tree.SetBranchAddress("bpc_scin_ilay", scin_ilay) tree.SetBranchAddress("bpc_scin_edep", scin_edep) #output txt csv out = open(outfile, "w") out.write("bpc_edep\n") #event loop nev = tree.GetEntries() for ievt in range(nev): tree.GetEntry(ievt) #deposited energy in event edep = 0. #scintillator loop for iscin in range(scin_edep.size()): #print(iscin, scin_istrip.at(iscin), scin_ilay.at(iscin), scin_edep.at(iscin)) edep += scin_edep.at(iscin) out.write(str(edep)+"\n") out.close() print("Done")
def test1AssignToReturnByRef( self ): """Test assignment to an instance returned by reference""" RefTester = ROOT.RefTester a = std.vector( RefTester )() a.push_back( RefTester( 42 ) ) self.assertEqual( len(a), 1 ) self.assertEqual( a[0].m_i, 42 ) a[0] = RefTester( 33 ) self.assertEqual( len(a), 1 ) self.assertEqual( a[0].m_i, 33 )
def test3TemplateInstantiationWithVectorOfFloat( self ): """Test template instantiation with a std::vector< float >""" gROOT.LoadMacro( "Template.C+" ) MyTemplatedClass = ROOT.MyTemplatedClass # the following will simply fail if there is a naming problem (e.g. std::, # allocator<int>, etc., etc.); note the parsing required ... b = MyTemplatedClass( std.vector( float ) )() for i in range(5): b.m_b.push_back( i ) self.assertEqual( round( b.m_b[i], 5 ), float(i) )
def main(): #open the input inp = TFile.Open("../../data/lmon.root") tree = inp.Get("DetectorTree") #get the branches with scintillator signals istrip = std.vector(int)() ilay = std.vector(int)() edep = std.vector(float)() tree.SetBranchAddress("lowQ2_scin_istrip", istrip) tree.SetBranchAddress("lowQ2_scin_ilay", ilay) tree.SetBranchAddress("lowQ2_scin_edep", edep) ievt = 2 # event number to read #load the event tree.GetEntry(ievt) #loop over the scintillators, all vectors are of the same size for i in xrange(istrip.size()): print i, ilay.at(i), istrip.at(i), edep.at(i)
def __init__(self, name, tree): #hit representation in the tree self.pdg = std.vector(int)() self.en = std.vector(float)() self.hx = std.vector(float)() self.hy = std.vector(float)() self.hz = std.vector(float)() tree.SetBranchAddress(name+"_HitPdg", self.pdg) tree.SetBranchAddress(name+"_HitEn", self.en) tree.SetBranchAddress(name+"_HitX", self.hx) tree.SetBranchAddress(name+"_HitY", self.hy) tree.SetBranchAddress(name+"_HitZ", self.hz) #interface to the hit self.hit = self.Hit(self) #counter position for transformation to local coordinates self.xpos = 0. self.ypos = 0. self.zpos = 0. self.theta_y = 0. self.theta_x = 0.
def test01WriteStdVector( self ): """Test writing of a single branched TTree with an std::vector<double>""" f = TFile( self.fname, 'RECREATE' ) t = TTree( self.tname, self.ttitle ) v = std.vector( 'double' )() t.Branch( 'mydata', v.__class__.__name__, v ) for i in range( self.N ): for j in range( self.M ): v.push_back( i*self.M+j ) t.Fill() v.clear() f.Write() f.Close()
def test01WriteStdVector(self): """Test writing of a single branched TTree with an std::vector<double>""" f = TFile(self.fname, 'RECREATE') t = TTree(self.tname, self.ttitle) v = std.vector('double')() t.Branch('mydata', v.__class__.__name__, v) for i in range(self.N): for j in range(self.M): v.push_back(i * self.M + j) t.Fill() v.clear() f.Write() f.Close()
def readFromROOT(self): #Check if data have already been read, #if not read in branch data if self._cache == None: branch = self.getObject() if self.branchType == Branch.BranchType.VECTORDOUBLE: #Use some ROOT's stuff to read vector<double> #Note we need to use ROOT.Double to have correct data type in vectors from ROOT import std, Double, AddressOf #Create a vector to contain doubles vect = std.vector(Double)(self.nelements, 0) data = AddressOf(vect) else: #Create an array to store data for each entry datatype = self.nelements * Branch.BranchType._typesMap[ self.branchType] data = datatype() #Set address of branch to the array branch.SetAddress(data) #Loop on events self._cache = [] for entry in xrange(branch.GetEntries()): branch.GetEntry(entry) #First simple case of simple variable if self.nelements == 1 and self.branchType != Branch.BranchType.VECTORDOUBLE: self._cache.append(data[0]) else: #Check if specific element is needed or all elements if self.element == -1: #Loop on elements of arrays d = [] for elem in xrange(self.nelements): if self.branchType == Branch.BranchType.VECTORDOUBLE: d.append(vect.at(elem)) else: d.append(data[elem]) else: #Get array/vector element self.element if self.branchType == Branch.BranchType.VECTORDOUBLE: d = vect.at(self.element) else: d = data[self.element] self._cache.append(d) return self._cache
def compute( self, data, **kwargs ) : """computes moments of data set (wrapper for C++ computeRooRealMoments) Looping over data in python is quite a bit slower than in C++. Hence, we adapt the arguments and then defer to the C++ computeRooRealMoments. """ from P2VV.Load import P2VVLibrary from ROOT import std, computeRooRealMoments momVec = std.vector('RooRealMoment*')() for func in self._basisFuncNames : momVec.push_back( self[func]._var ) computeRooRealMoments( data, momVec, kwargs.pop( 'ResetFirst', False ), kwargs.pop( 'Verbose', True ) ) for it1, func1 in enumerate(self._basisFuncNames) : self._coefficients[func1] = ( self[func1].coefficient(), self[func1].stdDev(), self[func1].significance() ) if self._covMatrixSize == len(self._basisFuncNames) : corrs = { } for it2, func2 in enumerate(self._basisFuncNames) : corrs[func2] = self[func2].correlation( it1 - it2 ) if it2 < it1 else self[func1].correlation( it2 - it1) self._correlations[func1] = corrs
def readFromROOT(self): #Check if data have already been read, #if not read in branch data if self._cache == None: branch = self.getObject() if self.branchType == Branch.BranchType.VECTORDOUBLE: #Use some ROOT's stuff to read vector<double> #Note we need to use ROOT.Double to have correct data type in vectors from ROOT import std,Double,AddressOf #Create a vector to contain doubles vect = std.vector(Double)(self.nelements,0) data = AddressOf( vect ) else: #Create an array to store data for each entry datatype = self.nelements * Branch.BranchType._typesMap[ self.branchType ] data = datatype() #Set address of branch to the array branch.SetAddress( data ) #Loop on events self._cache = [] for entry in xrange( branch.GetEntries() ): branch.GetEntry( entry ) #First simple case of simple variable if self.nelements == 1 and self.branchType != Branch.BranchType.VECTORDOUBLE: self._cache.append( data[0] ) else: #Check if specific element is needed or all elements if self.element == -1: #Loop on elements of arrays d = [] for elem in xrange( self.nelements ): if self.branchType == Branch.BranchType.VECTORDOUBLE: d.append( vect.at(elem) ) else: d.append( data[elem] ) else: #Get array/vector element self.element if self.branchType == Branch.BranchType.VECTORDOUBLE: d = vect.at( self.element ) else: d = data[self.element] self._cache.append( d ) return self._cache
def treatPropertyValue(value): if (type(value) is list) and (type(value[0]) is str): return list_to_stdvector('string', value) elif (type(value) is list) and (type(value[0]) is int): return list_to_stdvector('int', value) elif (type(value) is list) and (type(value[0]) is float): return list_to_stdvector('float', value) elif (type(value) is list) and (type(value[0]) is bool): return list_to_stdvector('bool', value) # list of list with ints, should be vector<vector<int>> elif (type(value) is list) and (type(value[0]) is list) and (type( value[0][0]) is int): from ROOT.std import vector vec = vector("vector<int>")() for v in value: vec.push_back(list_to_stdvector('int', v)) return vec else: return value
def eval_point(self, kernel_density, coord): """Evaluates PDF value at a given coordinate of normalized `KernelDensity` instance. Parameters ---------- kernel_density : KernelDensity Binned or adaptive `KernelDensity` instance. coord : tuple of floats Coordinates of a point at which the `kernel_density` is evaluated. Returns ------- value : float Evaluated PDF value at a given coordinate of normalized `kernel_density`. """ l = len(coord) v = std.vector(Double)(l) for i in range(l): v[i] = coord[i] return kernel_density.density(v) * self.model.kde_norm
def ReadFile(fil,tr,variables): data = TFile.Open(fil) tree = data.Get(tr) label = std.vector('int')(1) tree.SetBranchAddress('classID', label) x,y,w=[],[],[] for i in range(tree.GetEntries()): tree.GetEntry(i) x_tmp=[] for var in variables: x_tmp.append(getattr(tree,var)) x.append(x_tmp) y_tmp=[] for j in range(label.size()): y_tmp.append(label[j]) y.append(y_tmp) w.append(getattr(tree,'weight')) data.Close() if len(y[0])==1 : y = [e[0] for e in y] return x,y,w
def main(): args = parser() xSecFile = yaml.load( file( "{}/src/ChargedHiggs/Skimming/data/xsec.yaml".format( os.environ["CMSSW_BASE"]), "r")) xSec = 1. for key in xSecFile.keys(): if key in args.out_name: xSec = xSecFile[key]["xsec"] isData = True in [ name in args.out_name for name in ["Electron", "Muon", "MET"] ] channels = vector("string")() [channels.push_back(channel) for channel in args.channel] skimmer = NanoSkimmer(args.filename, isData) skimmer.EventLoop(channels, xSec) skimmer.WriteOutput(args.out_name)
# default configuration of the ElectronIsEMSelectorCutDefs # This one is used for tight++ menu import cppyy try : cppyy.loadDictionary('ElectronPhotonSelectorToolsDict') except : pass from ROOT import egammaPID, std # Next 3 lines are needed due to a difference how pyROOT and pyCintex handle stl vectors std.vector('float') std.vector('double') std.vector('int') # Import a needed helper from PATCore.HelperUtils import * # Define GeV GeV = 1000.0 def ElectronIsEMTightSelectorConfigDC14(theTool) : ''' These are the cut base isEM definitions: Tight from MC15 ''' theTool = GetTool(theTool) theTool.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150329/ElectronIsEMTightSelectorCutDefs.conf"
def multiplyP2VVAngleBases( angleBasis, **kwargs ) : doReset = kwargs.pop( 'DoReset', True ) def __dref__(arg) : from ROOT import RooAbsArg if isinstance( arg, RooAbsArg ) : return arg return arg._var if 'Functions' in kwargs : funcs = kwargs.pop('Functions') if 'Coefficients' in kwargs : coefs = kwargs.pop('Coefficients') assert len(funcs) == len(coefs)\ , 'P2VV - ERROR: multiplyP2VVAngleBases(): numbers of functions and coefficients are different' else : coefs = [ ConstVar( Name = 'one', Value = 1. ) for it in range( len(funcs) ) ] from ROOT import RooArgList funcList = RooArgList( __dref__(func) for func in funcs ) coefList = RooArgList( __dref__(coef) for coef in coefs ) angleBasis.createProdSum( funcList, coefList, doReset ) elif all( inds in kwargs for inds in ( 'iIndices', 'jIndices', 'lIndices', 'mIndices' ) ) : iInds = kwargs.pop('iIndices') jInds = kwargs.pop('jIndices') lInds = kwargs.pop('lIndices') mInds = kwargs.pop('mIndices') assert len(iInds) == len(jInds) == len(lInds) == len(mInds)\ , 'P2VV - ERROR: multiplyP2VVAngleBases(): different numbers i, j, l and m indices specified' if 'FixedCoefs' in kwargs : fixCoefs = kwargs.pop('FixedCoefs') assert len(iInds) == len(fixCoefs)\ , 'P2VV - ERROR: multiplyP2VVAngleBases(): numbers of indices and fixed coefficients are different' else : fixCoefs = [ 1. for it in range( len(iInds) ) ] if 'Coefficients' in kwargs : coefs = kwargs.pop('Coefficients') assert len(iInds) == len(coefs)\ , 'P2VV - ERROR: multiplyP2VVAngleBases(): numbers of indices and coefficients are different' else : coefs = [ ConstVar( Name = 'one', Value = 1. ) for it in range( len(iInds) ) ] from ROOT import std iIndsVec = std.vector('Int_t')() jIndsVec = std.vector('Int_t')() lIndsVec = std.vector('Int_t')() mIndsVec = std.vector('Int_t')() fixCoefsVec = std.vector('Double_t')() for ind in iInds : iIndsVec.push_back(ind) for ind in jInds : jIndsVec.push_back(ind) for ind in lInds : lIndsVec.push_back(ind) for ind in mInds : mIndsVec.push_back(ind) for coef in fixCoefs : fixCoefsVec.push_back(coef) from ROOT import RooArgList coefList = RooArgList( __dref__(coef) for coef in coefs ) angleBasis.createProdSum( iIndsVec, jIndsVec, lIndsVec, mIndsVec, fixCoefsVec, coefList, doReset ) else : raise RuntimeError, 'P2VV - ERROR: multiplyP2VVAngleBases(): either functions or indices should be specified'
print 'P2VV - INFO: Processing tree (%s initial entries): %s'%(intermediateTree.GetEntries(),protoTreePath) if addRunPeriodInfo: print 'P2VV - INFO: Adding run period (%s) info to ntuple'%runPeriod addIntegerToTree(intermediateTree, int(runPeriod), 'runPeriod' ) if addKaonSignInfo: print 'P2VV - INFO: Adding kaon sign (%+i) info to ntuple'%kaonSign addIntegerToTree(intermediateTree, int(kaonSign), 'kaonSign' ) if calculateHelAngles: calculateHelicityAngles(intermediateTree) if addKpiMassCategory: from ROOT import addCategoryToTree, std print 'P2VV - INFO: Adding Kpi-mass category with indices "%s" and KK-mass boundaries "%s" to n-tuple' % ( KpiMassInds, KpiMassBinBounds ) bounds = std.vector('Double_t')() inds = std.vector('Int_t')() for bound in KpiMassBinBounds : bounds.push_back(bound) for ind in KpiMassInds : inds.push_back(ind) addCategoryToTree( intermediateTree, KpiMassBranchName, 'KpiMassCat', bounds, inds ) # copy-rename branches from ROOT import copyFloatInTree for oldBranchName, newBranchName in obsDict.iteritems(): if oldBranchName != newBranchName[0]: print 'P2VV - INFO: Copying and renaming branch: %s --> %s'%(oldBranchName,newBranchName[0]) copyFloatInTree( intermediateTree, oldBranchName, newBranchName[0] ) # close intermediate files intermediateTree.Write() intermediateFile.Close()
def process(self, event): decayMode1 = -1 decayMode2 = -1 if self.cfg_ana.l1type == 'tau': decayMode1 = event.leg1.decayMode() if self.cfg_ana.l2type == 'tau': decayMode2 = event.leg2.decayMode() # RIC: some PF muons/electron can get the wrong mass assigned. # Peg their masses to the PDG values if self.cfg_ana.l1type == 'muon': mass1 = 0.10566 # PDG mass [GeV] elif self.cfg_ana.l1type == 'ele': mass1 = 0.51100e-3 # PDG mass [GeV] else: mass1 = event.leg1.mass() if self.cfg_ana.l2type == 'muon': mass2 = 0.10566 # PDG mass [GeV] elif self.cfg_ana.l2type == 'ele': mass2 = 0.51100e-3 # PDG mass [GeV] else: mass2 = event.leg2.mass() leg1 = measuredTauLepton(self.legType[self.cfg_ana.l1type], event.leg1.pt(), event.leg1.eta(), event.leg1.phi(), mass1, decayMode1) leg2 = measuredTauLepton(self.legType[self.cfg_ana.l2type], event.leg2.pt(), event.leg2.eta(), event.leg2.phi(), mass2, decayMode2) measuredLeptons = std.vector('svFitStandalone::MeasuredTauLepton')() # RIC: not really needed since SVfit internally sorts the inputs if hasattr(self.cfg_ana, 'order') and self.cfg_ana.order == '12': measuredLeptons.push_back(leg1) measuredLeptons.push_back(leg2) else: measuredLeptons.push_back(leg2) measuredLeptons.push_back(leg1) metcov = TMatrixD(2, 2) a_metcov = array.array('d', [event.diLepton.mvaMetSig(0, 0), event.diLepton.mvaMetSig(1, 0), event.diLepton.mvaMetSig(0, 1), event.diLepton.mvaMetSig(1, 1)]) metcov.SetMatrixArray(a_metcov) mex = event.diLepton.met().px() mey = event.diLepton.met().py() svfit = SVfitAlgo(measuredLeptons, mex, mey, metcov, 2*self.cfg_ana.verbose) # add an additional logM(tau,tau) term to the nll # to suppress tails on M(tau,tau) (default is false) # svfit.addLogM(False) if self.cfg_ana.integration == 'VEGAS': svfit.integrateVEGAS() elif self.cfg_ana.integration == 'MarkovChain': svfit.integrateMarkovChain() else: print 'The integration method must be defined in the cfg as "integration".' print 'Options: [VEGAS, MarkovChain]' raise # debug if self.cfg_ana.verbose: if abs(event.diLepton.svfitMass()-svfit.mass()) > 0.01: print 'WARNING: run {RUN}, lumi {LUMI}, event {EVT}'.format(RUN=str(event.run), LUMI=str(event.lumi), EVT=str(event.eventId)) print 'precomputed svfit mass ', event.diLepton.svfitMass() print 'svfit mass computed here ', svfit.mass() # method override event.diLepton.svfitMass = svfit.mass event.diLepton.svfitMassError = svfit.massUncert # add also the pt, eta and phi as computed by SVfit if self.cfg_ana.integration == 'MarkovChain': event.diLepton.svfitPt = svfit.pt event.diLepton.svfitPtError = svfit.ptUncert event.diLepton.svfitEta = svfit.eta event.diLepton.svfitPhi = svfit.phi event.diLepton.svfitMET = svfit.fittedMET event.diLepton.svfitTaus = svfit.fittedTauLeptons
import ROOT from ROOT import fcc, std import numpy as np import networkx as nx # command line arguments parser = argparse.ArgumentParser() parser.add_argument("filename", help="edm file to read") parser.add_argument("--nevents", help="max events to process (takes length of input root file by default)", type=int, default=-1) parser.add_argument('--output', type=str, help="name of rootfile to write", default="simVertices.root") args = parser.parse_args() primaryStartVertexVector = std.vector(fcc.GenVertexData)() primaryEndVertexVector = std.vector(fcc.GenVertexData)() secondaryStartVertexVector = std.vector(fcc.GenVertexData)() secondaryEndVertexVector = std.vector(fcc.GenVertexData)() hitProducingStartVertices = std.vector(fcc.GenVertexData)() print "creating root file and trees ..." f = ROOT.TFile(args.output, "recreate") t = ROOT.TTree( 'processedEvents', 'tree with processed fcc data' ) psvb = t.Branch("primaryStartVertices", primaryStartVertexVector) pevb = t.Branch("primaryEndVertices", primaryEndVertexVector) ssvb = t.Branch("secondaryStartVertices", secondaryStartVertexVector) sevb = t.Branch("secondaryEndVertices", secondaryEndVertexVector) hb = t.Branch("hitProducingStartVertices", hitProducingStartVertices) def r(point):
def __dovtest( self, v ): self.assertEqual( v.__class__, std.vector( 'double' ) ) self.assertEqual( v.size(), Nvec ) for i in range( Nvec ): self.assertEqual( v[i], i*i )
def puWeight(self): print 'PU scaling' puW = numpy.ones(1, dtype=numpy.float32) self.ttree.Branch(self.weightName,puW,self.weightName+"/F") self.inDATAFile = openTFile(self.inputDATAFileName) self.inMCFile = openTFile(self.inputMCFileName) self.puScaleDATAhisto = getHist(self.inDATAFile,self.HistoName) self.puScaleMChisto = getHist(self.inMCFile,self.HistoName) data_nBin = self.puScaleDATAhisto.GetNbinsX() data_minValue = self.puScaleDATAhisto.GetXaxis().GetXmin() data_maxValue = self.puScaleDATAhisto.GetXaxis().GetXmax() data_dValue = (data_maxValue - data_minValue) / data_nBin mc_nBin = self.puScaleMChisto.GetNbinsX() mc_minValue = self.puScaleMChisto.GetXaxis().GetXmin() mc_maxValue = self.puScaleMChisto.GetXaxis().GetXmax() mc_dValue = (mc_maxValue - mc_minValue) / mc_nBin ratio = mc_dValue/data_dValue nBin = data_nBin minValue = data_minValue maxValue = data_maxValue dValue = data_dValue print " ratio = " print ratio if (mc_dValue/data_dValue - (int) (mc_dValue/data_dValue)) != 0 : print " ERROR:: incompatible intervals!" exit(0); puScaleDATA = std.vector(float)() puScaleMCtemp = std.vector(float)() puScaleMC = std.vector(float)() ################ # remove last bin -> peak in DATA distribution # nBin = nBin-1 ################ for iBin in range(0, nBin): puScaleDATA.push_back(self.puScaleDATAhisto.GetBinContent(iBin+1)) mcbin = int(floor(iBin / ratio)) puScaleMCtemp.push_back(self.puScaleMChisto.GetBinContent(mcbin+1)) integralDATA = 0. integralMC = 0. for iBin in range(0, nBin): integralDATA += puScaleDATA.at(iBin) integralMC += puScaleMCtemp.at(iBin) print " integralDATA = " + "%.3f" %integralDATA print " integralMC = " + "%.3f" %integralMC for iBin in range(0, nBin): puScaleMC.push_back( puScaleMCtemp.at(iBin) * integralDATA / integralMC) nentries = self.nentries print 'total number of entries: '+str(nentries) i = 0 for ientry in range(0,nentries): i+=1 self.oldttree.GetEntry(ientry) ## print event count step = 50000 if i > 0 and i%step == 0.: print str(i)+' events processed.' ## ## ---------------------------------------------------------------- ## puW[0] = 1. ibin = -1 ## true pu reweighting if self.kindPU == "trpu" : ibin = int(self.oldttree.trpu / dValue) ## in time pu reweighting (observed) if self.kindPU == "itpu" : ibin = int(self.oldttree.itpu / dValue) if ibin < puScaleDATA.size() : if puScaleMC.at(ibin) != 0 : puW[0] = 1. * puScaleDATA.at(ibin) / puScaleMC.at(ibin) else : puW[0] = 1. else : ibin = puScaleDATA.size()-1 if puScaleMC.at(ibin) != 0 : puW[0] = 1. * puScaleDATA.at(ibin) / puScaleMC.at(ibin) else : puW[0] = 1. # print puW self.ttree.Fill()
def setReadCollectionNames( self, colNames ): #wrapper example for an autogenerated method that takes a string vector v = std.vector(std.string)() for col in colNames: v.push_back(col) self.reader.setReadCollectionNames( v )
nTupleIn = nTupleFileIn.Get(nTupleName) nTupleFileOut = TFile.Open( nTupleFilePathOut, 'RECREATE' ) nTupleOut = nTupleIn.CloneTree() nTupleFileIn.Close() del nTupleFileIn from P2VV.Load import P2VVLibrary if runPeriod : from ROOT import addIntegerToTree print 'adding run period "%s" to n-tuple' % runPeriod addIntegerToTree( nTupleOut, runPeriod, 'runPeriod' ) if firstData : from ROOT import addCategoryToTree, std print 'adding "first data" flag to n-tuple for data with run number < %d' % firstData bounds = std.vector('Double_t')() inds = std.vector('Int_t')() bounds.push_back( float(firstData) ) inds.push_back(1) inds.push_back(0) addCategoryToTree( nTupleOut, 'runNumber', 'firstData', bounds, inds ) if prescaleBounds : from ROOT import addCategoryToTree, std print 'adding prescale category with indices "%s" and run-number boundaries "%s" to n-tuple' % ( prescaleInds, prescaleBounds ) bounds = std.vector('Double_t')() inds = std.vector('Int_t')() for bound in prescaleBounds : bounds.push_back(bound) for ind in prescaleInds : inds.push_back(ind) addCategoryToTree( nTupleOut, 'runNumber', 'hlt2_prescale', bounds, inds )
from ROOT import std #test cluster id = Id.makeEcalId() tv =TVector3(0,0,0) cluster = ClusterCPP(3,tv,12,12345678) class AliceR(long): @staticmethod def value(): return 6 print AliceR.value() #test vectors m= std.vector('papas::Cluster')() m.push_back(cluster) m.size() print m[0].energy() v=std.unordered_map('uint64_t','papas::Cluster')() v[3] = ClusterCPP(3,tv,12,12345678) #test vectors w=std.unordered_map('int','int')() #try running papas simulation and reconstruction from ROOT.papas import CMS from ROOT.papas import PFEventDisplay, ViewPane, GDetector from ROOT.papas import Simulator
100, phsp.lowerLimit(1), phsp.upperLimit(1)) poly_hist = TH2F("poly", "Polynomial PDF", 100, phsp.lowerLimit(0), phsp.upperLimit(0), 100, phsp.lowerLimit(1), phsp.upperLimit(1)) kernel_hist = TH2F("kernel", "Kernel PDF", 100, phsp.lowerLimit(0), phsp.upperLimit(0), 100, phsp.lowerLimit(1), phsp.upperLimit(1)) true_kpi = TH1F("true_kpi", "M^{2}(K_{S}#pi) slice", 100, phsp.lowerLimit(0), phsp.upperLimit(0) ) poly_kpi = TH1F("poly_kpi", "M^{2}(K_{S}#pi) slice", 100, phsp.lowerLimit(0), phsp.upperLimit(0) ) kernel_kpi = TH1F("kernel_kpi", "M^{2}(K_{S}#pi) slice", 100, phsp.lowerLimit(0), phsp.upperLimit(0) ) true_pipi = TH1F("true_pipi", "M^{2}(#pi#pi) slice", 100, phsp.lowerLimit(1), phsp.upperLimit(1) ) poly_pipi = TH1F("poly_pipi", "M^{2}(#pi#pi) slice", 100, phsp.lowerLimit(1), phsp.upperLimit(1) ) kernel_pipi = TH1F("kernel_pipi", "M^{2}(#pi#pi) slice", 100, phsp.lowerLimit(1), phsp.upperLimit(1) ) # Coordinates in the phase space where we will create the 1D slices. from ROOT import std, Double v = std.vector(Double)(2) v[0] = 1.0; v[1] = 0.3; # Fill histogram with the result of kernel density estimation truepdf.project(true_hist) true_hist.Write() poly.project(poly_hist) poly_hist.Write() kde.project(kernel_hist) kernel_hist.Write() # Fill 1D slice in x projection, at the point y=v[1] truepdf.slice(v, 0, true_kpi) true_kpi.Write() poly.slice(v, 0, poly_kpi)
import sys import re import time import argparse oldargv = sys.argv[:] sys.argv = [ '-b-' ] import ROOT, os from ROOT import std ROOT.gROOT.SetBatch(True) sys.argv = oldargv ROOT.gSystem.Load("lib/libCFGMan.so") cfg = ROOT.CfgManager("test/test.cfg") cfg.ParseConfigString("test2.addedFromString 'new option from string'") cfg.ParseConfigString("test2.addedFromString+= work like a charm") cfg.ParseConfigString("test2.add+= 'added from py' great") cfg.Print() test_string = cfg.GetOpt("test.stringa") print(test_string) print(cfg.GetOpt("test.stringa", 1)) for opt in cfg.GetOpt(std.vector(std.string))("test.newline"): print(opt) sub_cfg = cfg.GetSubCfg("test3.subtest1") sub_cfg.Print()
#legend aleg = TLegend(0.6,0.4,0.8,0.6) SetOwnership( aleg, 0 ) aleg.SetMargin(0.12) aleg.SetTextSize(0.035) aleg.SetFillColor(10) aleg.SetBorderSize(0) isFirst = 1 ii = 0 stacklist[thegraph[ikey].name] = THStack("astack"+thegraph[ikey].name,thegraph[ikey].title) astack = stacklist[thegraph[ikey].name] xVal_val = TVectorD() yVal_val = TVectorD() yBin_val = std.vector(int)() xErr_val = TVectorD() yErr_val = TVectorD() zVal_val = TVectorD() zErr_val = TVectorD() nVal_val = 0 xVal_ref = TVectorD() yVal_ref = TVectorD() yBin_ref = std.vector(int)() xErr_ref = TVectorD() yErr_ref = TVectorD() zVal_ref = TVectorD() zErr_ref = TVectorD() nVal_ref = 0
#!/usr/bin/python import ROOT from ROOT import std, gROOT, gStyle, gPad, TCanvas, TH1, TH1D, TH2D, TLegend, TLine, TFile, TTree, TLorentzVector, TMath, TVirtualPad, TEventList fXX = TFile("tops.SMIA.tmp.10k.root","READ") tXX = fXX.Get("SMIA") pXX = ROOT.vector(TLorentzVector)() iXX = std.vector(int)() tXX.SetBranchAddress("p4",pXX); tXX.SetBranchAddress("id",iXX); hmSMXgen = TH1D("hmSMXgen", ";Truth #it{m}_{#it{t}#bar{#it{t}}} [GeV];Events",25,350,850) hmSMXgen.Sumw2() hmSMXgen.SetLineWidth(2) hmSMXgen.SetLineColor(ROOT.kAzure+9) hmSMXgen.SetMarkerColor(ROOT.kAzure+9) hmSMXgen.SetMarkerStyle(24) n=1 for event in tXX: if(n%1000==0): print "processed |SM+X|^2 generated ", n t1=event.p4[2] t2=event.p4[3] mtt = (t1+t2).M() hmSMXgen.Fill(mtt) n+=1 cnv = TCanvas("cnv","",600,600) cnv.Draw() cnv.cd() hmSMXgen.Draw()
gStyle.SetLineStyleString(2,"[12 12]"); # postscript dashes gStyle.SetEndErrorSize(0.); # gStyle.SetOptTitle(0); gStyle.SetOptStat(0); gStyle.SetOptFit(0); gStyle.SetPadTickX(1); gStyle.SetPadTickY(1); gStyle.SetPaintTextFormat("4.1f") setStyle() fMG = TFile("tops.MG_SM.500k.root","READ") tMG = fMG.Get("MG_SM") pMG = ROOT.vector(TLorentzVector)() iMG = std.vector(int)() tMG.SetBranchAddress("p4",pMG); tMG.SetBranchAddress("id",iMG); fSM = TFile("tops.SM.500k.root","READ") tSM = fSM.Get("SM") pSM = ROOT.vector(TLorentzVector)() iSM = std.vector(int)() tSM.SetBranchAddress("p4",pSM); tSM.SetBranchAddress("id",iSM); hmMG = TH1D("hmMG", ";Truth #it{m}_{#it{t}#bar{#it{t}}} [GeV];Events",25,350,850) hmMG.Sumw2() hmMG.SetLineWidth(2) hmMG.SetLineColor(ROOT.kBlack) hmMG.SetMarkerColor(ROOT.kBlack)
name = args.n jobid = args.i print 'name : ',name print 'jobid : ',jobid # Set up ROOT and RootCore: import ROOT ROOT.gROOT.Macro( '$ROOTCOREDIR/scripts/load_packages.C' ) if(not ROOT.xAOD.Init().isSuccess()): print "Failed xAOD.Init()" # Initialize the xAOD infrastructure from ROOT import std, gROOT, TFile, TTree, TLorentzVector tfile = "tops.SM.root" tfile = TFile(tfile,"RECREATE") tree = TTree("SM","SM") pdgid = std.vector(int)() p4 = ROOT.vector(TLorentzVector)() RunNumber = array( 'i', [ 0 ] ) EventNumber = array( 'i', [ 0 ] ) tree.Branch("id",pdgid) tree.Branch("p4",p4) tree.Branch("RunNumber",RunNumber,"RunNumber/I") tree.Branch("EventNumber",EventNumber,"EventNumber/I") # Set up the input files: xaodpath = "$HOME/data/MC/ttbar/ntup/" fullpath = ROOT.gSystem.ExpandPathName(xaodpath) fileName = fullpath+"/DAOD_TRUTH1.NTUP."+name+"."+jobid+".root" treeName = "CollectionTree" # default when making transient tree anyway f = ROOT.TFile.Open(fileName)