def AddNewBranches(inputfilename, treename, outputfilename):

  fcosin = TFile(inputfilename)
  tcosin = fcosin.Get(treename)
  fcosout = TFile(outputfilename,'RECREATE')
  tcosout = tcosin.CopyTree("")

  gROOT.ProcessLine(\
    "struct MyStruct{\
    Double_t adouble;\
    };")
  from ROOT import MyStruct

  cos1 = MyStruct()
  newBranchcos1 = tcosout.Branch('B_s0_Cos1', AddressOf(cos1,'adouble'), 'B_s0_Cos1/D')
  cos2 = MyStruct()
  newBranchcos2 = tcosout.Branch('B_s0_Cos2', AddressOf(cos2,'adouble'), 'B_s0_Cos2/D')
  phi = MyStruct()
  newBranchphi = tcosout.Branch('B_s0_Phi1', AddressOf(phi,'adouble'), 'B_s0_Phi1/D')
  t = MyStruct()
  newBrancht = tcosout.Branch('B_s0_t', AddressOf(t,'adouble'), 'B_s0_t/D')
  terr = MyStruct()
  newBranchterr = tcosout.Branch('B_s0_terr', AddressOf(terr,'adouble'), 'B_s0_terr/D')

  kp = TLorentzVector()
  pim = TLorentzVector()
  km = TLorentzVector()
  pip = TLorentzVector()

  print "Processing events ..."
  for ev, i in enumerate(tcosout):
    if (ev%1000==0): print ev, '/', tcosout.GetEntries()
    kp.SetXYZM(eval('i.'+KpPx_name),eval('i.'+KpPy_name),eval('i.'+KpPz_name),493.667)
    pim.SetXYZM(eval('i.'+PimPx_name),eval('i.'+PimPy_name),eval('i.'+PimPz_name),139.570)
    km.SetXYZM(eval('i.'+KmPx_name),eval('i.'+KmPy_name),eval('i.'+KmPz_name),493.667)
    pip.SetXYZM(eval('i.'+PipPx_name),eval('i.'+PipPy_name),eval('i.'+PipPz_name),139.570)
    angles = get_Angles(kp,pim,km,pip)
    cos1.adouble = angles[0]
    cos2.adouble = angles[1]
    phi.adouble  = angles[2]
    t.adouble    = eval('i.'+tau_name)*1000.
    terr.adouble = eval('i.'+tauerr_name)*1000.
    newBranchcos1.Fill()
    newBranchcos2.Fill()
    newBranchphi.Fill()
    newBrancht.Fill()
    newBranchterr.Fill()

  print "All events processed."

  tcosout.Write()
  fcosout.Close()
def btagEfficiencyTreeProducer(stageName="Z+jet", muChannel=True, path='../testfiles/'):
  #search for category number
  stage=-1
  for cat in categoryNames :
    stage+=1
    if cat==stageName : break
  # prepare output
  path='/nfs/user/llbb/Pat_8TeV_532p4/DYjets_Summer12_V2/'
  ROOT.gROOT.ProcessLine(
  "struct MyStruct {\
     Float_t     pt;\
     Float_t     eta;\
     Int_t       flavor;\
     Float_t     ssvhe;\
     Float_t     ssvhp;\
     Float_t     csv;\
     Float_t     eventWeight;\
  };" )
  from ROOT import MyStruct
  mystruct = MyStruct()
  f = ROOT.TFile( 'mybtagEfftree.root', 'RECREATE' )
  tree = ROOT.TTree( 'btagEff', 'btag efficiency' )
  tree.Branch( 'data', mystruct, 'pt/F:eta/F:flavor/I:ssvhe/F:ssvhp/F:csv/F:eventWeight/F' )
  # input
  if os.path.isdir(path):
    dirList=os.listdir(path)
    files=[]
    for fname in dirList:
      files.append(path+fname)
  elif os.path.isfile(path):
    files=[path]
  else:
    files=[]
  events = AnalysisEvent(files)
  EventSelection.prepareAnalysisEvent(events)
  # event loop
  eventCnt = 0
  print "starting loop on events"
  for event in events:
    categoryData = event.catMu if muChannel else event.catEle
    goodJets = event.goodJets_mu if muChannel else event.goodJets_ele
    if EventSelection.isInCategory(stage, categoryData):
      eventCnt = eventCnt +1
      if eventCnt%100==0 : print ".",
      if eventCnt%1000==0 : print ""
      # event weight
      mystruct.eventWeight = event.weight(weightList=["PileUp"])
      # that's where we access the jets
      for index,jet in enumerate(event.jets):
        if not goodJets[index]: continue
        mystruct.pt = jet.pt()
        mystruct.eta = jet.eta()
        mystruct.flavor = jet.partonFlavour()
        mystruct.ssvhe = jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags")
        mystruct.ssvhp = jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags")
        mystruct.csv = jet.bDiscriminator("combinedSecondaryVertexBJetTags")
        tree.Fill()
  f.Write()
  f.Close()
  print ""
Example #3
0
def writeCLTree(mg,mchi,xsec, box, model, directory, CLs, CLsExp):
    clTree = rt.TTree("clTree", "clTree")
    myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi;Double_t xsec;"
    iCL = 0
    myStructCmd+= "Double_t CL%i;"%(iCL+0)
    myStructCmd+= "Double_t CL%i;"%(iCL+1)
    myStructCmd+= "Double_t CL%i;"%(iCL+2)
    myStructCmd+= "Double_t CL%i;"%(iCL+3)
    myStructCmd+= "Double_t CL%i;"%(iCL+4)
    myStructCmd+= "Double_t CL%i;"%(iCL+5)
    iCL+=6
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    clTree.Branch("mg", rt.AddressOf(s,"mg"),'mg/D')
    clTree.Branch("mchi", rt.AddressOf(s,"mchi"),'mchi/D')
    clTree.Branch("xsec", rt.AddressOf(s,"xsec"),'xsec/D')
    
    s.mg = mg
    s.mchi = mchi
    s.xsec = xsec
    
    iCL = 0
    clTree.Branch("CLs_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+0)),'CL%i/D'%(iCL+0))
    clTree.Branch("CLsExpPlus2_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+1)),'CL%i/D'%(iCL+1))
    clTree.Branch("CLsExpPlus_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+2)),'CL%i/D'%(iCL+2))
    clTree.Branch("CLsExp_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+3)),'CL%i/D'%(iCL+3))
    clTree.Branch("CLsExpMinus_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+4)),'CL%i/D'%(iCL+4))
    clTree.Branch("CLsExpMinus2_%s"%box, rt.AddressOf(s,"CL%i"%(iCL+5)),'CL%i/D'%(iCL+5))
    exec 's.CL%i = CLs[iCL]'%(iCL+0)
    exec 's.CL%i = CLsExp[iCL][0]'%(iCL+1)
    exec 's.CL%i = CLsExp[iCL][1]'%(iCL+2)
    exec 's.CL%i = CLsExp[iCL][2]'%(iCL+3)
    exec 's.CL%i = CLsExp[iCL][3]'%(iCL+4)
    exec 's.CL%i = CLsExp[iCL][4]'%(iCL+5)
    iCL += 6

    clTree.Fill()

    xsecString = str(xsec).replace(".","p")
    outputFileName = "%s/CLs_mg_%s_mchi_%s_xsec_%s_%s.root" %(directory, mg, mchi, xsecString,'_'.join(boxes))
    print "CLs values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    clTree.Write()
    
    fileOut.Close()
    return outputFileName
def writeXsecTree(box, directory, mg, mchi, xsecULObs, xsecULExpPlus2, xsecULExpPlus, xsecULExp, xsecULExpMinus, xsecULExpMinus2):
    outputFileName = "%s/xsecUL_mg_%s_mchi_%s_%s.root" %(directory, mg, mchi, '_'.join(boxes))
    print "INFO: xsec UL values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    
    xsecTree = rt.TTree("xsecTree", "xsecTree")
    myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi;"
    ixsecUL = 0
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
    ixsecUL+=6
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mg", rt.AddressOf(s,"mg"),'mg/D')
    xsecTree.Branch("mchi", rt.AddressOf(s,"mchi"),'mchi/D')
    
    s.mg = mg
    s.mchi = mchi
    
    ixsecUL = 0
    xsecTree.Branch("xsecULObs_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+0)),'xsecUL%i/D'%(ixsecUL+0))
    xsecTree.Branch("xsecULExpPlus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+1)),'xsecUL%i/D'%(ixsecUL+1))
    xsecTree.Branch("xsecULExpPlus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+2)),'xsecUL%i/D'%(ixsecUL+2))
    xsecTree.Branch("xsecULExp_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+3)),'xsecUL%i/D'%(ixsecUL+3))
    xsecTree.Branch("xsecULExpMinus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+4)),'xsecUL%i/D'%(ixsecUL+4))
    xsecTree.Branch("xsecULExpMinus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+5)),'xsecUL%i/D'%(ixsecUL+5))
    exec 's.xsecUL%i = xsecULObs[ixsecUL]'%(ixsecUL+0)
    exec 's.xsecUL%i = xsecULExpPlus2[ixsecUL]'%(ixsecUL+1)
    exec 's.xsecUL%i = xsecULExpPlus[ixsecUL]'%(ixsecUL+2)
    exec 's.xsecUL%i = xsecULExp[ixsecUL]'%(ixsecUL+3)
    exec 's.xsecUL%i = xsecULExpMinus[ixsecUL]'%(ixsecUL+4)
    exec 's.xsecUL%i = xsecULExpMinus2[ixsecUL]'%(ixsecUL+5)
    ixsecUL += 4

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()
    
    fileOut.Close()
    
    return outputFileName
def writeXsecTree(box, model, directory, massPoint, xsecULObs, xsecULExpPlus2, xsecULExpPlus, xsecULExp, xsecULExpMinus, xsecULExpMinus2):
    outputFileName = "%s/xsecUL_%s_%s_%s.root" %(directory, model, massPoint, box)
    print "INFO: xsec UL values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    
    xsecTree = rt.TTree("xsecTree", "xsecTree")
    myStructCmd = "struct MyStruct{Double_t mass;"
    ixsecUL = 0
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
    ixsecUL+=6
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mass", rt.AddressOf(s,"mass"),'mass/D')
    
    
    s.mass = float(massPoint)
    
    ixsecUL = 0
    xsecTree.Branch("xsecULObs_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+0)),'xsecUL%i/D'%(ixsecUL+0))
    xsecTree.Branch("xsecULExpPlus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+1)),'xsecUL%i/D'%(ixsecUL+1))
    xsecTree.Branch("xsecULExpPlus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+2)),'xsecUL%i/D'%(ixsecUL+2))
    xsecTree.Branch("xsecULExp_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+3)),'xsecUL%i/D'%(ixsecUL+3))
    xsecTree.Branch("xsecULExpMinus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+4)),'xsecUL%i/D'%(ixsecUL+4))
    xsecTree.Branch("xsecULExpMinus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+5)),'xsecUL%i/D'%(ixsecUL+5))
    exec 's.xsecUL%i = xsecULObs[ixsecUL]'%(ixsecUL+0)
    exec 's.xsecUL%i = xsecULExpPlus2[ixsecUL]'%(ixsecUL+1)
    exec 's.xsecUL%i = xsecULExpPlus[ixsecUL]'%(ixsecUL+2)
    exec 's.xsecUL%i = xsecULExp[ixsecUL]'%(ixsecUL+3)
    exec 's.xsecUL%i = xsecULExpMinus[ixsecUL]'%(ixsecUL+4)
    exec 's.xsecUL%i = xsecULExpMinus2[ixsecUL]'%(ixsecUL+5)
    ixsecUL += 4

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()
    
    fileOut.Close()
    
    return outputFileName
Example #6
0
def writeXsecTree(box, model, directory, massPoint, xsecULObs, xsecULExpPlus2, xsecULExpPlus, xsecULExp, xsecULExpMinus, xsecULExpMinus2):
    outputFileName = "%s/xsecUL_%s_%s_%s.root" %(directory, model, massPoint, box)
    print "INFO: xsec UL values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    
    xsecTree = rt.TTree("xsecTree", "xsecTree")
    myStructCmd = "struct MyStruct{Double_t mass;"
    ixsecUL = 0
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
    ixsecUL+=6
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mass", rt.AddressOf(s,"mass"),'mass/D')
    
    
    s.mass = float(massPoint)
    
    ixsecUL = 0
    xsecTree.Branch("xsecULObs_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+0)),'xsecUL%i/D'%(ixsecUL+0))
    xsecTree.Branch("xsecULExpPlus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+1)),'xsecUL%i/D'%(ixsecUL+1))
    xsecTree.Branch("xsecULExpPlus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+2)),'xsecUL%i/D'%(ixsecUL+2))
    xsecTree.Branch("xsecULExp_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+3)),'xsecUL%i/D'%(ixsecUL+3))
    xsecTree.Branch("xsecULExpMinus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+4)),'xsecUL%i/D'%(ixsecUL+4))
    xsecTree.Branch("xsecULExpMinus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+5)),'xsecUL%i/D'%(ixsecUL+5))
    exec 's.xsecUL%i = xsecULObs[ixsecUL]'%(ixsecUL+0)
    exec 's.xsecUL%i = xsecULExpPlus2[ixsecUL]'%(ixsecUL+1)
    exec 's.xsecUL%i = xsecULExpPlus[ixsecUL]'%(ixsecUL+2)
    exec 's.xsecUL%i = xsecULExp[ixsecUL]'%(ixsecUL+3)
    exec 's.xsecUL%i = xsecULExpMinus[ixsecUL]'%(ixsecUL+4)
    exec 's.xsecUL%i = xsecULExpMinus2[ixsecUL]'%(ixsecUL+5)
    ixsecUL += 4

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()
    
    fileOut.Close()
    
    return outputFileName
Example #7
0
    def CreateTree(self):  # too much complication lvl, use CreateTree2
        if len(self.internalData):
            # <- TOTAL WORKAROUND: START -> #
            # SEE: http://wlav.web.cern.ch/wlav/pyroot/tpytree.html

            leafStr = ""
            for key in self.internalData:
                s, leafStr = self.__CreateDummyStructAsStr(
                    self.internalData[key])
                print(s)
                print(leafStr)
                gROOT.ProcessLine(s)
                break  #all modules are assumed to have the same set of measured parameters

            from ROOT import MyStruct
            ms = MyStruct()
            # <- TOTAL WORKAROUND: END -> #

            self.outputFile = TFile(self.outputFileName, "recreate")
            tree = TTree("tree", "readData")
            tree.Branch("b", ms, leafStr)

            tree.SetBranchAddress("b", tree)

            for key in self.internalData:
                setattr(ms, "key", key)
                for d in self.internalData[key]:
                    setattr(ms, d, (self.internalData[key])[d])
                tree.Fill()

                # break
            tree.Write()
            self.outputFile.Close()

            print("Data saved as TTree object")
Example #8
0
def output_file_nonTrain(y_pred_cls, y_pred_adv_cls, evt_weight, x_test_index,
                         INPUT_FILE, proc_tree, alpha_str):
    # Create a lookup table for discriminator value by event number
    disc_lookup_signal = {}
    disc_lookup_signal_adv = {}
    proc_evt_weight = {}

    for disc_val, disc_val_adv, evt_wt, run, lumi, event in zip(
            y_pred_cls, y_pred_adv_cls, evt_weight, x_test_index[:, 0],
            x_test_index[:, 1], x_test_index[:, 2]):

        disc_lookup_signal[(run, lumi, event)] = disc_val
        disc_lookup_signal_adv[(run, lumi, event)] = disc_val_adv
        proc_evt_weight[(run, lumi, event)] = evt_wt

    # We write out the signal and background events to a new ROOT file.
    # For events in the test set, we append the GBM discriminator.
    # For events in the train set, we set the discriminator to -1
    # to avoid accidentally reusing the training set in the analysis.
    print len(disc_lookup_signal), len(disc_lookup_signal_adv)
    out_name = os.path.basename(INPUT_FILE).replace(
        '.root', alpha_str + '_NNscore.root')
    out_proc = rt.TFile(out_name, 'RECREATE')
    out_proc_tree = proc_tree.CloneTree(0)

    # This is the boilerplate code for writing something
    # to a ROOT tree from Python.

    rt.gROOT.ProcessLine("struct MyStruct2{float disc_advNN;};")
    rt.gROOT.ProcessLine("struct MyStruct3{float disc_simpleNN;};")
    rt.gROOT.ProcessLine("struct MyStruct{double evt_wt;};")
    from ROOT import MyStruct3, MyStruct2, MyStruct
    s = MyStruct3()
    s_adv = MyStruct2()
    s_wt = MyStruct()
    disc_branch_proc = out_proc_tree.Branch('disc_simpleNN',
                                            rt.AddressOf(s, 'disc_simpleNN'),
                                            'disc_simpleNN/F')
    disc_branch_sig_proc = out_proc_tree.Branch(
        'disc_advNN', rt.AddressOf(s_adv, 'disc_advNN'), 'disc_advNN/F')
    evt_weight_branch_proc = out_proc_tree.Branch('evt_weight',
                                                  rt.AddressOf(s_wt, 'evt_wt'),
                                                  'evt_weight/D')

    print "Writing new ROOT process file with discriminator appended"
    fill_discriminator(proc_tree, out_proc_tree, disc_lookup_signal,
                       disc_lookup_signal_adv, proc_evt_weight, s, s_adv, s_wt)

    # Cristian's code uses GetCurrentFile() for this part.
    # I will do that too just in case (paranoia).
    out_proc.cd()
    out_proc_tree.GetCurrentFile().Write()
    #signalNevents.Write()
    out_proc_tree.GetCurrentFile().Close()

    print 'done writing output'
Example #9
0
def ns2ps(inputfilename,outputfilename):

	ftin = TFile(NTUPLE_PATH+inputfilename+'.root')
	ttin = ftin.Get('DecayTree')
	ftout = TFile(NTUPLE_PATH+outputfilename+'.root','RECREATE')
	print "Copying the original tree ..."
	ttout = ttin.CopyTree("")
	print "Tree copied."

	gROOT.ProcessLine(\
		"struct MyStruct{\
		Float_t afloat;\
		};")
	from ROOT import MyStruct

	t = MyStruct()
	newBrancht = ttout.Branch('B_s0_t', AddressOf(t,'afloat'), 'B_s0_t/F')
	terr = MyStruct()
	newBranchterr = ttout.Branch('B_s0_terr', AddressOf(terr,'afloat'), 'B_s0_terr/F')

	print "Processing events ..."
	for i in ttout:
		t.afloat = eval('i.'+tau_name)*1000.
		terr.afloat = eval('i.'+tauerr_name)*1000.
		newBrancht.Fill()
		newBranchterr.Fill()
	print "All events processed."

	ttout.Write()
	ftout.Close()
Example #10
0
def readTree(t, name):
  fname = 'result_'+nameid+'.root'
  print fname
  f = TFile( fname, 'recreate' )
  tN = TTree( 't1', 'tree with histos' )

  gROOT.ProcessLine(
  "struct MyStruct {\
   Int_t      ttbb_;\
   Double_t    DRbb_;\
   Double_t    weight_;\
   };" );
  from ROOT import MyStruct

  s = MyStruct()
  tN.Branch('ttbb',AddressOf(s,'ttbb_'),'ttbb_/I')
  tN.Branch('DRbb',AddressOf(s,'DRbb_'),'DRbb_/D')
  tN.Branch('weight',AddressOf(s,'weight_'),'weight_/D')

  l = TLorentzVector() 
  l2 = TLorentzVector() 
  l3 = TLorentzVector()

  # Event loop
  nev = t.GetEntries()
  for n in t:
    particles = n.Particle
#    weights = n.Rwgt
    event = n.Event

    output = isTTBB(particles)
    s.ttbb_=output[0]
    s.DRbb_=output[1]
    s.weight_= cxlist[fid]/nev
    tN.Fill()

  f.Write()
  f.Close()
Example #11
0
def writeXsecTree(directory, model, mg, mchi, xsecULTotal, xsecULHighPt,
                  xsecULHighRes, xsecULHbb, xsecULZbb):
    outputFileName = "%s/xsecUL_%s_mg_%s_mchi_%s.root" % (directory, model, mg,
                                                          mchi)
    print "INFO: xsec UL values being written to %s" % outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")

    xsecTree = rt.TTree("xsecTree", "xsecTree")
    myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi;"
    for ixsecUL in range(0, 5):
        myStructCmd += "Double_t xsecUL%i;" % (ixsecUL)
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mg", rt.AddressOf(s, "mg"), 'mg/D')
    xsecTree.Branch("mchi", rt.AddressOf(s, "mchi"), 'mchi/D')
    s.mg = mg
    s.mchi = mchi

    ixsecUL = 0
    for box in ['Total', 'HighPt', 'HighRes', 'Hbb', 'Zbb']:
        xsecTree.Branch("xsecUL%s" % box,
                        rt.AddressOf(s, "xsecUL%i" % (ixsecUL)),
                        'xsecUL%i/D' % (ixsecUL))
        exec 's.xsecUL%i = xsecUL%s[0]' % (ixsecUL, box)
        ixsecUL += 1

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()

    fileOut.Close()

    return outputFileName
Example #12
0
    def __init__(self, schema):
        self.log = logging.getLogger('root')
        self.log = self.log.getChild(self.__class__.__name__)

        self.schema = schema

        #  Create ROOT file and TTree
        filename = 'gnomon.root'
        self.file = ROOT.TFile(filename, 'RECREATE')
        self.t = ROOT.TTree('t', '')

         # This code will be passed into CINT
        self.names_lookup, self.types_lookup = self.make_lookups(schema)
        my_struct_code = self.form_cint(self.names_lookup, self.types_lookup)

        self.log.info('Using following structure for converting Python: %s' %  my_struct_code)
        
        ROOT.gROOT.ProcessLine(my_struct_code)

        from ROOT import MyStruct

        self.my_struct = MyStruct()

        for key, val in self.names_lookup.iteritems():
            name = val
            my_type = self.types_lookup[key]

            code = None
            if my_type == 'string':
                code = 'C'
            elif my_type == 'integer':
                code = 'I'
            elif my_type == 'number' or my_type == 'array':
                code = 'F'
            elif my_type == 'object':
                pass
            elif my_type == 'boolean':
                code = 'O'
            else:
                raise ValueError

            x = ROOT.AddressOf(self.my_struct, str(name))
            if my_type == 'array':
                self.t.Branch(name, x,  '%s[%d]/%s' % (name, BUFFER_SIZE, code))
            else:
                self.t.Branch(name, x,  '%s/%s' % (name, code))
Example #13
0
def AddCosines(inputfilename,inputfileextradir,inputfileextradirname,outputfilename):

	fcosin = TFile(NTUPLE_PATH + inputfilename + '.root')
	if inputfileextradir: tcosin = fcosin.Get(inputfileextradirname).Get('DecayTree')
	else: tcosin = fcosin.Get('DecayTree')
	fcosout = TFile(NTUPLE_PATH + outputfilename + '.root','RECREATE')
	print "Copying the original tree ..."
	tcosout = tcosin.CopyTree("")
	print "Tree copied."

	gROOT.ProcessLine(\
		"struct MyStruct{\
		Double_t adouble;\
		};")
	from ROOT import MyStruct
	cos1 = MyStruct()
	newBranchcos1 = tcosout.Branch('B_s0_Cos1', AddressOf(cos1,'adouble'), 'B_s0_Cos1/D')
	cos2 = MyStruct()
	newBranchcos2 = tcosout.Branch('B_s0_Cos2', AddressOf(cos2,'adouble'), 'B_s0_Cos2/D')
	kp = TLorentzVector()
	pim = TLorentzVector()
	km = TLorentzVector()
	pip = TLorentzVector()

	print "Processing events ..."
	for i in tcosout:
		kp.SetXYZM(eval('i.'+KpPx_name),eval('i.'+KpPy_name),eval('i.'+KpPz_name),493.667)
		pim.SetXYZM(eval('i.'+PimPx_name),eval('i.'+PimPy_name),eval('i.'+PimPz_name),139.570)
		km.SetXYZM(eval('i.'+KmPx_name),eval('i.'+KmPy_name),eval('i.'+KmPz_name),493.667)
		pip.SetXYZM(eval('i.'+PipPx_name),eval('i.'+PipPy_name),eval('i.'+PipPz_name),139.570)
		angles = get_Angles(kp,pim,km,pip)
		cos1.afloat = angles[0]
		cos2.afloat = angles[1]
		newBranchcos1.Fill()
		newBranchcos2.Fill()
	print "All events processed."

	tcosout.Write()
	fcosout.Close()
Example #14
0
for ii in vectors_cand_seed:
    tree.Branch(ii[0]+"_seed",ii[1])
    
# Create a struct for the run information
rt.gROOT.ProcessLine(\
      "struct MyStruct{\
      Int_t run;\
      Int_t ls;\
      Int_t event;\
      };")

from ROOT import MyStruct

# Create branches in the tree
s = MyStruct()

tree.Branch("run",rt.AddressOf(s,"run"),"run/I")
tree.Branch("ls",rt.AddressOf(s,"ls"),"ls/I")
tree.Branch("event",rt.AddressOf(s,"event"),"event/I")

#retreives the lables for a handle for an event
def getAllLabels(event):
    for ii in handles:
        input_tag = ii[0] #triplet (label, middle, process(
        handle = ii[1] 
        event.getByLabel(input_tag, handle)

#gets the maps for all of the handles and returns a list
def getMaps():
    maps = []
Example #15
0
   Int_t    Y;\
   Int_t    Xray;\
   Int_t    PH17;\
   Int_t    PH18;\
   Int_t    PH19;\
   Int_t    PH24;\
   Int_t    PH25;\
   Int_t    PH26;\
   Int_t    PH31;\
   Int_t    PH32;\
   Int_t    PH33;\
  };" );


from ROOT import MyStruct
my = MyStruct()

tr.Branch('Arg', AddressOf(my,'Arg'), 'Arg/I');
tr.Branch('Frame', AddressOf(my,'Frame'), 'Frame/I');
tr.Branch('Event_th', AddressOf(my,'Event_th'), 'Event_th/I');
tr.Branch('Split_th', AddressOf(my,'Split_th'), 'Split_th/I');
tr.Branch('X', AddressOf(my,'X'), 'X/I');
tr.Branch('Y', AddressOf(my,'Y'), 'Y/I');
tr.Branch('Xray', AddressOf(my,'Xray'), 'Xray/I');
tr.Branch('PH17', AddressOf(my,'PH17'), 'PH17/I');
tr.Branch('PH18', AddressOf(my,'PH18'), 'PH18/I');
tr.Branch('PH19', AddressOf(my,'PH19'), 'PH19/I');
tr.Branch('PH24', AddressOf(my,'PH24'), 'PH24/I');
tr.Branch('PH25', AddressOf(my,'PH25'), 'PH25/I');
tr.Branch('PH26', AddressOf(my,'PH26'), 'PH26/I');
tr.Branch('PH31', AddressOf(my,'PH31'), 'PH31/I');
        else:
            sitelist.append(mystruct.fSite)

        h1rate.Fill(float(altitude))
        tree.Fill()
        f.Write()


f = TFile('raw.root', 'UPDATE')
gROOT.ProcessLine("struct MyStruct {\
    Float_t     fLat;\
    Float_t     fLong;\
    Float_t     fAlt;\
    Int_t     fTimestamp;\
    Char_t    fSite[64];\
};")
from ROOT import MyStruct
mystruct = MyStruct()
sitereset()

tree = TTree('rawdata', 'Rawdata')
tree.Branch('lat', mystruct, 'Lat/F')
tree.Branch('long', mystruct, 'Long/F')
tree.Branch('alt', mystruct, 'Alt/F')
tree.Branch('timestamp', mystruct, 'Timestamp/I')
tree.Branch('site', AddressOf(mystruct, 'fSite'), 'Site/C')

h1rate = TH1F('h1rate', 'Cumulative rate distribution', 100, 0, 20)
f.Write()
cherrypy.quickstart(MyMonitoring())
Example #17
0
def saveConstants(detector, file):
    from ROOT import TFile
    from ROOT import TTree
    from ROOT import gROOT
    from ROOT import AddressOf
    f = TFile(file, 'RECREATE')
    t = TTree('Corrections', 'Corrections')

    gROOT.ProcessLine(\
        "struct MyStruct{\
            Int_t index;\
            Int_t type;\
            Int_t bec;\
            Int_t layer;\
            Int_t sector;\
            Int_t ring;\
            Int_t hits;\
            Double_t tx;\
            Double_t ty;\
            Double_t tz;\
            Double_t rx;\
            Double_t ry;\
            Double_t rz;\
            Double_t etx;\
            Double_t ety;\
            Double_t etz;\
            Double_t erx;\
            Double_t ery;\
            Double_t erz;\
        };"           )
    from ROOT import MyStruct
    # Create branches in the tree
    s = MyStruct()
    t.Branch('index', AddressOf(s, 'index'), 'index/I')
    t.Branch('type', AddressOf(s, 'type'), 'type/I')
    t.Branch('bec', AddressOf(s, 'bec'), 'bec/I')
    t.Branch('layer', AddressOf(s, 'layer'), 'layer/I')
    t.Branch('sector', AddressOf(s, 'sector'), 'sector/I')
    t.Branch('ring', AddressOf(s, 'ring'), 'ring/I')
    t.Branch('hits', AddressOf(s, 'hits'), 'hits/I')
    t.Branch('tx', AddressOf(s, 'tx'), 'tx/D')
    t.Branch('ty', AddressOf(s, 'ty'), 'ty/D')
    t.Branch('tz', AddressOf(s, 'tz'), 'tz/D')
    t.Branch('rx', AddressOf(s, 'rx'), 'rx/D')
    t.Branch('ry', AddressOf(s, 'ry'), 'ry/D')
    t.Branch('rz', AddressOf(s, 'rz'), 'rz/D')
    t.Branch('etx', AddressOf(s, 'etx'), 'etx/D')
    t.Branch('ety', AddressOf(s, 'ety'), 'ety/D')
    t.Branch('etz', AddressOf(s, 'etz'), 'etz/D')
    t.Branch('erx', AddressOf(s, 'erx'), 'erx/D')
    t.Branch('ery', AddressOf(s, 'ery'), 'ery/D')
    t.Branch('erz', AddressOf(s, 'erz'), 'erz/D')
    t.SetMarkerStyle(20)
    #print detector
    for i in range(detector.nModules()):
        detector.GetModule(i)
        s.index = i
        if "Pixel" in detector.GetModule(i).Det:
            det = 1
        elif "SCT" in detector.GetModule(i).Det:
            det = 2
        elif "TRT" in detector.GetModule(i).Det:
            det = 3
        else:
            det = 0
        s.type = det

        if "Barrel" in detector.GetModule(i).BarrelEC:
            bec = 0
        elif "EndCapA" in detector.GetModule(
                i).BarrelEC or "EndcapA" in detector.GetModule(i).BarrelEC:
            bec = -1
        elif "EndCapC" in detector.GetModule(
                i).BarrelEC or "EndcapC" in detector.GetModule(i).BarrelEC:
            bec = 1
        else:
            bec = 999
        s.bec = bec
        s.layer = int(detector.GetModule(i).Layer)
        s.sector = int(detector.GetModule(i).PhiModule)
        s.ring = int(detector.GetModule(i).EtaModule)
        s.hits = int(detector.GetModule(i).Hits)
        s.tx = detector.GetModule(i).Tx
        s.ty = detector.GetModule(i).Ty
        s.tz = detector.GetModule(i).Tz
        s.rx = detector.GetModule(i).Rx
        s.ry = detector.GetModule(i).Ry
        s.rz = detector.GetModule(i).Rz
        s.bx = detector.GetModule(i).Bx
        s.etx = detector.GetModule(i).ETx
        s.ety = detector.GetModule(i).ETy
        s.etz = detector.GetModule(i).ETz
        s.erx = detector.GetModule(i).ERx
        s.ery = detector.GetModule(i).ERy
        s.erz = detector.GetModule(i).ERz
        s.ebx = detector.GetModule(i).EBx
        t.Fill()
    f.Write()
    f.Close()
Example #18
0
def convertToROOT(path, ascii_file):
  try:
    ascifilename = path+'/'+ascii_file+'.txt'
    spamReader = csv.reader(open(ascifilename, 'rb'), delimiter=' ', skipinitialspace=True)
    print "ASCI file name =", ascifilename
  except IOError:
    print 'File %s does not exist' % (ascifilename)
    return 666

  stuff = MyStruct()

  ArrSize = 3700

  nB1          = array('i', [ 0 ] )
  nB2          = array('i', [ 0 ] )
  b1_bunches   = array('i', ArrSize*[0])
  b2_bunches   = array('i', ArrSize*[0])
  b1_time_zc   = array('f', ArrSize*[0])
  b2_time_zc   = array('f', ArrSize*[0])
  #b1_time_le   = array('f', ArrSize*[0])
  #b2_time_le   = array('f', ArrSize*[0])
  b1_amp       = array('f', ArrSize*[0])
  b2_amp       = array('f', ArrSize*[0])
  b1_int  = array('f', ArrSize*[0])
  b2_int  = array('f', ArrSize*[0])
  b1_len       = array('f', ArrSize*[0])
  b2_len       = array('f', ArrSize*[0])
  nCol         = array('i', [ 0 ] )
  deltaT       = array('f', [ 0 ] )
  bMode        = array('i', [ 0 ] )


  rootFile    = TFile(path+'/root/'+ascii_file+'.root',"recreate")
  bunchTree = TTree("bunchTree","")

  bunchTree.Branch("vars", stuff, "version/F:status/i:scale/F:b1_offset:b1_gain:b2_offset:b2_gain:orb_len_trig:orb_len_1:orb_1_2:cog_ddly_c3_c4:cog_ddly_c1_c3:cog_ddly_c2_c4:cog_ddly_c1_c2")
  bunchTree.Branch("time",  AddressOf( stuff, 'daTime' ), "daTime/l")

  bunchTree.Branch('nB1', nB1, 'nB1/I')
  bunchTree.Branch('nB2', nB2, 'nB2/I')
  bunchTree.Branch('b1_bunches', b1_bunches, 'b1_bunches[nB1]/I')
  bunchTree.Branch('b2_bunches', b2_bunches, 'b2_bunches[nB2]/I')
  bunchTree.Branch('b1_time_zc', b1_time_zc, 'b1_time_zc[nB1]/F')
  bunchTree.Branch('b2_time_zc', b2_time_zc, 'b2_time_zc[nB2]/F')
  #bunchTree.Branch('b1_time_le', b1_time_le, 'b1_time_le[nB1]/F')
  #bunchTree.Branch('b2_time_le', b2_time_le, 'b2_time_le[nB2]/F')
  bunchTree.Branch('b1_amp', b1_amp, 'b1_amp[nB1]/F')
  bunchTree.Branch('b2_amp', b2_amp, 'b2_amp[nB2]/F')
  bunchTree.Branch('b1_int', b1_int, 'b1_int[nB1]/F')
  bunchTree.Branch('b2_int', b2_int, 'b2_int[nB2]/F')
  bunchTree.Branch('b1_len', b1_len, 'b1_len[nB1]/F')
  bunchTree.Branch('b2_len', b2_len, 'b2_len[nB2]/F')
  bunchTree.Branch('nCol', nCol, 'nCol/I')
  bunchTree.Branch('deltaT', deltaT, 'deltaT/F')
  bunchTree.Branch('bMode', bMode, 'bMode/I')


  i=0
  for row in spamReader:
      #if i>500: break
      if (row[0] == "#" or row[2]!="1"): continue

      stuff.version = float(row[0])

      #Parse date and time, save as TDatime
      date = re.split("-|T|:|U|", row[1])
      #print date
      dt = TDatime(int(date[0]), int(date[1]), int(date[2]), int(date[3]), int(date[4]), int(date[5]))
      stuff.daTime = dt.Convert()

      stuff.status    = bool(row[2])
      try:
          stuff.scale     = float(row[3])
      except ValueError:
          stuff.scale = 1.0
      stuff.b1_offset = float(row[4])
      stuff.b1_gain   = float(row[5])
      stuff.b2_offset = float(row[6])
      stuff.b2_gain   = float(row[7])


      '''# Zero-crossing '''
      nB1[0]    = int(row[8])
      nB2[0]    = int(row[10])


      """
      if row[8]!=row[12]:
          print "Miss-match in number of bunches for beam 1 !!!\n",
          continue
      if row[10]!=row[14]:
          continue
          print "Miss-match in number of bunches for beam 2 !!!\n"

      if row[16]!= row[8] or row[18]!= row[10]:
          print "\n \t ---Leading edge and zc Number of bunches don't match --- \n"
          continue
      if row[20]!= row[8] or row[22]!= row[10]:
          print "\n \t --- Number of bunches don't match Amplitudes--- \n"
          continue
      if (nB1[0]!=0 and nB2[0]!=0) and (row[24]!= row[8] or row[27]!= row[10]):
          print "\n \t --- Number of bunches don't match Integrals--- \n"
          print i, [row[a] for a in [24,8,27, 10]]
          continue
      """

      #12,13 = foldovwer stuff

      # This is the arrays for B1
      bunchNum = n.array(re.split(",",row[9]),  dtype = n.int)
      time_zc  = n.array(re.split(",",row[14]), dtype = n.float)
      amp      = n.array(re.split(",",row[16]), dtype = n.float)
      integ    = n.array(re.split(",",row[18]), dtype = n.float)
      length   = n.array(re.split(",",row[20]), dtype = n.float)

      # Debugging the Intensity problems
      # n.set_printoptions(precision=3)
      # if i>2950 and i<2965:
          #print 'line number ', i, row[1]
          # print 'Int=', integ[0:10]*0.960E9
          #print 'Len=', length[0:3]*1E9
              # for a in range (0,29):
              #print a, row[a][:60]


      for j in range(nB1[0]):
          try:
              b1_bunches[j]  = bunchNum[j]
          except IndexError:
              print 'Warning: out of range... but will continue'
              print 'bunchNum', bunchNum

              for a in range (0,29):
                  print a, row[a][:40]
              return 666


          b1_time_zc[j] = time_zc[j]
          if bunchNum[j] > 3300:
            b1_time_zc[j] += ORBIT_LEN*1e-9

          b1_amp[j]      = amp[j]
          if nB1[0]!=0 and nB2[0]!=0:
              b1_int[j] = integ[j]
              b1_len[j] = length[j]

      # now the same for B2
      bunchNum = n.array(re.split(",",row[11]), dtype = n.int)
      time_zc  = n.array(re.split(",",row[15]), dtype = n.float)
      amp      = n.array(re.split(",",row[17]), dtype = n.float)
      integ    = n.array(re.split(",",row[19]), dtype = n.float)
      length   = n.array(re.split(",",row[21]), dtype = n.float)

      for j in range(nB2[0]):
          try:
              b2_bunches[j]  = bunchNum[j]
          except IndexError:
              print 'Warning: out of range... but will continue'
              print 'bunchNum', bunchNum
              return 666
          b2_time_zc[j]  = time_zc[j]
          if bunchNum[j] > 3300:
            b2_time_zc[j] += ORBIT_LEN*1e-9

          b2_amp[j]      = amp[j]
          if nB1[0]!=0 and nB2[0]!=0:
              b2_int[j] = integ[j]
              b2_len[j] = length[j]



      '''Checks'''

      #if (nB1[0]==358):
      #    print b1_bunches

      '''
      if (nB1[0]==352 and nB2[0]==352):

          print "b1 po", b1_bunches[0], b1_bunches[1], b1_bunches[2]
          print "b2 po", b2_bunches[0], b2_bunches[1], b2_bunches[2]
          print "b1 zc", b1_time_zc[0], b1_time_zc[1], b1_time_zc[2]
          print "b2 zc", b2_time_zc[0], b2_time_zc[1], b2_time_zc[2]
          print "b1 le", b1_time_le[0], b1_time_le[1], b1_time_le[2]
          print "b2 le", b2_time_le[0], b2_time_le[1], b2_time_le[2]
      '''


      stuff.orb_len_trig = 0.0
      stuff.orb_len_1    = 0.0
      stuff.orb_1_2      = 0.0
      stuff.cog_ddly_c3_c4 = 0.0
      stuff.cog_ddly_c1_c3 = 0.0
      stuff.cog_ddly_c2_c4 = 0.0
      stuff.cog_ddly_c1_c2 = 0.0
      if nB1[0]!=0 and nB2[0]!=0:
          stuff.orb_len_trig = float(row[22])
          stuff.orb_len_1    = float(row[23])
          stuff.orb_1_2      = float(row[24])
          stuff.cog_ddly_c3_c4 = float(row[25])
          stuff.cog_ddly_c1_c3 = float(row[26])
          stuff.cog_ddly_c2_c4 = float(row[27])
          stuff.cog_ddly_c1_c2 = float(row[28])

      if stuff.version>=4.6:
          nCol[0]    = int(row[29])
          deltaT[0]  = float(row[30])


      if stuff.version>=4.8:
        #print row[30:]
        bMode = int(row[31])
      else:
        bMode = 0


      bunchTree.Fill()
      i+=1

  bunchTree.Write()
  print 'Number of entries in this tree =', bunchTree.GetEntries()

  rootFile.Close()

  return 42
Example #19
0
                  VarParsing.varType.string,
                  'name of output root file')

options.register ('infilename',
                  'TempOut.csv',
                  VarParsing.multiplicity.singleton,
                  VarParsing.varType.string,
                  'name of input file from lcr2.py')

options.parseArguments()

   
ofile = TFile(options.outfilename,"RECREATE")
tr = TTree("AnalysisTree","AnalysisTree")
    
s = MyStruct()

hltpath = TString("")
    

tr.Branch('run',AddressOf(s,'runnr'),'runnr/i')
tr.Branch('luminosityBlock',AddressOf(s,'luminosityBlock'),'luminosityBlock/i')
#tr.Branch("HLTpath","TString",hltpath)
#tr.Branch('L1bit','TString',l1bit)
tr.Branch('intgRecLumi',AddressOf(s,'intgRecLumi'),'intgRecLumi/D')   
#tr.Branch('HLTpresc',AddressOf(s,'HLTpresc'),'HLTpresc/D')
#tr.Branch('L1presc',AddressOf(s,'L1presc'),'L1presc/D')

infile = open("TempOut.csv", "r")

infile.readline()
Example #20
0
def convertToROOT(path, ascii_file):
    try:
      ascifilename = path+'/'+ascii_file+'.txt'
      spamReader = csv.reader(open(ascifilename, 'rb'), delimiter=' ', skipinitialspace=True)
      print "ASCI file name =", ascifilename
    except IOError:
      print 'File %s does not exist' % (ascifilename)
      return

    stuff = MyStruct()

    root_fileName = path+'/root/'+ascii_file+'.root'
    print "Creating the file: ", root_fileName
    root_file    = TFile(root_fileName,"recreate")
    timeTree = TTree("timeTree","")

    timeTree.Branch("vars1", stuff, "version/F:status/I:scale/D:b1_offset:b1_gain:b2_offset:b2_gain:nB1/I:nB2/I:\
b1_phase_min/D:b1_phase_max:b1_phase_mean:b1_phase_sigma:\
b2_phase_min/D:b2_phase_max:b2_phase_mean:b2_phase_sigma:\
bb_phase_min/D:bb_phase_max:bb_phase_mean:bb_phase_sigma:\
bcmain_jitter/F:b1_flag/I:b2_flag/I:nCol/I:bMode/I")

    timeTree.Branch("vars5",  AddressOf( stuff, 'daTime' ), "daTime/l")

    i=0
    for row in spamReader:
        # if i>500: break
        #print row
        if (row[0] == "#" or row[4]=="?"): continue
        #if i>600:   print i, [row[a] for a in [16,17,18,8,9]]

        stuff.version = float(row[0])

        # Parse date and time, save as TDatime
        date = re.split("-|T|:|U|", row[1])
        # print date
        dt = TDatime(int(date[0]), int(date[1]), int(date[2]), int(date[3]), int(date[4]), int(date[5]))
        stuff.daTime = dt.Convert()
        # stuff.daTime = dt.Convert(kTRUE)
        # dt.Print()

        stuff.status    = bool(int(row[2]))
        try:
            stuff.scale     = float(row[3])
        except ValueError:
            stuff.scale = 1.0
        stuff.b1_offset = float(row[4])
        stuff.b1_gain   = float(row[5])
        stuff.b2_offset = float(row[6])
        stuff.b2_gain   = float(row[7])
        stuff.nB1   = int(row[8])
        stuff.nB2   = int(row[9])

        # print "N bunches = ", stuff.nB1, stuff.nB2

        if stuff.nB1!=0:
            if row[10]!="-": stuff.b1_phase_min   = float(row[10])
            if row[11]!="-": stuff.b1_phase_max   = float(row[11])
            if row[12]!="-": stuff.b1_phase_mean  = float(row[12])
            if row[13]!="-": stuff.b1_phase_sigma = float(row[13])
        if stuff.nB2!=0:
            if row[14]!="-": stuff.b2_phase_min   = float(row[14])
            if row[15]!="-": stuff.b2_phase_max   = float(row[15])
            if row[16]!="-": stuff.b2_phase_mean  = float(row[16])
            if row[17]!="-": stuff.b2_phase_sigma = float(row[17])
        if (stuff.nB1!=0 and stuff.nB2!=0):
            if row[18]!="-": stuff.bb_phase_min   = float(row[18])
            if row[19]!="-": stuff.bb_phase_max   = float(row[19])
            if row[20]!="-": stuff.bb_phase_mean  = float(row[20])
            if row[21]!="-": stuff.bb_phase_sigma = float(row[21])

            # print 'Delta T = ', stuff.bb_phase_mean

        # if (len(row)!=22): print "len(row) = ", len(row)
        if len(row)>21:
            stuff.bcmain_jitter = float(row[22])
            stuff.b1_flag = int(row[23])
            stuff.b2_flag = int(row[24])

        if stuff.version>=4.6:
            stuff.nCol  = int(row[25])
        if stuff.version>=4.8:
            #print row[25:]
            stuff.bMode = int(row[26])
        else:
            stuff.bMode = 0

        timeTree.Fill()
        i+=1

    timeTree.Write()
    print timeTree.GetEntries()

    root_file.Close()

    return 42
Example #21
0
def writeXsecTree(box, model, directory, mg, mchi, xsecULObs, xsecULExpPlus2, xsecULExpPlus, xsecULExp, xsecULExpMinus, xsecULExpMinus2):
    outputFileName = "%s/xsecUL_mg_%s_mchi_%s_%s.root" %(directory, mg, mchi, box)
    print "INFO: xsec UL values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    
    xsecTree = rt.TTree("xsecTree", "xsecTree")
    try:
        from ROOT import MyStruct
    except ImportError:
        myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi; Double_t x; Double_t y;"
        ixsecUL = 0
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
        ixsecUL+=6
        myStructCmd += "}"
        rt.gROOT.ProcessLine(myStructCmd)
        from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mg", rt.AddressOf(s,"mg"),'mg/D')
    xsecTree.Branch("mchi", rt.AddressOf(s,"mchi"),'mchi/D')
    xsecTree.Branch("x", rt.AddressOf(s,"x"),'x/D')
    xsecTree.Branch("y", rt.AddressOf(s,"y"),'y/D')
    
    
    s.mg = mg
    s.mchi = mchi
    if 'T1x' in model:
        s.x = float(model[model.find('x')+1:model.find('y')].replace('p','.'))
        s.y = float(model[model.find('y')+1:].replace('p','.'))
    elif model == 'T1bbbb':
        s.x = 1
        s.y = 0
    elif model == 'T1tttt':
        s.x = 0
        s.y = 1
    else:
        s.x = -1
        s.y = -1
    
    ixsecUL = 0
    xsecTree.Branch("xsecULObs_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+0)),'xsecUL%i/D'%(ixsecUL+0))
    xsecTree.Branch("xsecULExpPlus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+1)),'xsecUL%i/D'%(ixsecUL+1))
    xsecTree.Branch("xsecULExpPlus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+2)),'xsecUL%i/D'%(ixsecUL+2))
    xsecTree.Branch("xsecULExp_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+3)),'xsecUL%i/D'%(ixsecUL+3))
    xsecTree.Branch("xsecULExpMinus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+4)),'xsecUL%i/D'%(ixsecUL+4))
    xsecTree.Branch("xsecULExpMinus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+5)),'xsecUL%i/D'%(ixsecUL+5))
    exec 's.xsecUL%i = xsecULObs[ixsecUL]'%(ixsecUL+0)
    exec 's.xsecUL%i = xsecULExpPlus2[ixsecUL]'%(ixsecUL+1)
    exec 's.xsecUL%i = xsecULExpPlus[ixsecUL]'%(ixsecUL+2)
    exec 's.xsecUL%i = xsecULExp[ixsecUL]'%(ixsecUL+3)
    exec 's.xsecUL%i = xsecULExpMinus[ixsecUL]'%(ixsecUL+4)
    exec 's.xsecUL%i = xsecULExpMinus2[ixsecUL]'%(ixsecUL+5)
    ixsecUL += 4

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()
    
    fileOut.Close()
    
    return outputFileName
Example #22
0
# Make a tree
fit_toy_tree = rt.TTree('fit_toy_tree','tree containing the toy fit parameters')

# Create a struct
rt.gROOT.ProcessLine(\
      "struct MyStruct{\
      Float_t mr0;\
      Float_t n;\
      Float_t b;\
      Float_t ntot;\
      };")

from ROOT import MyStruct

# Create branches in the tree
struct = MyStruct()
fit_toy_tree.Branch('mr0',rt.AddressOf(struct,'mr0'),'mr0/F')
fit_toy_tree.Branch('n',rt.AddressOf(struct,'n'),'n/F')
fit_toy_tree.Branch('b',rt.AddressOf(struct,'b'),'b/F')
fit_toy_tree.Branch('ntot',rt.AddressOf(struct,'ntot'),'ntot/F')

mr0_list = fit_toy_summary.get_mr0()
n_list = fit_toy_summary.get_n()
b_list = fit_toy_summary.get_b()
ntot_list = fit_toy_summary.get_ntot()

# Fill tree
for toy in range(fit_toy_summary.get_ntoys()):
    struct.mr0 = mr0_list[toy]
    struct.n = n_list[toy]
    struct.b = b_list[toy]
Example #23
0
  else:
    return float('nan')

structString = "struct MyStruct{ULong_t event;"
for var in variables:
  structString +="Float_t "+var+";"

for var in extraVariables:
  structString +="Float_t "+var+";"

structString   +="};"
ROOT.gROOT.ProcessLine(structString)

from ROOT import MyStruct

s = MyStruct()

#rwHisto = ""
#if globals().has_key("reweightingHistoFile"):
#  if reweightingHistoFile!="":
#    rf = ROOT.TFile(reweightingHistoFile)
#    htmp = rf.Get("ngoodVertices_Data")
#    ROOT.gDirectory.cd("PyROOT:/")
#    rwHisto = htmp.Clone()
#    rf.Close()
#    print "Using reweightingHisto", reweightingHistoFile, rwHisto
#
#if rwHisto == "":
#  print "Don't use nvtx reweighting"

def getReweightingHisto(filename=""):
Example #24
0
Cut = [CutB1, CutB2]

structString = "struct MyStruct{ULong_t event;"

for var in variables:
  structString +="Float_t "+var+";"
for var in extraVariables:
  structString +="Float_t "+var+";"

structString   +="};"

ROOT.gROOT.ProcessLine(structString)

from ROOT import MyStruct

s = MyStruct()

if not os.path.isdir(outputDir):
  os.system("mkdir "+outputDir)

t = R.TTree( "Events", "Events", 1 )
t.Branch("event", ROOT.AddressOf(s, "event"), "event/l")
for var in variables:
  t.Branch(var,   ROOT.AddressOf(s,var), var+'/F')
for var in extraVariables:
  t.Branch(var,   ROOT.AddressOf(s,var), var+'/F')

# ============================================================================
for cut in Cut:
  c = R.TChain('Events')
  c.Add(inputDir+'*.root')
Example #25
0
  leaf = c.GetAlias(varNameHisto)
  if leaf!='':
    return c.GetLeaf(leaf).GetValue()
  else:
    return float('nan')

structString = "struct MyStruct{"
for var in variables:
  structString +="Float_t "+var+";"

structString   +="};"
ROOT.gROOT.ProcessLine(structString)

from ROOT import MyStruct

s = MyStruct()

rwHisto = ""
if globals().has_key("reweightingHistoFile"):
  if reweightingHistoFile!="":
    rf = ROOT.TFile(reweightingHistoFile)
    htmp = rf.Get("ngoodVertices_Data")
    ROOT.gDirectory.cd("PyROOT:/")
    rwHisto = htmp.Clone()
    rf.Close()
    print "Using reweightingHisto", reweightingHistoFile, rwHisto

for m in chmodes:
  commoncf = "-1"
  exec(m)
  print "Mode:", chmode, "for", mode
Example #26
0
Beam_ener = 5.0

# Setup output branches
PID_v = r.vector('Int_t')()
P_X_v = r.vector('Double_t')()
P_Y_v =r.vector('Double_t')()
P_Z_v =r.vector('Double_t')()
E_v =r.vector('Double_t')()
M_v =r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine( "struct MyStruct{ Int_t n_particles; Double_t weight; };")
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct() 
output_tree.Branch('n_particles',AddressOf(s,'n_particles'),'n_particles/I')
output_tree.Branch('weight',AddressOf(s,'weight'),'weight/D')
output_tree.Branch("PID",PID_v)
output_tree.Branch("P_X",P_X_v)
output_tree.Branch("P_Y",P_Y_v)
output_tree.Branch("P_Z",P_Z_v)
output_tree.Branch("E",E_v)
output_tree.Branch("M",M_v)

in_ev = 0 # To know when to look for particles we must know when we are inside an event
in_ev_1 = 0 # The first line after <event> is information so we must skip that as well
s.n_particles = 0
for line in input_file:
#    if line[:1] == "#":
#        continue
    pass


i = Image.open(input_file)
pixels = i.load() # this is not a list
output_tree = TTree("Physics", "Physics")
print "Setup complete \nOpened picture " + input_file + "  \nConverting to .root format and outputing to " + output_file_name



# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine( "struct MyStruct{ Double_t X_v; Double_t Y_v; Double_t Pixel_v; };")
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct() 
output_tree.Branch('X_v',AddressOf(s,'X_v'),'X_v/D')
output_tree.Branch('Y_v',AddressOf(s,'Y_v'),'Y_v/D')
output_tree.Branch('Pixel_v',AddressOf(s,'Pixel_v'),'Pixel_v/D')


width, height = i.size
output_th2f = TH2F("histo_2d","Pixel ditribution; x(px) ; y(px) ",width,0,width,height,0,height) 

for y in range(height):
    cur_row_ttl = 0
    for x in range(width):
        cur_pixel = pixels[x, y]
        cur_pixel_mono = sum(cur_pixel) / len(cur_pixel)
        cur_row_ttl += cur_pixel_mono
        s.X_v = x
Example #28
0
def getJobStatistics(LOGDIR,OUTFILE):
    DIR_SUMMARY = {}
    SUMMARY = {} ###stores full stat
    SINGLE_DIR_DATA = {} ###stores single entries
    MEAN_COMP = {} ### stores stat info

    firstDir = True
    tempI=0

    samplesBinEdges = {} #{'lowerBin':{},'upperBin':{}}
    
    #Begin dir analysis
    if os.path.isdir(LOGDIR)==False and os.path.islink(LOGDIR)==False:
        print LOGDIR
        print "[ERROR] Directory not Valid"
        exit(1)


    SUMMARY = {"Success":0, "Failures":0, "Error":{}}
    spDirName = splitDirName(LOGDIR)
    
    if OUTFILE=="": OUTFILE = LOGDIR.strip('/').split("/")[-1]+'.root'
       
    print "---"
    print "OutFile:",OUTFILE
    print "Analyzing "+LOGDIR
    print "---"

    ###Parsing Files
    CRAB_LOGDIR = LOGDIR+"/res/"
    ### use stdout or xml for both?
    if options.TYPE == "CRAB": LOGS = os.popen("ls "+CRAB_LOGDIR+"*.stdout")
    elif  options.TYPE == "CMSSW": LOGS = os.popen("ls "+LOGDIR+"/*.xml")
    elif options.TYPE == "CMSSWCRAB": LOGS = os.popen("ls "+CRAB_LOGDIR+"CMSSW*.stdout")
    else: printError("Please choose a type: CRAB, CMSSW or CMSSWCRAB")
        
    ### creating a TTree
    outFile = ROOT.TFile(OUTFILE,"RECREATE")
    perfTree = ROOT.TTree('Performance', 'Performance')
    ### loop over logfiles/jobs
    Total_jobs=0
    Total_successfulJobs=0
    valueContainer = {}

    for x in LOGS:
        #Parse crabDir
        x = x.strip('\n')
        if options.TYPE == "CRAB": rValue = parseDir_Crab(LOGDIR, x, acceptedSummaries)
        elif  options.TYPE == "CMSSW": rValue = parseDir_CMSSW( x, acceptedSummaries)
        elif  options.TYPE == "CMSSWCRAB": rValue = parseDir_CMSSWCrab( LOGDIR, x, 'cmssw', acceptedSummaries)
                
        if rValue!=1: job_output = rValue
        else: continue
        #end Parse crabDir

	Total_jobs+=1
	if job_output["Success"]:
	  Total_successfulJobs+=1

        ###User Quantities, aka combination of logged quantities
        totalMB = 0
        totalActualMB = 0
        totalReadTime = 0
   
        if job_output.has_key('tstoragefile-read-total-megabytes'): totalMB += float(job_output['tstoragefile-read-total-megabytes'])
        if job_output.has_key('tstoragefile-readv-total-megabytes'): totalMB += float(job_output['tstoragefile-readv-total-megabytes'])
        
        if job_output.has_key('tstoragefile-read-actual-total-megabytes'): totalActualMB += float(job_output['tstoragefile-read-actual-total-megabytes'])
        if job_output.has_key('tstoragefile-readv-actual-total-megabytes'): totalActualMB += float(job_output['tstoragefile-readv-actual-total-megabytes'])


	### TODO: some estimate of read_kB/event
	### TODO: find a good error handling
	computeErrorStat(job_output, SUMMARY)

	### here, we are creating the tree structure, depending on the log content  
	for label in job_output.keys():
	  if not valueContainer.has_key(label):
	    if isinstance( job_output[label] , float) or isinstance( job_output[label] , list) :
	      valueContainer[label]=ROOT.std.vector( float )()
	      perfTree.Branch(str(makeCleanLabel(label,job_output)),valueContainer[str(label)])
	    if label=="Error":
	      valueContainer[label]=ROOT.std.vector( float )()
	      perfTree.Branch(str(makeCleanLabel(label,job_output)),valueContainer[str(label)])
#	      valueContainer[label+"_weight"]=ROOT.std.vector( float )()
#	      perfTree.Branch(str(makeCleanLabel(label,job_output))+"_weight",valueContainer[str(label)])
	  pushJobOutput( label, job_output, SINGLE_DIR_DATA)

	isFirstJob=False
    ###end log cycle
    ###
    
    ###the previous loop gathers the info and creates the tree structure
    ###this one actually fills the tree
    ###TODO: better if conditions
    for job in range(0,Total_successfulJobs):
      for label in SINGLE_DIR_DATA.keys():
	if label=="Error": 	continue
	if isinstance( SINGLE_DIR_DATA[label][job] , float):
	  valueContainer[label].clear()
	  valueContainer[label].push_back(SINGLE_DIR_DATA[label][job])
	elif isinstance( SINGLE_DIR_DATA[label][job] , list):
	  valueContainer[label].clear()
	  for entry in SINGLE_DIR_DATA[label][job]:
	    valueContainer[label].push_back(entry)
      ###tree filling
      perfTree.Fill()
    
#    Still need to record errors:
    label="Error"
    for err in SUMMARY[label].keys():
      print str(err)+" : "+str(SUMMARY[label][err])
      for job in range(0,int(SUMMARY[label][err])):
	valueContainer[label].clear()
	valueContainer[label].push_back(float(err))
	perfTree.Fill()

#############################################3 something entirely new here -- the job info!
    gROOT.ProcessLine(
	  "struct MyStruct {\
	  Char_t site[100];\
          Char_t dataset[200];\
          Char_t sw[100];\
          Char_t config[100];\
	  Char_t script[100];\
	  Char_t eventsJob[100];\
	  Char_t timestamp[100];\
	  Char_t comments[200];\
          Char_t njobs[100];\
	  };" );
    
    from ROOT import MyStruct, AddressOf;
    mystruct = MyStruct();
    info_tree = ROOT.TTree("info_tree","info_tree");
    info_tree.Branch("site",AddressOf(mystruct,'site'),'site/C');
    info_tree.Branch("dataset",AddressOf(mystruct,'dataset'),'dataset/C');
    info_tree.Branch("sw",AddressOf(mystruct,'sw'),'sw/C');
    info_tree.Branch("config",AddressOf(mystruct,'config'),'config/C');
    info_tree.Branch("comments",AddressOf(mystruct,'comments'),'comments/C');
    info_tree.Branch("eventsJob",AddressOf(mystruct,'eventsJob'),'eventsJob/C');
    info_tree.Branch("timestamp",AddressOf(mystruct,'timestamp'),'timestamp/C');
    info_tree.Branch("njobs",AddressOf(mystruct,'njobs'),'njobs/C');
    

#    fullstring=LOGDIR.strip('/').split("/")[-1].replace(".root","")
#    print "starting out with fullstring ",fullstring
#    bla_site = fullstring[0:fullstring.find("-")]
#    bla_rest = fullstring[fullstring.find("-")+1:len(fullstring)]
#    bla_script=bla_rest[0:bla_rest.find("-")]
#    bla_rest = bla_rest[bla_rest.find("-")+1:len(bla_rest)]
#    bla_nevents=int(bla_rest[0:bla_rest.find("-")])
#    bla_rest = bla_rest[bla_rest.find("-")+1:len(bla_rest)]
#    bla_config=bla_rest[0:bla_rest.find("-")]
#    bla_rest = bla_rest[bla_rest.find("-")+1:len(bla_rest)]
#    bla_timestamp=bla_rest[0:bla_rest.find("__")]

    #mystruct.site="%s" % bla_site
    #mystruct.config="%s" % bla_config
    #mystruct.script="%s" % bla_script
    #mystruct.timestamp="%s" % bla_timestamp
    #mystruct.nevents="ne%s" % bla_nevents
    #mystruct.njobs="nj%s" % str(Total_jobs)
    
    mystruct.site="%s" % options.SITE
    mystruct.config="%s" % options.CONFIG
    mystruct.sw="%s" % options.SW
    mystruct.timestamp="%s" % options.TIMESTAMP
    mystruct.eventsJob="ne%s" % options.EVENTSJOB
    mystruct.njobs="nj%s" % str(Total_jobs)
    mystruct.comments="ne%s" % options.COMMENTS

    
    info_tree.Fill()
    
    

#############################################3 /something entirely new here -- the job info!


    outFile.Write()
    outFile.Close()
Example #29
0
    
    smoothXsecTree = rt.TTree("smoothXsecTree", "smoothXsecTree")
    myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi;Double_t x;Double_t y;"
    ixsecUL = 0
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
    myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
    ixsecUL+=6
    myStructCmd += "}"
    rt.gROOT.ProcessLine(myStructCmd)
    from ROOT import MyStruct

    s = MyStruct()
    smoothXsecTree.Branch("mg", rt.AddressOf(s,"mg"),'mg/D')
    smoothXsecTree.Branch("mchi", rt.AddressOf(s,"mchi"),'mchi/D')
    smoothXsecTree.Branch("x", rt.AddressOf(s,"x"),'x/D')
    smoothXsecTree.Branch("y", rt.AddressOf(s,"y"),'y/D')
    if 'T1x' in model:
        s.x = float(model[model.find('x')+1:model.find('y')].replace('p','.'))
        s.y = float(model[model.find('y')+1:].replace('p','.'))
    elif model == 'T1bbbb':
        s.x = 1
        s.y = 0
    elif model == 'T1tttt':
        s.x = 0
        s.y = 1
    else:
        s.x = -1
Example #30
0

#Comparator
def getPt(TLorentzVector):
    return TLorentzVector[0].Pt()


############################################################################
# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine(
    "struct MyStruct{ Int_t n_particles; Double_t weight; Int_t njet; Float_t xsec1; Float_t xsec1_error; Float_t xsec2; Float_t xsec2_error; Int_t counter; Int_t SSmumu; Int_t OSmumu; Int_t SSee; Int_t OSee; Int_t SSemu; Int_t OSemu; };"
)
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct()
output_tree.Branch('n_particles', AddressOf(s, 'n_particles'), 'n_particles/I')
output_tree.Branch('weight', AddressOf(s, 'weight'),
                   'weight/D')  # exponential not working
output_tree.Branch('njet', AddressOf(s, 'njet'), 'njet/I')
output_tree.Branch('xsec1', AddressOf(s, 'xsec1'), 'xsec1/F')
output_tree.Branch('xsec1_error', AddressOf(s, 'xsec1_error'), 'xsec1_error/F')
output_tree.Branch('xsec2', AddressOf(s, 'xsec2'), 'xsec2/F')
output_tree.Branch('xsec2_error', AddressOf(s, 'xsec2_error'), 'xsec2_error/F')
output_tree.Branch('counter', AddressOf(s, 'counter'), 'counter/I')

#topology counter
output_tree.Branch('SSmumu', AddressOf(s, 'SSmumu'), 'SSmumu/I')
output_tree.Branch('OSmumu', AddressOf(s, 'OSmumu'), 'OSmumu/I')
output_tree.Branch('SSee', AddressOf(s, 'SSee'), 'SSee/I')
output_tree.Branch('OSee', AddressOf(s, 'OSee'), 'OSee/I')
Example #31
0
        Float_t vthrcal6;\
        Float_t vthrcal7;\
        Float_t vthrhv0;\
        Float_t vthrhv1;\
        Float_t vthrhv2;\
        Float_t vthrhv3;\
        Float_t vthrhv4;\
        Float_t vthrhv5;\
        Float_t vthrhv6;\
        Float_t vthrhv7;\
      };")

    from ROOT import MyStruct

    # Create branches in the tree
    s = MyStruct()
    mytree.Branch('rootInt',AddressOf(s,'channel'),'channel/I')
    mytree.Branch('rootFloat',AddressOf(s,'peak'),'peak/F')
    mytree.Branch('rootFloat',AddressOf(s,'pedestal'),'pedestal/F')
    mytree.Branch('rootFloat',AddressOf(s,'pedrms'),'pedrms/F')
    mytree.Branch('rootFloat',AddressOf(s,'deltat'),'deltat/F')
    mytree.Branch('rootFloat',AddressOf(s,'time'),'time/F')
    mytree.Branch('rootFloat',AddressOf(s,'caltemp'),'caltemp/F')
    mytree.Branch('rootFloat',AddressOf(s,'hvtemp'),'hvtemp/F')
    mytree.Branch('rootInt',AddressOf(s,'thr0'),'thr0/I')
    mytree.Branch('rootInt',AddressOf(s,'thr1'),'thr1/I')
    mytree.Branch('rootInt',AddressOf(s,'thr2'),'thr2/I')
    mytree.Branch('rootInt',AddressOf(s,'thr3'),'thr3/I')
    mytree.Branch('rootInt',AddressOf(s,'thr4'),'thr4/I')
    mytree.Branch('rootInt',AddressOf(s,'thr5'),'thr5/I')
    mytree.Branch('rootInt',AddressOf(s,'thr6'),'thr6/I')
    myCLs.sort()
    myCLsHisto = rt.TH1D("ExpectedCLs_%s" %BoxName, 100, min(myCLs), max(myCLs))
    for thisCLs in myCLs: myCLsHisto.Fill(thisCLs)
        
    clExpectedTree = rt.TTree("clExpectedTree", "clExpectedTree")
    rt.gROOT.ProcessLine(
        "struct MyStruct{\
        Double_t m0;\
        Double_t m12;\
        Double_t CLexp;\
        Double_t CLexpPlus;\
        Double_t CLexpMinus;};")
    from ROOT import MyStruct

    s = MyStruct()
    clTree.Branch("m0", rt.AddressOf(s,"m0"),'m0/D')
    clTree.Branch("m12", rt.AddressOf(s,"m12"),'m12/D')
    clTree.Branch("CLexp_%s" %BoxName, rt.AddressOf(s,"CLexp"),'CLexp/D')
    clTree.Branch("CLexpPlus_%s" %BoxName, rt.AddressOf(s,"CLexpPlus"),'CLexpPlus/D')
    clTree.Branch("CLexpMinus_%s" %BoxName, rt.AddressOf(s,"CLexpMinus"),'CLexpMinus/D')

    s.m0 = m0
    s.m12 = m12
    s.CLexp, s.CLexpPlus, s.CLexpMinus = ComputeMedian(myCLsHisto)
    clExpectedTree.Fill()
    
    outFile = rt.TFile(fileName.split(".root")[0]+"_expected.root", "recreate")
    clExpectedTree.Fill()
    myCLsHisto.Fill()
    outFile.Close()
Example #33
0
tr = TTree('tree_ne', 'tree')

gROOT.ProcessLine(\
"struct MyStruct {\
   Int_t    Arg;\
   Int_t    Frame;\
   Int_t    Event_th;\
   Int_t    Split_th;\
   Int_t    X;\
   Int_t    Y;\
   Int_t    Xray;\
   Int_t    count;\
};"    )

from ROOT import MyStruct
my = MyStruct()

tr.Branch('Arg', AddressOf(my, 'Arg'), 'Arg/I')
tr.Branch('Frame', AddressOf(my, 'Frame'), 'Frame/I')
tr.Branch('Event_th', AddressOf(my, 'Event_th'), 'Event_th/I')
tr.Branch('Split_th', AddressOf(my, 'Split_th'), 'Split_th/I')
tr.Branch('X', AddressOf(my, 'X'), 'X/I')
tr.Branch('Y', AddressOf(my, 'Y'), 'Y/I')
tr.Branch('Xray', AddressOf(my, 'Xray'), 'Xray/I')
tr.Branch('count', AddressOf(my, 'count'), 'count/I')

argvs = sys.argv
root = TFile(argvs[-1])

for i in range(1, 7):
    print 'tree = %s' % i
Example #34
0
tin_bkg = fin_bkg.Get("DecayTree")

fout = TFile(
    "/afs/cern.ch/work/j/jugarcia/public/FastNTuples/Bd2Dptaunu/Bd2Dptaunu_ToyForBDT.root",
    "RECREATE")

tout_signal = tin_signal.CloneTree(0)
tout_bkg = tin_bkg.CloneTree(0)

gROOT.ProcessLine(\
 "struct MyStruct{\
	Float_t afloat;\
	};"    )
from ROOT import MyStruct

evtype = MyStruct()
weight = MyStruct()
mass = MyStruct()

br_evtype_signal = tout_signal.Branch('signal', AddressOf(evtype, 'afloat'),
                                      'signal/F')
br_weight_signal = tout_signal.Branch('weight', AddressOf(weight, 'afloat'),
                                      'weight/F')
br_mass_signal = tout_signal.Branch('Dplus_MM_toy', AddressOf(mass, 'afloat'),
                                    'Dplus_MM_toy/F')
br_evtype_bkg = tout_bkg.Branch('signal', AddressOf(evtype, 'afloat'),
                                'signal/F')
br_weight_bkg = tout_bkg.Branch('weight', AddressOf(weight, 'afloat'),
                                'weight/F')
br_mass_bkg = tout_bkg.Branch('Dplus_MM_toy', AddressOf(mass, 'afloat'),
                              'Dplus_MM_toy/F')
Example #35
0
                   var_min_Kp_Km_ETA)
reader.AddVariable("max_pip_pim_ETA := max(pip_LOKI_ETA,pim_LOKI_ETA)",
                   var_max_pip_pim_ETA)
reader.AddVariable("min_pip_pim_ETA := min(pip_LOKI_ETA,pim_LOKI_ETA)",
                   var_min_pip_pim_ETA)

var_Bs_M = array('f', [0])
reader.AddSpectator("Bs_M", var_Bs_M)

reader.BookMVA("BDT", "dataset1/weights/TMVAClassification_BDT.weights.xml")
#reader.BookMVA("BDTG","dataset1/weights/TMVAClassification_BDTG.weights.xml")

gROOT.ProcessLine("struct MyStruct{ Float_t afloat; };")
from ROOT import MyStruct

bdt_output = MyStruct()
#bdtg_output = MyStruct()
br_bdt = tout.Branch('BDT', AddressOf(bdt_output, 'afloat'), 'BDT/F')
#br_bdtg = tout.Branch('BDTG', AddressOf(bdtg_output,'afloat'), 'BDTG/F')

print "Processing events ..."
for ev in tout:

    var_Bs_PT[0] = ev.Bs_PT
    var_Kst_PT[0] = ev.Kst_PT
    var_Kstb_PT[0] = ev.Kstb_PT
    var_max_Kp_Km_PT[0] = max(ev.Kp_PT, ev.Km_PT)
    var_min_Kp_Km_PT[0] = min(ev.Kp_PT, ev.Km_PT)
    var_max_pip_pim_PT[0] = max(ev.pip_PT, ev.pim_PT)
    var_min_pip_pim_PT[0] = min(ev.pip_PT, ev.pim_PT)
    var_Bs_DIRA_OWNPV[0] = ev.Bs_DIRA_OWNPV
Example #36
0
print "Setup complete \nOpened file " + str(sys.argv[1]) + "  \nConverting to .root format and outputing to " + output_file_name

# Setup output branches
PID_v = r.vector('Int_t')()
P_X_v = r.vector('Double_t')()
P_Y_v =r.vector('Double_t')()
P_Z_v =r.vector('Double_t')()
E_v =r.vector('Double_t')()
M_v =r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine( "struct MyStruct{ Int_t n_particles; Double_t weight; };")
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct() 
output_tree.Branch('n_particles',AddressOf(s,'n_particles'),'n_particles/I')
output_tree.Branch('weight',AddressOf(s,'weight'),'weight/D')
output_tree.Branch("PID",PID_v)
output_tree.Branch("P_X",P_X_v)
output_tree.Branch("P_Y",P_Y_v)
output_tree.Branch("P_Z",P_Z_v)
output_tree.Branch("E",E_v)
output_tree.Branch("M",M_v)

skippedLines = []
in_ev = 0 # To know when to look for particles we must know when we are inside an event
in_ev_1 = 0 # The first line after <event> is information so we must skip that as well
s.n_particles = 0
s.weight = 0
for line in input_file:
   Float_t rate;\
   Int_t hits;\
   Float_t thr;\
   Float_t vthrcal;\
   Float_t vthrhv;\
      };"

# Create a ROOT struct to hold information from each json run
gROOT.ProcessLine(struct_run_string)
gROOT.ProcessLine(struct_channel_string)

from ROOT import MyStruct
from ROOT import MyStructChannel

# Create branches in the tree
s = MyStruct()  ## general run info
channel_branch = [MyStructChannel() for i in range(96)]

mytree.Branch('run', AddressOf(s, 'run'), 'run/I')
mytree.Branch('peak', AddressOf(s, 'peak'), 'peak/F')
mytree.Branch('dt', AddressOf(s, 'dt'), 'dt/F')
mytree.Branch('pedestal', AddressOf(s, 'pedestal'), 'pedestal/F')
mytree.Branch('pedrms', AddressOf(s, 'pedrms'), 'pedrms/F')
mytree.Branch('time', AddressOf(s, 'time'), 'time/F')
mytree.Branch('localtime', AddressOf(s, 'localtime'), 'localtime/D')
mytree.Branch('skipped_words', AddressOf(s, 'skipped_words'),
              'skipped_words/I')
mytree.Branch('overflows', AddressOf(s, 'overflows'), 'overflows/I')
mytree.Branch('caltemp', AddressOf(s, 'caltemp'), 'caltemp/F')
mytree.Branch('hvtemp', AddressOf(s, 'hvtemp'), 'hvtemp/F')
mytree.Branch('calp', AddressOf(s, 'calp'), 'calp/F')
Example #38
0
  leaf = c.GetAlias(varNameHisto)
  if leaf!='':
    return c.GetLeaf(leaf).GetValue()
  else:
    return float('nan')

structString = "struct MyStruct{"
for var in variables:
  structString +="Float_t "+var+";"

structString   +="};"
ROOT.gROOT.ProcessLine(structString)

from ROOT import MyStruct

s = MyStruct()

rwHisto = ""
if globals().has_key("reweightingHistoFile"):
  if reweightingHistoFile!="":
    rf = ROOT.TFile(reweightingHistoFile)
    htmp = rf.Get("ngoodVertices_Data")
    ROOT.gDirectory.cd("PyROOT:/")
    rwHisto = htmp.Clone()
    rf.Close()
    print "Using reweightingHisto", reweightingHistoFile, rwHisto

for m in chmodes:
  commoncf = "-1"
  exec(m)
  print "Mode:", chmode, "for", mode
Example #39
0
	Int_t nJets=0;\
        Float_t Tau_pt=0;\
        Float_t Tau_phi=0;\
        Float_t Tau_eta=0;\
        Int_t nTaus=0;\
        Float_t MET=0;\
        Float_t TransMass=0;\
        Float_t tj1Dist=0;\
	Float_t DPhi_tau_miss=0;\
        Float_t DPhi_bjet_miss=0;\
        Float_t Upsilon=0;\
};")

from ROOT import MyStruct

mystruct = MyStruct()

#File list of samples to be read from
if isSignal:
    samples = [
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_1000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_10000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_1500',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_2000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_2500',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_3000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_5000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_7000',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_750',
        'ChargedHiggs_HplusTB_HplusToTauNu_HeavyMass_M_800',
        'ChargedHiggs_HplusTB_HplusToTauNu_IntermediateMassNoNeutral_M_145',
Example #40
0
    'met_tst_nolep_phi',
    'met_tst_phi',
    'metsig_tst',
]
ints = [
    'passJetCleanTight',
    'trigger_met_encoded',
    'trigger_met_encodedv2',
]
bols = [
    'passVjetsFilter',
    'passVjetsFilterTauEl',
    'passVjetsPTV',
]
from ROOT import MyStruct
mystruct = MyStruct()
tree_out = ROOT.TTree('QCDDDNominal', 'Nominal data driven QCD')
#tree_out.Branch( 'myfloats', mystruct, 'jj_mass/F:jj_dphi/F:jj_deta/F' )
tree_out.Branch('jj_mass', ROOT.AddressOf(mystruct, 'jj_mass'), 'jj_mass/F')
tree_out.Branch('jj_dphi', ROOT.AddressOf(mystruct, 'jj_dphi'), 'jj_dphi/F')
tree_out.Branch('jj_deta', ROOT.AddressOf(mystruct, 'jj_deta'), 'jj_deta/F')
tree_out.Branch('w', ROOT.AddressOf(mystruct, 'w'), 'w/F')
tree_out.Branch('TriggerEffWeight', ROOT.AddressOf(mystruct,
                                                   'TriggerEffWeight'),
                'TriggerEffWeight/F')
tree_out.Branch('TriggerEffWeightBDT',
                ROOT.AddressOf(mystruct, 'TriggerEffWeightBDT'),
                'TriggerEffWeightBDT/F')
tree_out.Branch('met_tenacious_tst_j1_dphi',
                ROOT.AddressOf(mystruct, 'met_tenacious_tst_j1_dphi'),
                'met_tenacious_tst_j1_dphi/F')
Example #41
0
    leaf = c.GetAlias(varNameHisto)
    if leaf != '':
        return c.GetLeaf(leaf).GetValue()
    else:
        return float('nan')


#Define and compile C struct; do not recompile when changes have been made in a single py session because the import statement will not update the struct
structString = "struct MyStruct{"
for var in variables:
    structString += "Float_t " + var + ";"
structString += "};"
ROOT.gROOT.ProcessLine(structString)
from ROOT import MyStruct

s = MyStruct()

#Did you specify a PU reweighting hist file?
rwHisto = ""
if globals().has_key("reweightingHistoFile"):
    if reweightingHistoFile != "":
        rf = ROOT.TFile(reweightingHistoFile)
        htmp = rf.Get("ngoodVertices_Data")
        ROOT.gDirectory.cd("PyROOT:/")
        rwHisto = htmp.Clone()
        rf.Close()
        print "Using reweightingHisto", reweightingHistoFile, rwHisto

if not os.path.isdir(outputDir):
    os.system("mkdir " + outputDir)
if not os.path.isdir(outputDir + "/" + chmode + "/"):
Example #42
0
                  'OutFile.root',
                  VarParsing.multiplicity.singleton,
                  VarParsing.varType.string,
                  'name of output root file')



options.parseArguments()

#os.system("lumiCalc2.py -i "+options.JSONname+" lumibyls -b stable --hltpath "+options.HLTpath+" -o TempOut.csv")
os.system("pixelLumiCalc.py -i "+options.JSONname+" lumibyls --hltpath "+options.HLTpath+" -o TempOut.csv")
    
ofile = TFile(options.outfilename,"RECREATE")
tr = TTree("AnalysisTree","AnalysisTree")
    
s = MyStruct()

hltpath = TString("")
    

tr.Branch('run',AddressOf(s,'runnr'),'runnr/i')
tr.Branch('luminosityBlock',AddressOf(s,'luminosityBlock'),'luminosityBlock/i')
tr.Branch("HLTpath","TString",hltpath)
#tr.Branch('L1bit','TString',l1bit)
tr.Branch('intgRecLumi',AddressOf(s,'intgRecLumi'),'intgRecLumi/D')   
tr.Branch('HLTpresc',AddressOf(s,'HLTpresc'),'HLTpresc/D')
tr.Branch('L1presc',AddressOf(s,'L1presc'),'L1presc/D')

#'''
#input:  {run:[lumilsnum(0),cmslsnum(1),timestamp(2),beamstatus(3),beamenergy(4),deliveredlumi(5),recordedlumi(6),calibratedlumierror(7),{hltpath:[l1name,l1prescale,hltprescale,efflumi]},bxdata,beamdata]}
#'''
Example #43
0
def output_file(y_pred_cls,y_pred_adv_cls,evt_weight, y_test, z_test,x_test_index,SIGNAL_FILE,sigtree,BKG_FILE_2018,bkgtree3,alpha_str):
    # Create a lookup table for discriminator value by event number
    disc_lookup_signal = {}
    disc_lookup_bkg = {}
    disc_lookup_signal_adv = {}
    disc_lookup_bkg_adv = {}
    sig_evt_weight={}
    bkg_evt_weight={}
    ys=[]
    h_sig_simple=rt.TH1F("simpleNN_VBF","simpleNN_VBF",100,0.,1.);
    h_sig_adv=rt.TH1F("advNN_VBF","advNN_VBF",100,0.,1.);
    h_bkg_simple=rt.TH1F("simpleNN_VBF","simpleNN_VBF",100,0.,1.);
    h_bkg_adv=rt.TH1F("advNN_VBF","advNN_VBF",100,0.,1.);
    print len(y_pred_cls), len(y_pred_adv_cls), len(evt_weight), len(y_test), len(x_test_index[:,0]),len(x_test_index[:,1]), len(x_test_index[:,2])
    print y_test.sum()
    
    ctr=0
    for disc_val, disc_val_adv, evt_wt, y_val, mass, run, lumi, event in zip(y_pred_cls, y_pred_adv_cls, evt_weight, y_test, z_test,x_test_index[:,0],x_test_index[:,1], x_test_index[:,2]):
        ctr+=1
        if y_val!=1. and y_val!=0.: print y_val
        if y_val == 1.:
            disc_lookup_signal[(run, lumi, event)] = disc_val
            disc_lookup_signal_adv[(run, lumi, event)] = disc_val_adv
            sig_evt_weight[(run, lumi, event)] = evt_wt
            if (mass<120. or mass>130.):
                h_sig_simple.Fill(disc_val,evt_wt)
                h_sig_adv.Fill(disc_val_adv, evt_wt)
            ys.append(1)
            #print y_val
            #print disc_val
        elif y_val == 0:
            disc_lookup_bkg[(run, lumi, event)] = disc_val
            disc_lookup_bkg_adv[(run, lumi, event)] = disc_val_adv
            bkg_evt_weight[(run, lumi, event)] = evt_wt
            if (mass<120. or mass>130.):
                h_bkg_simple.Fill(disc_val,evt_wt)
                h_bkg_adv.Fill(disc_val_adv, evt_wt)
            #print y_val
            #print disc_val
          
    # We write out the signal and background events to a new ROOT file.
    # For events in the test set, we append the GBM discriminator.  
    # For events in the train set, we set the discriminator to -1
    # to avoid accidentally reusing the training set in the analysis.
    print np.sum(ys)
    print len(ys)
    print ctr
    print len(disc_lookup_signal), len(disc_lookup_signal_adv)
    print len(disc_lookup_bkg), len(disc_lookup_bkg_adv)
    out_signal_name = os.path.basename(SIGNAL_FILE).replace('.root', alpha_str+'_NNscore_new.root')
    out_signal = rt.TFile(out_signal_name, 'RECREATE')
    out_signal_tree = sigtree.CloneTree(0)

    out_bkg_name = os.path.basename(BKG_FILE_2018).replace('.root', alpha_str+'_NNscore_new.root')
    out_bkg = rt.TFile(out_bkg_name, 'RECREATE')
    out_bkg_tree3 = bkgtree3.CloneTree(0)
    
    rt.gROOT.ProcessLine("struct MyStruct2{float disc_advNN;};")
    rt.gROOT.ProcessLine("struct MyStruct3{float disc_simpleNN;};")
    rt.gROOT.ProcessLine("struct MyStruct{double evt_wt;};")
    from ROOT import MyStruct3, MyStruct2, MyStruct
    s = MyStruct3()
    s_adv = MyStruct2()
    s_wt = MyStruct()
    disc_branch_sig = out_signal_tree.Branch('disc_simpleNN', rt.AddressOf(s, 'disc_simpleNN'), 'disc_simpleNN/F');
    disc_branch_bkg3 = out_bkg_tree3.Branch('disc_simpleNN', rt.AddressOf(s, 'disc_simpleNN'), 'disc_simpleNN/F');
   
    disc_branch_sig_adv = out_signal_tree.Branch('disc_advNN', rt.AddressOf(s_adv, 'disc_advNN'), 'disc_advNN/F');
    disc_branch_bkg_adv3 = out_bkg_tree3.Branch('disc_advNN', rt.AddressOf(s_adv, 'disc_advNN'), 'disc_advNN/F');
     
    evt_weight_branch_sig = out_signal_tree.Branch('evt_weight', rt.AddressOf(s_wt, 'evt_wt'), 'evt_weight/D');
    evt_weight_branch_bkg3 = out_bkg_tree3.Branch('evt_weight', rt.AddressOf(s_wt, 'evt_wt'), 'evt_weight/D');
   
    print "Writing new ROOT signal file with discriminator appended"
    fill_discriminator(sigtree, out_signal_tree, disc_lookup_signal,disc_lookup_signal_adv, sig_evt_weight,s, s_adv,s_wt)
    print "Writing new ROOT background file with discriminator appended"
    fill_discriminator(bkgtree3, out_bkg_tree3, disc_lookup_bkg,disc_lookup_bkg_adv, bkg_evt_weight,s, s_adv,s_wt)

    
    out_signal.cd()
    h_sig_simple.Write()
    h_sig_adv.Write()
    out_signal_tree.GetCurrentFile().Write()
    out_signal_tree.GetCurrentFile().Close()

    out_bkg.cd()
    h_bkg_simple.Write()
    h_bkg_adv.Write()
    out_bkg_tree3.GetCurrentFile().Write()
    out_bkg_tree3.GetCurrentFile().Close()
    
    print 'done writing output'
def rewrite_tree(oldfile, newname):
    f = ROOT.TFile.Open(oldfile)
    oldtree = f.Get('NOMINAL')
    gROOT.ProcessLine("struct MyStruct {\
       Int_t     fEvent;\
       Double_t    fNOMINAL_pileup_combined_weight;\
       Double_t    fcross_section;\
       Double_t    ffilter_efficiency;\
       Double_t    fkfactor;\
       Double_t    fweight_mc;\
       Double_t    fPt;\
       Double_t    fmetE;\
       Double_t    fdPhi;\
       Double_t    fPhiMiss;\
       Double_t    fMt;\
       Double_t    fEta;\
    };")
    from ROOT import MyStruct
    mystruct = MyStruct()
    f1 = TFile('/eos/user/g/gtolkach/data/' + newname, 'RECREATE')
    tree = TTree('NOMINAL', 'Just A Tree')
    tree.Branch('event', mystruct, 'fEvent/I')

    if oldfile.find('data_mu') == -1:
        tree.Branch('NOMINAL_pileup_combined_weight',
                    AddressOf(mystruct, 'fNOMINAL_pileup_combined_weight'),
                    'fNOMINAL_pileup_combined_weight/D')
        tree.Branch('cross_section', AddressOf(mystruct, 'fcross_section'),
                    'fcross_section/D')
        tree.Branch('filter_efficiency',
                    AddressOf(mystruct, 'ffilter_efficiency'),
                    'ffilter_efficiency/D')
        tree.Branch('kfactor', AddressOf(mystruct, 'fkfactor'), 'fkfactor/D')
        tree.Branch('kweight_mc', AddressOf(mystruct, 'fweight_mc'),
                    'fweight_mc/D')

    tree.Branch('Pt', AddressOf(mystruct, 'fPt'), 'fPt/D')
    tree.Branch('metE', AddressOf(mystruct, 'fmetE'), 'fmetE/D')
    tree.Branch('dPhi', AddressOf(mystruct, 'fdPhi'), 'fdPhi/D')
    tree.Branch('PhiMiss', AddressOf(mystruct, 'fPhiMiss'), 'fPhiMiss/D')
    tree.Branch('Mt', AddressOf(mystruct, 'fMt'), 'fMt/D')
    tree.Branch('Eta', AddressOf(mystruct, 'fEta'), 'fEta/D')

    cutflowhisto = ROOT.TH1D("cutflow", ";Cut;Event", 5, 1, 6)
    cutflowhisto.GetXaxis().SetBinLabel(1, "All")
    cutflowhisto.GetXaxis().SetBinLabel(2, "charge")
    cutflowhisto.GetXaxis().SetBinLabel(3, "medium ")
    cutflowhisto.GetXaxis().SetBinLabel(4, "isoTight")
    cutflowhisto.GetXaxis().SetBinLabel(5, "n_bjets")

    for i in range(0, oldtree.GetEntries()):
        #    for i in range(0, 60000):
        oldtree.GetEntry(i)
        mystruct.fEvent = i
        cutflowhisto.Fill(1)
        #cuts
        if not (oldtree.lep_0_q == -1):
            continue
        cutflowhisto.Fill(2)
        if not (oldtree.lep_0_id_medium == 1):
            continue
        cutflowhisto.Fill(3)

        if not (oldtree.lep_0_iso_FCTight == 1):
            continue

        cutflowhisto.Fill(4)
        if not (oldtree.n_bjets == 0):
            continue
        cutflowhisto.Fill(5)

        #        if oldfile.find('data_mu') != -1:
        #            if not(oldtree.lep_0_q == -1):
        #                continue
        #            print(oldtree.lep_0_q)
        #            mystruct.fPt = oldtree.lep_0_p4_fast.Pt()
        #            mystruct.fmetE = oldtree.met_reco_p4_fast.E()
        #            if math.fabs(oldtree.lepmet_dphi) > 3.14159:
        #                 mystruct.fdPhi = 2*3.14159 - math.fabs(oldtree.lepmet_dphi)
        #            else:
        #                mystruct.fdPhi = math.fabs(oldtree.lepmet_dphi)
        #            mystruct.fPhiMiss = oldtree.met_reco_p4_fast.Phi()
        #            mystruct.fMt = oldtree.lepmet_mt
        #            mystruct.fEta = oldtree.lep_0_p4_fast.Eta()
        #
        #        if oldfile.find('data_mu') == -1:
        #        mystruct.fNOMINAL_pileup_combined_weight = oldtree.NOMINAL_pileup_combined_weight
        #        mystruct.fcross_section = oldtree.cross_section
        #        mystruct.ffilter_efficiency = oldtree.filter_efficiency
        #        mystruct.fkfactor = oldtree.kfactor
        #        mystruct.fweight_mc = oldtree.weight_mc
        mystruct.fPt = oldtree.lep_0_p4_fast.Pt()
        mystruct.fmetE = oldtree.met_reco_p4_fast.E()
        if math.fabs(oldtree.lepmet_dphi) > 3.14159:
            mystruct.fdPhi = 2 * 3.14159 - math.fabs(oldtree.lepmet_dphi)
        else:
            mystruct.fdPhi = math.fabs(oldtree.lepmet_dphi)
        mystruct.fPhiMiss = oldtree.met_reco_p4_fast.Phi()
        mystruct.fMt = oldtree.lepmet_mt
        mystruct.fEta = oldtree.lep_0_p4_fast.Eta()

        tree.Fill()
    if oldfile.find('data_mu') == -1:
        h_metadata = f.Get('h_metadata')
        h_metadata.Write()
    c1 = ROOT.TCanvas()
    cutflowhisto.Draw()
    c1.Draw()
    c1.SaveAs('hist.pdf')

    f1.Write()
    f.Close()
    f1.Close()
Example #45
0
# For events in the train set, we set the discriminator to -1
# to avoid accidentally reusing the training set in the analysis.
out_signal_name = os.path.basename(signalFileName).replace(
    '.root', '_BDT.root')
out_signal = root.TFile(out_signal_name, 'RECREATE')
out_signal_tree = signalTree.CloneTree(0)

out_bkg_name = os.path.basename(bkgFileName).replace('.root', '_BDT.root')
out_bkg = root.TFile(out_bkg_name, 'RECREATE')
out_bkg_tree = bkgTree.CloneTree(0)

# This is the boilerplate code for writing something
# to a ROOT tree from Python.
root.gROOT.ProcessLine("struct MyStruct{float disc;};")
from ROOT import MyStruct
s = MyStruct()
disc_branch_sig = out_signal_tree.Branch('disc', root.AddressOf(s, 'disc'),
                                         'disc/F')
disc_branch_bkg = out_bkg_tree.Branch('disc', root.AddressOf(s, 'disc'),
                                      'disc/F')

print "Writing new ROOT signal file with discriminator appended"
fill_discriminator(signalTree, out_signal_tree, disc_lookup_signal, s)
print "Writing new ROOT background file with discriminator appended"
fill_discriminator(bkgTree, out_bkg_tree, disc_lookup_bkg, s)

# Cristian's code uses GetCurrentFile() for this part.
# I will do that too just in case (paranoia).
out_signal.cd()
out_signal_tree.GetCurrentFile().Write()
#signalNevents.Write()
from random import shuffle

##############################
######### GENERATION #########
##############################

gROOT.ProcessLine(
                  "struct MyStruct {\
                  Float_t     f_muonMass1;\
                  Float_t     f_muonMass2;\
                  Float_t     f_muonMass3;\
                  Float_t     f_muonMass4;\
                  };" )

from ROOT import MyStruct
mystruct = MyStruct()

f = TFile( 'ZBosonNtuple.root', 'RECREATE' )
tree = TTree( 'T', 'Z Boson Data' )
tree.Branch( 'muons', mystruct, 'f_muonMass1/F:f_muonMass2:f_muonMass3:f_muonMass4' )

rand = TRandom()

muonMass = {}

for i in range(10000):
    muonMass[0] = rand.Exp(30)*90
    muonMass[1] = abs(rand.Gaus(91.2,1.3) - muonMass[0])
    muonMass[2] = rand.Exp(30)
    muonMass[3] = rand.Exp(30)
    
Example #47
0
nEntries = ch.GetEntries()
print "nEntries = ", nEntries
#*****set brances*****
#set branche satus, at first, all off
#event information
#new tree
outFile = FileName + '_HH_no_PNet_Discriminator.root'
newFile = root.TFile(outFile, "RECREATE")
ch_new = ch.CloneTree(0)

root.gROOT.ProcessLine("struct MyStruct{float disc_hh;};")

from ROOT import MyStruct

# Create branches in the tree
s = MyStruct()

bpt = ch_new.Branch('disc_hh', root.AddressOf(s, 'disc_hh'), 'disc_hh/F')

for i in range(nEntries):
    ch.GetEntry(i)
    if i % 10000 == 0:
        print "Processing event nr. %i of %i" % (i, nEntries)
    s.disc_hh = disc[i]
    ch_new.Fill()
ch_new.Print()
# use GetCurrentFile just in case we went over the
# (customizable) maximum file size
ch_new.GetCurrentFile().Write()
Nevents.Write()
ch_new.GetCurrentFile().Close()
Example #48
0
PID_v = r.vector('Int_t')()
P_X_v = r.vector('Double_t')()
P_Y_v =r.vector('Double_t')()
P_Z_v =r.vector('Double_t')()
E_v =r.vector('Double_t')()
M_v =r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine(\
          "struct MyStruct{\
Int_t n_particles;\
};")
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct()
output_tree.Branch('n_particles',AddressOf(s,'n_particles'),'n_particles/I')
output_tree.Branch("PID",PID_v)
output_tree.Branch("P_X",P_X_v)
output_tree.Branch("P_Y",P_Y_v)
output_tree.Branch("P_Z",P_Z_v)
output_tree.Branch("E",E_v)
output_tree.Branch("M",M_v)

in_ev = 0 # To know when to look for particles we must know when we are inside an event
in_ev_1 = 0 # The first line after <event> is information so we must skip that as well
s.n_particles = 0
for line in input_file:
    if line[:1] == "#":
        continue
    
Example #49
0
  else:
    return float('nan')

structString = "struct MyStruct{ULong_t event;"
for var in variables:
  structString +="Float_t "+var+";"

for var in extraVariables:
  structString +="Float_t "+var+";"

structString   +="};"
ROOT.gROOT.ProcessLine(structString)

from ROOT import MyStruct

s = MyStruct()

def getReweightingHisto(filename=""):
  if filename=="":
    return ""
  rf = ROOT.TFile(filename)
  htmp = rf.Get("ngoodVertices_Data")
  ROOT.gDirectory.cd("PyROOT:/")
  rwHisto = htmp.Clone()
  rf.Close()
  return rwHisto


from defaultMu2012Samples import dy, wjetsInc, ttbar, ttbarPowHeg,  stop, getSignal

T1tttt = {}
def btagEfficiencyTreeProducer(stageName="Z+jet", output="mybtagEfftree.root", path='../testfiles/'):
  #search for category number
  stage=-1
  liststage = []
  for cat in categoryNames :
    stage+=1
    if stageName in cat : liststage.append(stage)
  print "Will run on stages: "
  for ls in liststage : print categoryNames[ls]
  # prepare output
  #path='/nfs/user/llbb/Pat_8TeV_ReReco/Summer12_DYjets/pat53_1.root'
  ROOT.gROOT.ProcessLine(
  "struct MyStruct {\
     Float_t     pt;\
     Float_t     eta;\
     Int_t       flavor;\
     Float_t     ssvhe;\
     Float_t     ssvhp;\
     Float_t     csv;\
     Float_t     jbp;\
     Float_t     jp;\
     Float_t     csvv1;\
     Float_t     ivfhe;\
     Float_t     ivfhp;\
     Float_t     sv2;\
     Float_t     csvivf;\
     Float_t     csvv1sl;\
     Float_t     eventWeight;\
     Float_t     CSVMWeight;\
  };" )
  from ROOT import MyStruct
  mystruct = MyStruct()
  f = ROOT.TFile( output, 'RECREATE' )
  tree = ROOT.TTree( 'btagEff', 'btag efficiency' )
  tree.Branch( 'data', mystruct, 'pt/F:eta/F:flavor/I:ssvhe/F:ssvhp/F:csv/F:jbp/F:jp/F:csvv1/F:ivfhe/F:ivfhp/F:sv2/F:csvivf/F:csvv1sl/F:eventWeight/F:CSVMWeight/F' )
  # input
  if os.path.isdir(path):
    dirList=os.listdir(path)
    files=[]
    for fname in dirList:
      files.append(path+fname)
  elif os.path.isfile(path):
    files=[path]
  else:
    files=[]
  events = AnalysisEvent(files)
  EventSelection.prepareAnalysisEvent(events)
  # event loop
  eventCnt = 0
  print "starting loop on events"
  for event in events:
    categoryData = event.category
    goodJets = event.goodJets_all
    Pass = 0
    for ls in liststage:
      if isInCategory(ls, categoryData) : Pass+=1
    if Pass>0:
      eventCnt = eventCnt +1
      if eventCnt%100==0 : print ".",
      if eventCnt%1000==0 : print eventCnt
      # event weight
      mystruct.eventWeight = event.weight(weightList=["PileUp"])
      # that's where we access the jets
      for index,jet in enumerate(event.jets):
        if not goodJets[index]: continue
        mystruct.pt = jet.pt()
        mystruct.eta = jet.eta()
        mystruct.flavor = jet.partonFlavour()
        mystruct.ssvhe = jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags")
        mystruct.ssvhp = jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags")
        mystruct.csv = jet.bDiscriminator("combinedSecondaryVertexBJetTags")
        mystruct.jbp = jet.bDiscriminator("jetBProbabilityBJetTags")
        mystruct.jp = jet.bDiscriminator("jetProbabilityBJetTags")
        mystruct.csvv1 = jet.bDiscriminator("combinedSecondaryVertexV1BJetTags")
        mystruct.ivfhe = jet.bDiscriminator("simpleInclusiveSecondaryVertexHighEffBJetTags")
        mystruct.ivfhp = jet.bDiscriminator("simpleInclusiveSecondaryVertexHighPurBJetTags")
        mystruct.sv2 = jet.bDiscriminator("doubleSecondaryVertexHighEffBJetTags")
        mystruct.csvivf = jet.bDiscriminator("combinedInclusiveSecondaryVertexBJetTags")
        mystruct.csvv1sl = jet.bDiscriminator("combinedSecondaryVertexSoftPFLeptonV1BJetTags")
        btagW.myJetSet.reset()
        btagW.myJetSet.addJet(configuration.SF_uncert, jet.partonFlavour(),jet.pt(),jet.eta(), btagW.algo1, btagW.algo2)
        mystruct.CSVMWeight = btagW.getWeight(btagW.myJetSet, 1, 1)
        tree.Fill()
  f.Write()
  f.Close()
  print ""
def writeXsecTree(box, model, directory, mg, mchi, xsecULObs, xsecULExpPlus2, xsecULExpPlus, xsecULExp, xsecULExpMinus, xsecULExpMinus2):
    outputFileName = "%s/%s_xsecUL_mg_%s_mchi_%s_%s.root" %(directory, model, mg, mchi, box)
    print "INFO: xsec UL values being written to %s"%outputFileName
    fileOut = rt.TFile.Open(outputFileName, "recreate")
    
    xsecTree = rt.TTree("xsecTree", "xsecTree")
    try:
        from ROOT import MyStruct
    except ImportError:
        myStructCmd = "struct MyStruct{Double_t mg;Double_t mchi; Double_t x; Double_t y;"
        ixsecUL = 0
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+0)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+1)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+2)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+3)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+4)
        myStructCmd+= "Double_t xsecUL%i;"%(ixsecUL+5)
        ixsecUL+=6
        myStructCmd += "}"
        rt.gROOT.ProcessLine(myStructCmd)
        from ROOT import MyStruct

    s = MyStruct()
    xsecTree.Branch("mg", rt.AddressOf(s,"mg"),'mg/D')
    xsecTree.Branch("mchi", rt.AddressOf(s,"mchi"),'mchi/D')
    xsecTree.Branch("x", rt.AddressOf(s,"x"),'x/D')
    xsecTree.Branch("y", rt.AddressOf(s,"y"),'y/D')
    
    
    s.mg = mg
    s.mchi = mchi
    if 'T1x' in model:
        s.x = float(model[model.find('x')+1:model.find('y')].replace('p','.'))
        s.y = float(model[model.find('y')+1:].replace('p','.'))
    elif model == 'T1bbbb':
        s.x = 1
        s.y = 0
    elif model == 'T1tttt':
        s.x = 0
        s.y = 1
    else:
        s.x = -1
        s.y = -1
    
    ixsecUL = 0
    xsecTree.Branch("xsecULObs_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+0)),'xsecUL%i/D'%(ixsecUL+0))
    xsecTree.Branch("xsecULExpPlus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+1)),'xsecUL%i/D'%(ixsecUL+1))
    xsecTree.Branch("xsecULExpPlus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+2)),'xsecUL%i/D'%(ixsecUL+2))
    xsecTree.Branch("xsecULExp_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+3)),'xsecUL%i/D'%(ixsecUL+3))
    xsecTree.Branch("xsecULExpMinus_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+4)),'xsecUL%i/D'%(ixsecUL+4))
    xsecTree.Branch("xsecULExpMinus2_%s"%box, rt.AddressOf(s,"xsecUL%i"%(ixsecUL+5)),'xsecUL%i/D'%(ixsecUL+5))
    exec 's.xsecUL%i = xsecULObs[ixsecUL]'%(ixsecUL+0)
    exec 's.xsecUL%i = xsecULExpPlus2[ixsecUL]'%(ixsecUL+1)
    exec 's.xsecUL%i = xsecULExpPlus[ixsecUL]'%(ixsecUL+2)
    exec 's.xsecUL%i = xsecULExp[ixsecUL]'%(ixsecUL+3)
    exec 's.xsecUL%i = xsecULExpMinus[ixsecUL]'%(ixsecUL+4)
    exec 's.xsecUL%i = xsecULExpMinus2[ixsecUL]'%(ixsecUL+5)
    ixsecUL += 4

    xsecTree.Fill()

    fileOut.cd()
    xsecTree.Write()
    
    fileOut.Close()
    
    return outputFileName
Example #52
0
nEntries = ch.GetEntries()
print "nEntries = ", nEntries
#*****set brances*****
#set branche satus, at first, all off
#event information
#new tree
outFile = FileName + '_ttZDiscriminator.root'
newFile = root.TFile(outFile, "RECREATE")
ch_new = ch.CloneTree(0)

root.gROOT.ProcessLine("struct MyStruct{float disc_ttZ;};")

from ROOT import MyStruct

# Create branches in the tree
s = MyStruct()

bpt = ch_new.Branch('disc_ttZ', root.AddressOf(s, 'disc_ttZ'), 'disc_ttZ/F')

for i in range(nEntries):
    ch.GetEntry(i)
    if i % 10000 == 0:
        print "Processing event nr. %i of %i" % (i, nEntries)
    s.disc_ttZ = disc[i]
    ch_new.Fill()
ch_new.Print()
# use GetCurrentFile just in case we went over the
# (customizable) maximum file size
ch_new.GetCurrentFile().Write()
Nevents.Write()
ch_new.GetCurrentFile().Close()
Example #53
0
P_X_v = r.vector('Double_t')()
P_Y_v = r.vector('Double_t')()
P_Z_v = r.vector('Double_t')()
E_v = r.vector('Double_t')()
M_v = r.vector('Double_t')()
P4_v = r.vector('ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float>>')()
Wgt_v = r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine("struct MyStruct{ Int_t n_particles; };")
gROOT.ProcessLine("struct MyFloat{ Float_t weight; };")
from ROOT import MyStruct
from ROOT import MyFloat

# Assign the variables to the struct
s = MyStruct()
event_wgt = MyFloat()
output_tree.Branch('n_particles', AddressOf(s, 'n_particles'), 'n_particles/I')
output_tree.Branch("PID", PID_v)
output_tree.Branch("P_X", P_X_v)
output_tree.Branch("P_Y", P_Y_v)
output_tree.Branch("P_Z", P_Z_v)
output_tree.Branch("E", E_v)
output_tree.Branch("M", M_v)
output_tree.Branch("P4", P4_v)
output_tree.Branch("Wgt", Wgt_v)
output_tree.Branch('event_wgt', AddressOf(event_wgt, 'weight'), 'event_wgt/F')

in_ev = 0  # To know when to look for particles we must know when we are inside an event
in_ev_1 = 0  # The first line after <event> is information so we must skip that as well
in_wgt = 0  # To know when to look for weights we must know when we are inside an event
outputFile = root.TFile(outputFilename, "RECREATE")
outputFile.cd()
outputTree = inputTree.CloneTree(0)

nEntries = inputTree.GetEntries()
print("nEntries = ", nEntries)
_disc_var_name = 'disc_' + _bkg_type + '_' + _year + '_' + _bdt_type

root.gROOT.ProcessLine("struct MyStruct{float disc;};")
from ROOT import MyStruct

nSamplings = 100
random = root.TRandom3(1000)

# Create branches in the tree
my_s = MyStruct()
my_s_JESUp = MyStruct()
my_s_JESDown = MyStruct()
my_s_JMSUp = MyStruct()
my_s_JMSDown = MyStruct()
my_s_JMRUp = MyStruct()
my_s_JMRDown = MyStruct()

#print(my_s)
#print (root.addressof(my_s))
#print (root.addressof(my_s,'disc'))
#root.addressof(my_s,'disc')

branch_disc = outputTree.Branch(_disc_var_name, root.addressof(my_s, 'disc'),
                                _disc_var_name + '/F')
branch_disc_JESUp = outputTree.Branch(_disc_var_name + "_JESUp",
Example #55
0
def main1TrackMVA(_name="Lb_Lcmunu_MagUp.root"):

    #---Get the Track Reconstruction Efficiency correction factor
    Correction = 1. / 1.035  #This is a number I get from LHCb-PUB-2015-024

    #---Set the random number generator, but seed it for reproducibility
    random.seed(0)

    #_name = "tupleoutMC_trackeronly_v19"
    fin = r.TFile.Open(_name, "READ")
    tin = fin.Get("tupleout/DecayTree")

    for br in ["nVeloClusters", "nITClusters", "nOTClusters", "nPVs"]:
        tin.SetBranchStatus(br, 1)

    for br in [
            "Lb_TRACK_NDOF_DAU*", "Lb_PT_DAU*", "Lb_P_DAU*",
            "Lb_IPCHI2_OWNPV_DAU*", "Lb_TRACK_GHOSTPROB_DAU*",
            "Lb_TRACK_CHI2_DAU*"
    ]:
        tin.SetBranchStatus(br, 1)

    for br in ["*COMB*", "Lb_HLt1TwoTrackMVAEmulations*"]:
        tin.SetBranchStatus(br, 1)

    for head in ["mu", "K", "pi", "p"]:
        for br in ["PT", "IPCHI2_OWNPV", "PX", "PY", "PZ", "PT", "P"]:
            tin.SetBranchStatus(head + "_" + br, 1)

    fout = r.TFile.Open(_name[:-5] + '_wHLT1OneTrackEmulation.root',
                        'RECREATE')
    tout = r.TTree("DecayTree", "DecayTree")

    r.gROOT.ProcessLine("struct MyStruct0{Bool_t abool;};")
    r.gROOT.ProcessLine("struct MyStruct{Int_t aint;};")
    r.gROOT.ProcessLine("struct MyStruct2{Float_t afloat;};")
    from ROOT import MyStruct0
    from ROOT import MyStruct
    from ROOT import MyStruct2

    isGECPassed = MyStruct0()
    isTrackPassed_K = MyStruct0()
    isTrackPassed_p = MyStruct0()
    isTrackPassed_pi = MyStruct0()
    isAdditional_K = MyStruct0()
    isAdditional_p = MyStruct0()
    isAdditional_pi = MyStruct0()
    isPassed_K = MyStruct0()
    isPassed_p = MyStruct0()
    isPassed_pi = MyStruct0()
    isTrackReco_K = MyStruct0()
    isTrackReco_p = MyStruct0()
    isTrackReco_pi = MyStruct0()
    HLT1TrackMVA_TOS_K = MyStruct0()
    HLT1TrackMVA_TOS_p = MyStruct0()
    HLT1TrackMVA_TOS_pi = MyStruct0()
    HLT1TrackMVA_TOS_Corr_K = MyStruct0()
    HLT1TrackMVA_TOS_Corr_p = MyStruct0()
    HLT1TrackMVA_TOS_Corr_pi = MyStruct0()

    Lc_HLT1TrackMVA_Emu_TOS = MyStruct()
    Lc_HLT1TrackMVA_Emu_EffCorrected_TOS = MyStruct()

    Lc_HLT1TwoTrackMVA_Emu_TOS = MyStruct()
    Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS = MyStruct()

    mu_Phi = MyStruct2()
    K_Phi = MyStruct2()
    pi_Phi = MyStruct2()
    p_Phia = MyStruct2()

    mu_Theta = MyStruct2()
    K_Theta = MyStruct2()
    pi_Theta = MyStruct2()
    p_Theta = MyStruct2()

    isGECPassed_branch = tout.Branch("isGECPassed",
                                     r.AddressOf(isGECPassed, 'abool'),
                                     "isGECPassed/B")

    isTrackPassed_branch_K = tout.Branch("isTrackPassed_K",
                                         r.AddressOf(isTrackPassed_K, 'abool'),
                                         "isTrackPassed_K/B")
    isTrackPassed_branch_p = tout.Branch("isTrackPassed_p",
                                         r.AddressOf(isTrackPassed_p, 'abool'),
                                         "isTrackPassed_p/B")
    isTrackPassed_branch_pi = tout.Branch(
        "isTrackPassed_pi", r.AddressOf(isTrackPassed_pi, 'abool'),
        "isTrackPassed_pi/B")

    isAdditional_branch_K = tout.Branch("isAdditional_K",
                                        r.AddressOf(isAdditional_K, 'abool'),
                                        "isAdditional_K/B")
    isAdditional_branch_p = tout.Branch("isAdditional_p",
                                        r.AddressOf(isAdditional_p, 'abool'),
                                        "isAdditional_p/B")
    isAdditional_branch_pi = tout.Branch("isAdditional_pi",
                                         r.AddressOf(isAdditional_pi, 'abool'),
                                         "isAdditional_pi/B")

    isPassed_branch_K = tout.Branch("isPassed_K",
                                    r.AddressOf(isPassed_K, 'abool'),
                                    "isPassed_K/B")
    isPassed_branch_p = tout.Branch("isPassed_p",
                                    r.AddressOf(isPassed_p, 'abool'),
                                    "isPassed_p/B")
    isPassed_branch_pi = tout.Branch("isPassed_pi",
                                     r.AddressOf(isPassed_pi, 'abool'),
                                     "isPassed_pi/B")

    isTrackReco_branch_K = tout.Branch("isTrackReco_K",
                                       r.AddressOf(isTrackReco_K, 'abool'),
                                       "isTrackReco_K/B")
    isTrackReco_branch_p = tout.Branch("isTrackReco_p",
                                       r.AddressOf(isTrackReco_p, 'abool'),
                                       "isTrackReco_p/B")
    isTrackReco_branch_pi = tout.Branch("isTrackReco_pi",
                                        r.AddressOf(isTrackReco_pi, 'abool'),
                                        "isTrackReco_pi/B")

    HLT1TrackMVA_Emu_TOS_branch_K = tout.Branch(
        "HLT1TrackMVA_TOS_K", r.AddressOf(HLT1TrackMVA_TOS_K, 'abool'),
        "HLT1TrackMVA_TOS_K/B")
    HLT1TrackMVA_Emu_TOS_branch_p = tout.Branch(
        "HLT1TrackMVA_TOS_p", r.AddressOf(HLT1TrackMVA_TOS_p, 'abool'),
        "HLT1TrackMVA_TOS_p/B")
    HLT1TrackMVA_Emu_TOS_branch_pi = tout.Branch(
        "HLT1TrackMVA_TOS_pi", r.AddressOf(HLT1TrackMVA_TOS_pi, 'abool'),
        "HLT1TrackMVA_TOS_pi/B")

    HLT1TrackMVA_Emu_TOS_Corr_branch_K = tout.Branch(
        "HLT1TrackMVA_TOS_Corr_K", r.AddressOf(HLT1TrackMVA_TOS_Corr_K,
                                               'abool'),
        "HLT1TrackMVA_TOS_Corr_K/B")
    HLT1TrackMVA_Emu_TOS_Corr_branch_p = tout.Branch(
        "HLT1TrackMVA_TOS_Corr_p", r.AddressOf(HLT1TrackMVA_TOS_Corr_p,
                                               'abool'),
        "HLT1TrackMVA_TOS_Corr_p/B")
    HLT1TrackMVA_Emu_TOS_Corr_branch_pi = tout.Branch(
        "HLT1TrackMVA_TOS_Corr_pi",
        r.AddressOf(HLT1TrackMVA_TOS_Corr_pi, 'abool'),
        "HLT1TrackMVA_TOS_Corr_pi/B")

    Lc_HLT1TrackMVA_Emu_TOS_branch = tout.Branch(
        "Lc_HLT1TrackMVA_Emu_TOS", r.AddressOf(Lc_HLT1TrackMVA_Emu_TOS,
                                               'aint'),
        "Lc_HLT1TrackMVA_Emu_TOS/I")
    Lc_HLT1TrackMVA_Emu_EffCorrected_TOS_branch = tout.Branch(
        "Lc_HLT1TrackMVA_Emu_EffCorrected_TOS",
        r.AddressOf(Lc_HLT1TrackMVA_Emu_EffCorrected_TOS, 'aint'),
        "Lc_HLT1TrackMVA_Emu_EffCorrected_TOS/I")

    Lc_HLT1TwoTrackMVA_Emu_TOS_branch = tout.Branch(
        "Lc_HLT1TwoTrackMVA_Emu_TOS",
        r.AddressOf(Lc_HLT1TwoTrackMVA_Emu_TOS, 'aint'),
        "Lc_HLT1TwoTrackMVA_Emu_TOS/I")
    Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS_branch = tout.Branch(
        "Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS",
        r.AddressOf(Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS, 'aint'),
        "Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS/I")

    mu_Phi_branch = tout.Branch("mu_Phi", r.AddressOf(mu_Phi, "afloat"),
                                "mu_Phi/F")
    K_Phi_branch = tout.Branch("K_Phi", r.AddressOf(K_Phi, "afloat"),
                               "K_Phi/F")
    pi_Phi_branch = tout.Branch("pi_Phi", r.AddressOf(pi_Phi, "afloat"),
                                "pi_Phi/F")
    p_Phi_branch = tout.Branch("p_Phi", r.AddressOf(p_Phia, "afloat"),
                               "p_Phi/F")

    mu_Theta_branch = tout.Branch("mu_Theta", r.AddressOf(mu_Theta, "afloat"),
                                  "mu_Theta/F")
    K_Theta_branch = tout.Branch("K_Theta", r.AddressOf(K_Theta, "afloat"),
                                 "K_Theta/F")
    pi_Theta_branch = tout.Branch("pi_Theta", r.AddressOf(pi_Theta, "afloat"),
                                  "pi_Theta/F")
    p_Theta_branch = tout.Branch("p_Theta", r.AddressOf(p_Theta, "afloat"),
                                 "p_Theta/F")

    #-------------------------------------------------------------------------------------------------------------

    NEvents = tin.GetEntries()

    i = 0
    print("Processing events ...")
    for ev in tin:
        if (i % 1000 == 0):
            sys.stdout.write("\rProcessed " +
                             str(round(float(i) / NEvents * 100, 2)) + "%")
            sys.stdout.flush()
        #if (i == 15000):
        #    break

        Lc_HLT1TrackMVA_Emu_TOS.aint = 0
        Lc_HLT1TrackMVA_Emu_EffCorrected_TOS.aint = 0

        Lc_HLT1TwoTrackMVA_Emu_TOS.aint = 0
        Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS.aint = 0

        mu_Phi.afloat = 0
        K_Phi.afloat = 0
        pi_Phi.afloat = 0
        p_Phia.afloat = 0

        mu_Theta.afloat = 0
        K_Theta.afloat = 0
        pi_Theta.afloat = 0
        p_Theta.afloat = 0

        #------------------------------------------------------------------------------

        #---Global event decisions
        GECvariables = GetGECVariables(ev)
        IsGECPassed = GECDecision(GECvariables)
        isGECPassed.abool = IsGECPassed

        #---Save all needed informations once for all
        Variables_vec = {}
        AdditionalVariables_vec = {}
        TwoTrackVariables_vec = {}

        for head in ["DAU_1", "DAU_2", "DAU_3", "DAU_4"]:
            Variables_vec[head] = GetVariables(head, ev)
            AdditionalVariables_vec[head] = AdditionalVariables(
                ev, head, Correction)

        for head in ["1_2", "1_3", "1_4", "2_3", "2_4", "3_4"]:
            TwoTrackVariables_vec[head] = GetTwoTrackVariables(ev, head)

        #---Single particle decisions
        for head in ["DAU_1", "DAU_2", "DAU_3"]:
            IsTrackPassed = TrackInputDecision(Variables_vec[head])
            IsAdditional = TrackAdditionalDecision(
                AdditionalVariables_vec[head])
            IsPassed = TrackMVADecision(Variables_vec[head])
            IsTrackReconstructed = TrackReconstructedDecision(
                AdditionalVariables_vec[head])
            if head == "DAU_1":
                isTrackPassed_K.abool = IsTrackPassed
                isAdditional_K.abool = IsAdditional
                isPassed_K.abool = IsPassed
                isTrackReco_K.abool = IsTrackReconstructed
            if head == "DAU_2":
                isTrackPassed_p.abool = IsTrackPassed
                isAdditional_p.abool = IsAdditional
                isPassed_p.abool = IsPassed
                isTrackReco_p.abool = IsTrackReconstructed
            if head == "DAU_3":
                isTrackPassed_pi.abool = IsTrackPassed
                isAdditional_pi.abool = IsAdditional
                isPassed_pi.abool = IsPassed
                isTrackReco_pi.abool = IsTrackReconstructed

            if (IsTrackReconstructed and IsPassed and IsGECPassed
                    and IsTrackPassed and IsAdditional):
                Lc_HLT1TrackMVA_Emu_EffCorrected_TOS.aint = 1
            if (IsPassed and IsGECPassed and IsTrackPassed and IsAdditional):
                Lc_HLT1TrackMVA_Emu_TOS.aint = 1
        '''


            #---Two particle decisions
            for k in range(1,3):
                    j = k+1
                    while (j<=3):

                            combination  = str(k)+"_"+str(j)

                            variables_k           = Variables_vec["DAU_"+str(k)]
                            variables_j           = Variables_vec["DAU_"+str(j)]

                            AdditionalVariables_k = AdditionalVariables_vec["DAU_"+str(k)]
                            AdditionalVariables_j = AdditionalVariables_vec["DAU_"+str(j)]

                            IsTrackPassed_k       = TrackInputDecision(variables_k)
                            IsTrackPassed_j       = TrackInputDecision(variables_j)

                            IsTrackPassed  = IsTrackPassed_k and IsTrackPassed_j
                    
                            IsAdditional_k        = TrackAdditionalDecision(AdditionalVariables_k)
                            IsAdditional_j        = TrackAdditionalDecision(AdditionalVariables_j)

                            IsAdditional   = IsAdditional_k and IsAdditional_j

                            IsInputPassed_k = TwoTrackInputDecision(variables_k)
                            IsInputPassed_j = TwoTrackInputDecision(variables_j)

                            IsInputPassed                 = IsInputPassed_k and IsInputPassed_j

                            variables_comb                = TwoTrackVariables_vec[combination]

                            IsPassed              = TwoTrackMVADecision(variables_comb)

                            IsTrackReconstructed_k  = TrackReconstructedDecision(AdditionalVariables_k)
                            IsTrackReconstructed_j  = TrackReconstructedDecision(AdditionalVariables_j)

                            IsTrackReconstructed = IsTrackReconstructed_k and IsTrackReconstructed_j

                            if (IsPassed                    and IsInputPassed              and IsGECPassed and IsTrackPassed and IsAdditional):
                                    Lc_HLT1TwoTrackMVA_Emu_TOS.aint = 1

                            if (IsTrackReconstructed and IsPassed                and IsInputPassed  and IsGECPassed and IsTrackPassed and IsAdditional):
                                    Lc_HLT1TwoTrackMVA_Emu_EffCorrected_TOS.aint = 1

                            j = j+1

            #-----Fill the additional variables
            mu_Phi.afloat  = math.atan(getattr(tin, "mu_PY")  / getattr(tin, "mu_PX" ))
            K_Phi.afloat   = math.atan(getattr(tin, "K_PY")   / getattr(tin, "K_PX"  ))
            p_Phia.afloat = math.atan(getattr(tin, "p_PY") / getattr(tin, "p_PX"))
            pi_Phi.afloat = math.atan(getattr(tin, "pi_PY") / getattr(tin, "pi_PX"))

            mu_Theta.afloat  = math.acos(getattr(tin, "mu_PZ")  / getattr(tin, "mu_P" ))
            K_Theta.afloat   = math.acos(getattr(tin, "K_PZ")   / getattr(tin, "K_P"  ))
            p_Theta.afloat = math.acos(getattr(tin, "p_PZ") / getattr(tin, "p_P"))
            pi_Theta.afloat = math.acos(getattr(tin, "pi_PZ") / getattr(tin, "pi_P"))
            '''

        i = i + 1
        tout.Fill()
    print("\nAll events processed.")
    tout.Write()
    fout.Close()
    fin.Close()
Example #56
0
# Setup output branches
Layer_v = r.vector('Int_t')()
Sector_v = r.vector('Int_t')()
Id_v  = r.vector('Int_t')()
Edep_v =r.vector('Double_t')()
X_v = r.vector('Double_t')()
Y_v =r.vector('Double_t')()
Z_v =r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine( "struct MyStruct{ Int_t n_hits; Int_t PID_v; Double_t P_X_v; Double_t P_Y_v; Double_t P_Z_v;};")
from ROOT import MyStruct

# Assign the variables to the struct
s = MyStruct() 
output_tree.Branch('N_hits',AddressOf(s,'n_hits'),'n_hits/I')
output_tree.Branch("PID",AddressOf(s,'PID_v'),'PID_v/I')
output_tree.Branch("P_X",AddressOf(s,'P_X_v'),'P_X_v/D')
output_tree.Branch("P_Y",AddressOf(s,'P_Y_v'),'P_Y_v/D')
output_tree.Branch("P_Z",AddressOf(s,'P_Z_v'),'P_Z_v/D')
output_tree.Branch("Edep",Edep_v)
output_tree.Branch("X",X_v)
output_tree.Branch("Y",Y_v)
output_tree.Branch("Z",Z_v)
output_tree.Branch("Layer",Layer_v)
output_tree.Branch("Sector",Sector_v)
output_tree.Branch("Id",Id_v)
in_ev = 0 # To know when to look for particles we must know when we are inside an event
in_ev_1 = 0 # The first line after <event> is information so we must skip that as well
s.n_hits = 0