From ed143540d9338b8c522910e3f4b515e41a0987ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Tue, 20 Oct 2020 15:47:50 +0200 Subject: [PATCH 1/7] files for AP of CEP Jpsi->ll 2016,17,18 data ntuples --- CEP_Jpsi2ll/DVJpsiCEP_AP.py | 284 ++++ CEP_Jpsi2ll/DataTypes/2016.py | 2 + CEP_Jpsi2ll/DataTypes/2017.py | 2 + CEP_Jpsi2ll/DataTypes/2018.py | 2 + CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py | 4 + CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py | 4 + CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py | 4 + CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py | 4 + CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py | 4 + CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py | 4 + CEP_Jpsi2ll/DataTypes/real_data.py | 2 + CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py | 1262 ++++++++++++++++++ CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py | 490 +++++++ CEP_Jpsi2ll/DiLeptonTuple/__init__.py | 0 CEP_Jpsi2ll/README.md | 11 + CEP_Jpsi2ll/__init__.py | 0 CEP_Jpsi2ll/info.yaml | 75 ++ 17 files changed, 2154 insertions(+) create mode 100644 CEP_Jpsi2ll/DVJpsiCEP_AP.py create mode 100644 CEP_Jpsi2ll/DataTypes/2016.py create mode 100644 CEP_Jpsi2ll/DataTypes/2017.py create mode 100644 CEP_Jpsi2ll/DataTypes/2018.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py create mode 100644 CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py create mode 100644 CEP_Jpsi2ll/DataTypes/real_data.py create mode 100644 CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py create mode 100644 CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py create mode 100644 CEP_Jpsi2ll/DiLeptonTuple/__init__.py create mode 100644 CEP_Jpsi2ll/README.md create mode 100644 CEP_Jpsi2ll/__init__.py create mode 100644 CEP_Jpsi2ll/info.yaml diff --git a/CEP_Jpsi2ll/DVJpsiCEP_AP.py b/CEP_Jpsi2ll/DVJpsiCEP_AP.py new file mode 100644 index 0000000000..c961d1be40 --- /dev/null +++ b/CEP_Jpsi2ll/DVJpsiCEP_AP.py @@ -0,0 +1,284 @@ +from Configurables import DaVinci +# Define some global variables, change accordingly +year = DaVinci().DataType + +# Fill the chi_c_0,1,2 branches +fillChic = True + +# Print extended information about the trigger TISTOS decissions +allInfoTISTOS =False + +######################################################################################## +# Start making the ntuple +from Gaudi.Configuration import * + +from Configurables import CondDB +db = CondDB ( LatestGlobalTagByDataType = year ) + +MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M" +from Configurables import PrintHeader, PrintDecayTree, StoreExplorerAlg, FilterDesktop, CheckSelResult, CombineParticles, EventNodeKiller, createODIN, EventTuple, TupleToolStripping + +from PhysSelPython.Wrappers import Selection, DataOnDemand, SelectionSequence +from CommonParticles.Utils import * + +from Configurables import DiElectronMaker, ProtoParticleCALOFilter, DaVinciInit, TrackSelector +from Configurables import LoKi__HDRFilter +from GaudiKernel.SystemOfUnits import * +from PhysConf.Selections import ( StrippingSelection ) + +# Dielectron candidates +dieLL = DiElectronMaker('StdDiElectronFromTracks') +dieLL.Particle = "J/psi(1S)" +# selector = trackSelector ( dieLL , trackTypes = ["Long","Upstream"] ) +dieLL.addTool( TrackSelector, name='TrackSelector' ) +dieLL.TrackSelector.TrackTypes = ["Long"] +dieLL.addTool( ProtoParticleCALOFilter, name='Electron' ) +dieLL.Electron.Selection = ["RequiresDet='CALO' CombDLL(e-pi)>'-2.0'"] +dieLL.DiElectronMassMax = 8000.*MeV +dieLL.DiElectronMassMin = 100.*MeV +dieLL.DiElectronPtMin = 0.*MeV + +# Use upstream electrons too +""" +dieLL2 = DiElectronMaker('StdDiElectronFromTracks2') +dieLL2.Particle = "J/psi(1S)" +dieLL2.addTool( TrackSelector, name='TrackSelector' ) +dieLL2.TrackSelector.TrackTypes = ["Long","Upstream"] +dieLL2.addTool( ProtoParticleCALOFilter, name='Electron' ) +dieLL2.Electron.Selection = ["CombDLL(e-pi)>'-100'"] +dieLL2.DiElectronMassMax = 8000.*MeV +dieLL2.DiElectronMassMin = 100.*MeV +dieLL2.DiElectronPtMin = 0.*MeV +""" + +# Dimuon candidates +_StdLooseDiMuon = DataOnDemand( Location = 'Phys/StdLooseDiMuon/Particles' ) +_MuMu = FilterDesktop( "DiMuons", Code = "(M>0*MeV) & (M<8000*MeV)" ) + +# Selections +SelEE = Selection("SelEE", Algorithm = dieLL ) +SelMM = Selection("SelMM", Algorithm = _MuMu, RequiredSelections = [ _StdLooseDiMuon ]) +#SelLUee = Selection("SelLUee", Algorithm = dieLL2 ) + +# Build a filter to choose candidates passing stripping/Hlt2 +if (year == "2016"): + filterEE = LoKi__HDRFilter( "filterEE", + Code = "HLT_PASS('StrippingLowMultDiElectronLineDecision')", # StrippingLowMultDiElectronLine + Location="/Event/Strip/Phys/DecReports") + SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[filterEE] ) + # Upstream electrons + #SeqLUee = SelectionSequence("SeqLUee", TopSelection = SelLUee, EventPreSelector=[filterEE] ) # just E dos not work + + filterMM = LoKi__HDRFilter( "filterMM", + Code = "HLT_PASS('StrippingLowMultDiMuonLineDecision')", # StrippingLowMultDiElectronLine + Location="/Event/Strip/Phys/DecReports") + SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[filterMM] ) +elif (year == "2017" or year == "2018"): + + Hlt2FilterEE = LoKi__HDRFilter( "Hlt2FilterEE", + Code = "HLT_PASS('Hlt2LowMultDiElectronDecision')", # Hlt2LowMultDiElectronDecision + Location="Hlt2/DecReports") + SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[Hlt2FilterEE] ) + # Upstream electrons + #SeqLUee = SelectionSequence("SeqLUee", TopSelection = SelLUee, EventPreSelector=[Hlt2FilterEE] ) # just E dos not work + + Hlt2FilterMM = LoKi__HDRFilter( "Hlt2FilterMM", + Code = "HLT_PASS('Hlt2LowMultDiMuonDecision')", # Hlt2LowMultDiMuonDecision + Location="Hlt2/DecReports") + SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[Hlt2FilterMM] ) + + +######################################################################################## +# Fill the chi_c_0,1,2 branches +if (fillChic): + _Gamma = DataOnDemand( Location = 'Phys/StdVeryLooseAllPhotons/Particles' ) + _Chic0MM = CombineParticles("chic0", + DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + _Chic1MM = CombineParticles("chic1", + DecayDescriptor = "chi_c1(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + _Chic2MM = CombineParticles("chic2", + DecayDescriptor = "chi_c2(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + _Chic0EE = CombineParticles("chic0", + DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + _Chic1EE = CombineParticles("chic1", + DecayDescriptor = "chi_c1(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + _Chic2EE = CombineParticles("chic2", + DecayDescriptor = "chi_c2(1P) -> J/psi(1S) gamma", + DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, + CombinationCut = "(AM<5500)", + MotherCut = "(M<6000)") + + + SelChic0MM = Selection("SelChic0MM", Algorithm = _Chic0MM, RequiredSelections = [ SelMM, _Gamma ]) + SelChic1MM = Selection("SelChic1MM", Algorithm = _Chic1MM, RequiredSelections = [ SelMM, _Gamma ]) + SelChic2MM = Selection("SelChic2MM", Algorithm = _Chic2MM, RequiredSelections = [ SelMM, _Gamma ]) + SelChic0EE = Selection("SelChic0EE", Algorithm = _Chic0EE, RequiredSelections = [ SelEE, _Gamma ]) + SelChic1EE = Selection("SelChic1EE", Algorithm = _Chic1EE, RequiredSelections = [ SelEE, _Gamma ]) + SelChic2EE = Selection("SelChiC2EE", Algorithm = _Chic2EE, RequiredSelections = [ SelEE, _Gamma ]) + + if (year == "2016"): + SeqChic0MM = SelectionSequence("SeqChic0MM", TopSelection = SelChic0MM, EventPreSelector=[filterMM] ) + SeqChic1MM = SelectionSequence("SeqChic1MM", TopSelection = SelChic1MM, EventPreSelector=[filterMM] ) + SeqChic2MM = SelectionSequence("SeqChic2MM", TopSelection = SelChic2MM, EventPreSelector=[filterMM] ) + SeqChic0EE = SelectionSequence("SeqChic0EE", TopSelection = SelChic0EE, EventPreSelector=[filterEE] ) + SeqChic1EE = SelectionSequence("SeqChic1EE", TopSelection = SelChic1EE, EventPreSelector=[filterEE] ) + SeqChic2EE = SelectionSequence("SeqChic2EE", TopSelection = SelChic2EE, EventPreSelector=[filterEE] ) + elif (year == "2017" or year == "2018"): + SeqChic0MM = SelectionSequence("SeqChic0MM", TopSelection = SelChic0MM, EventPreSelector=[Hlt2FilterMM] ) + SeqChic1MM = SelectionSequence("SeqChic1MM", TopSelection = SelChic1MM, EventPreSelector=[Hlt2FilterMM] ) + SeqChic2MM = SelectionSequence("SeqChic2MM", TopSelection = SelChic2MM, EventPreSelector=[Hlt2FilterMM] ) + SeqChic0EE = SelectionSequence("SeqChic0EE", TopSelection = SelChic0EE, EventPreSelector=[Hlt2FilterEE] ) + SeqChic1EE = SelectionSequence("SeqChic1EE", TopSelection = SelChic1EE, EventPreSelector=[Hlt2FilterEE] ) + SeqChic2EE = SelectionSequence("SeqChic2EE", TopSelection = SelChic2EE, EventPreSelector=[Hlt2FilterEE] ) + +######################################################################################## + +# Needed for Herschel +from Configurables import HCRawBankDecoder +decoder = HCRawBankDecoder() + +# Fill ntuple +DaVinci().appendToMainSequence( [ decoder ] ) +DaVinci().appendToMainSequence( [SeqEE.sequence() ]) +#DaVinci().appendToMainSequence( [SeqLUee.sequence() ]) # Upstream electrons +#DaVinci().appendToMainSequence( [ PrintDecayTree(Inputs=['Phys/SelLUee/Particles']) ]) +DaVinci().appendToMainSequence( [SeqMM.sequence() ]) +if (fillChic): + DaVinci().appendToMainSequence( [SeqChic0MM.sequence() ]) + #DaVinci().appendToMainSequence( [SeqChic1MM.sequence() ]) + #DaVinci().appendToMainSequence( [SeqChic2MM.sequence() ]) + DaVinci().appendToMainSequence( [SeqChic0EE.sequence() ]) + #DaVinci().appendToMainSequence( [SeqChic1EE.sequence() ]) + #DaVinci().appendToMainSequence( [SeqChic2EE.sequence() ]) + +#from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Psi2S2Jpsipipi, Chic02JpsiMuMuGamma, Chic12JpsiMuMuGamma, Chic22JpsiMuMuGamma, Chic02JpsiEEGamma, Chic12JpsiEEGamma, Chic22JpsiEEGamma +#from CEP_Jpsi2ll import DiLeptonTuple +import CEP_Jpsi2ll +from CEP_Jpsi2ll.DiLeptonTuple import DiLeptonTuple as DLT +DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) +#DaVinci().appendToMainSequence( DLT.addTuple(name="SelLUee", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelLUee/Particles'], options = ["CEP"] ) ) # Upstream electrons +DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) +if (fillChic): + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic0MM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic0MM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic0EE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChic0EE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) +# DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic1MM", decay=DLT.Chic12JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic1MM/Particles'], options = ["CEP"]) ) +# DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic2MM", decay=DLT.Chic22JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic2MM/Particles'], options = ["CEP"]) ) +""" +DaVinci().appendToMainSequence( [SeqEE.sequence() ]) # +#DaVinci().appendToMainSequence( [SeqLUee.sequence() ]) # Upstream electrons +DaVinci().appendToMainSequence( [SeqMM.sequence() ]) # +if (fillChic): + DaVinci().appendToMainSequence( [SeqChic0.sequence() ]) + DaVinci().appendToMainSequence( [SeqChic1.sequence() ]) + DaVinci().appendToMainSequence( [SeqChic2.sequence() ]) +#DaVinci().appendToMainSequence( [ PrintDecayTree(Inputs=['Phys/SelLUee/Particles']) ]) # +from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Psi2S2Jpsipipi, Chic12JpsiMuMuGamma +DaVinci().appendToMainSequence( addTuple(name="SelEE", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], options = ["CEP"] ) ) +#DaVinci().appendToMainSequence( addTuple(name="SelLUee", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelLUee/Particles'], options = ["CEP"] ) ) +DaVinci().appendToMainSequence( addTuple(name="SelMM", decay=Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], options = ["CEP"]) ) +if (fillChic): + DaVinci().appendToMainSequence( addTuple(name="SelChic0", decay=Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic0/Particles'], options = ["CEP"]) ) + DaVinci().appendToMainSequence( addTuple(name="SelChic1", decay=Chic12JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic1/Particles'], options = ["CEP"]) ) + DaVinci().appendToMainSequence( addTuple(name="SelChic2", decay=Chic22JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic2/Particles'], options = ["CEP"]) ) +""" +nev = -1 +DaVinci().EvtMax = nev +DaVinci().PrintFreq = 10000 +#DaVinci().DataType = year +DaVinci().Lumi = True +DaVinci().TupleFile = "CEP.root" +if ( nev>0 and nev<100): DaVinciInit("DaVinciInitAlg").PrintEvent = True + +from GaudiConf import IOHelper +#IOHelper().inputFiles([ '/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103400_00053594_1.lowmult.dst','/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103804_00002271_1.lowmult.dst','/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103804_00004991_1.lowmult.dst' ], clear=True) + + +if (allInfoTISTOS): + # Extra options from Roel to try and figure out what TisTos is doing + from Configurables import ToolSvc, TriggerTisTos + ToolSvc().addTool(TriggerTisTos, "Hlt1TriggerTisTos") + ToolSvc().Hlt1TriggerTisTos.HltDecReportsLocation = 'Hlt1/DecReports' + ToolSvc().Hlt1TriggerTisTos.HltSelReportsLocation = 'Hlt1/SelReports' + + ToolSvc().addTool(TriggerTisTos, "Hlt2TriggerTisTos") + ToolSvc().Hlt2TriggerTisTos.HltDecReportsLocation = 'Hlt2/DecReports' + ToolSvc().Hlt2TriggerTisTos.HltSelReportsLocation = 'Hlt2/SelReports' + + from GaudiKernel.Configurable import applyConfigurableUsers + applyConfigurableUsers() + # assert(False) + + import GaudiPython as GP + import ROOT + appMgr = GP.AppMgr() + + location = 'Phys/SelEE' + + # Initialize the ApplicationMgr + appMgr.initialize() + + # Get some services + TES = appMgr.evtSvc() + toolSvc = appMgr.toolSvc() + + #LHCb = gbl.LHCb + + tttHlt1 = toolSvc.create('Hlt1TriggerTisTos', interface='ITriggerTisTos') + tttHlt2 = toolSvc.create('Hlt2TriggerTisTos', interface='ITriggerTisTos') + + Hlt1decisions = ['Hlt1LowMultMuonDecision' , 'Hlt1LowMultMaxVeloAndHerschelDecision' , 'Hlt1LowMultMaxVeloCutDecision' , 'Hlt1LowMultVeloCut_LeptonsDecision' , 'Hlt1LowMultPassThroughDecision' , 'Hlt1LowMultVeloAndHerschel_LeptonsDecision'] + Hlt2decisions = ['Hlt2LowMultDiMuonDecision' , 'Hlt2LowMultDiElectronDecision'] + + def run(evtNum): + appMgr.run(evtNum) + if not bool(TES['/Event']): + return (-1, None) + + particles = TES[location + '/Particles'] + if not particles: + return (0, None) + + particles = [p for p in particles] + if not particles: + return (0, None) + + return (1, particles) + # Look for the first event with candidates and print its information + while True: + s, particles = run(1) + if s == -1: + break + if s == 1: + break + + # Print the information + if s: + particle = particles[0] + tttHlt1.setOfflineInput(particle) + tttHlt2.setOfflineInput(particle) + for dec in Hlt1decisions: + tttHlt1.triggerTisTos(dec) + print(tttHlt1.analysisReportTrigger()) + for dec in Hlt2decisions: + tttHlt2.triggerTisTos(dec) + print(tttHlt2.analysisReportTrigger()) diff --git a/CEP_Jpsi2ll/DataTypes/2016.py b/CEP_Jpsi2ll/DataTypes/2016.py new file mode 100644 index 0000000000..8ac76be65c --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/2016.py @@ -0,0 +1,2 @@ +from Configurables import DaVinci +DaVinci().DataType = "2016" diff --git a/CEP_Jpsi2ll/DataTypes/2017.py b/CEP_Jpsi2ll/DataTypes/2017.py new file mode 100644 index 0000000000..cb4fdc4f1d --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/2017.py @@ -0,0 +1,2 @@ +from Configurables import DaVinci +DaVinci().DataType = "2017" diff --git a/CEP_Jpsi2ll/DataTypes/2018.py b/CEP_Jpsi2ll/DataTypes/2018.py new file mode 100644 index 0000000000..d13c09afac --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/2018.py @@ -0,0 +1,2 @@ +from Configurables import DaVinci +DaVinci().DataType = "2018" diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py new file mode 100644 index 0000000000..459b0190a5 --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20170721-2-vc-md100' diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py new file mode 100644 index 0000000000..a945b470d6 --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20190430-1-vc-md100' diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py new file mode 100644 index 0000000000..5838d8ab96 --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20190430-vc-md100' diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py new file mode 100644 index 0000000000..e34708fca5 --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20170721-2-vc-mu100' diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py new file mode 100644 index 0000000000..51aaedd36a --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20190430-1-vc-mu100' diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py new file mode 100644 index 0000000000..cd5a44f570 --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py @@ -0,0 +1,4 @@ +from Configurables import DaVinci +DaVinci().Simulation = True +DaVinci().DDDBtag = 'dddb-20170721-3' +DaVinci().CondDBtag = 'sim-20190430-vc-mu100' diff --git a/CEP_Jpsi2ll/DataTypes/real_data.py b/CEP_Jpsi2ll/DataTypes/real_data.py new file mode 100644 index 0000000000..53064162fa --- /dev/null +++ b/CEP_Jpsi2ll/DataTypes/real_data.py @@ -0,0 +1,2 @@ +from Configurables import DaVinci +DaVinci().Simulation = False diff --git a/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py new file mode 100644 index 0000000000..17f5eb74f7 --- /dev/null +++ b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py @@ -0,0 +1,1262 @@ +""" +The big TCKs are for 2011: + 0x790038 33% + 0x760037 28% + 0x730035 18% +for 2012: + 0x94003D 29% + 0x97003D 29% + 0x990042 34% + +for 2015: + 0x010800A2 +for 2017 (Hlt1) + 290461443 +for 2017 (Hlt2) + 558962435 +for 2018 + 292820993 Hl1t + 561190913 Hlt2 + +s = set() +for tck in [ 0x790038, 0x760037, 0x730035, 0x94003D, 0x97003D, 0x990042 ]: + s.update(set(getHlt1Lines(tck))) + s.update(set(getHlt2Lines(tck))) + print tck, len(s) + +l = list(s) +l.sort() + +for i in l: + print ' "'+i.replace("Hlt::Line/",' "')+'Decision", ' + + +s = set() +for tck in [ 0x010800A2, 290461443, 558962435,292820993, 561190913 ]: + s.update(set(getHlt1Lines(tck))) + s.update(set(getHlt2Lines(tck))) + print tck, len(s) + +l = list(s) +l.sort() + +for i in l: + print ' "'+i.replace("Hlt::Line/",' "')+'Decision", ' + + + +""" +def allRun2Lines(): + return [ "Hlt1B2GammaGammaDecision", + "Hlt1B2GammaGammaHighMassDecision", + "Hlt1B2HH_LTUNB_KKDecision", + "Hlt1B2HH_LTUNB_KPiDecision", + "Hlt1B2HH_LTUNB_PiPiDecision", + "Hlt1B2PhiGamma_LTUNBDecision", + "Hlt1B2PhiPhi_LTUNBDecision", + "Hlt1BeamGasBeam1Decision", + "Hlt1BeamGasBeam1VeloOpenDecision", + "Hlt1BeamGasBeam2Decision", + "Hlt1BeamGasBeam2VeloOpenDecision", + "Hlt1BeamGasCrossingEnhancedBeam1Decision", + "Hlt1BeamGasCrossingEnhancedBeam2Decision", + "Hlt1BeamGasCrossingForcedRecoDecision", + "Hlt1BeamGasCrossingForcedRecoFullZDecision", + "Hlt1BeamGasCrossingParasiticDecision", + "Hlt1BeamGasHighRhoVerticesDecision", + "Hlt1BeamGasNoBeamBeam1Decision", + "Hlt1BeamGasNoBeamBeam2Decision", + "Hlt1Bottomonium2KstarKstarDecision", + "Hlt1Bottomonium2PhiPhiDecision", + "Hlt1CEPDecision", + "Hlt1CEPVeloCutDecision", + "Hlt1CalibHighPTLowMultTrksDecision", + "Hlt1CalibMuonAlignJpsiDecision", + "Hlt1CalibRICHMirrorRICH1Decision", + "Hlt1CalibRICHMirrorRICH2Decision", + "Hlt1CalibTrackingKKDecision", + "Hlt1CalibTrackingKPiDecision", + "Hlt1CalibTrackingKPiDetachedDecision", + "Hlt1CalibTrackingPiPiDecision", + "Hlt1Ccbar2PhiPhiDecision", + "Hlt1CharmXSecDecision", + "Hlt1DiElectronHighMassDecision", + "Hlt1DiElectronLowMassDecision", + "Hlt1DiElectronLowMassNoIPDecision", + "Hlt1DiMuonHighMassDecision", + "Hlt1DiMuonLowMassDecision", + "Hlt1DiMuonNoIPDecision", + "Hlt1DiMuonNoIPSSDecision", + "Hlt1DiMuonNoL0Decision", + "Hlt1DiProtonDecision", + "Hlt1DiProtonHighDecision", + "Hlt1DiProtonLowMultDecision", + "Hlt1ErrorEventDecision", + "Hlt1GlobalDecision", + "Hlt1IncPhiDecision", + "Hlt1L0AnyDecision", + "Hlt1L0AnyNoSPDDecision", + "Hlt1LowMultMaxVeloAndHerschelDecision", + "Hlt1LowMultMaxVeloCutDecision", + "Hlt1LowMultMuonDecision", + "Hlt1LowMultPassThroughDecision", + "Hlt1LowMultVeloAndHerschel_HadronsDecision", + "Hlt1LowMultVeloAndHerschel_LeptonsDecision", + "Hlt1LowMultVeloCut_HadronsDecision", + "Hlt1LowMultVeloCut_LeptonsDecision", + "Hlt1LumiDecision", + "Hlt1MBNoBiasDecision", + "Hlt1MBNoBiasRateLimitedDecision", + "Hlt1MultiDiMuonNoIPDecision", + "Hlt1MultiMuonNoL0Decision", + "Hlt1NoBiasEmptyEmptyDecision", + "Hlt1NoBiasNonBeamBeamDecision", + "Hlt1NoPVPassThroughDecision", + "Hlt1ODINTechnicalDecision", + "Hlt1SingleElectronNoIPDecision", + "Hlt1SingleMuonHighPTDecision", + "Hlt1SingleMuonHighPTNoMUIDDecision", + "Hlt1SingleMuonNoIPDecision", + "Hlt1Tell1ErrorDecision", + "Hlt1TrackMVADecision", + "Hlt1TrackMVATightDecision", + "Hlt1TrackMuonDecision", + "Hlt1TrackMuonMVADecision", + "Hlt1TrackMuonNoSPDDecision", + "Hlt1TwoTrackMVADecision", + "Hlt1TwoTrackMVATightDecision", + "Hlt1VeloClosingMicroBiasDecision", + "Hlt2B2HHDecision", + "Hlt2B2HH_B2HHDecision", + "Hlt2B2HH_B2KKDecision", + "Hlt2B2HH_B2KPiDecision", + "Hlt2B2HH_B2PiPiDecision", + "Hlt2B2HH_Lb2PKDecision", + "Hlt2B2HH_Lb2PPiDecision", + "Hlt2B2K0pi0Decision", + "Hlt2B2KKDecision", + "Hlt2B2KPiDecision", + "Hlt2B2Kpi0Decision", + "Hlt2B2Kpi0_B2K0pi0Decision", + "Hlt2B2Kpi0_B2Kpi0Decision", + "Hlt2B2OC_B2DK_D2HHTurboDecision", + "Hlt2B2OC_B2DPi_D2HHTurboDecision", + "Hlt2B2PiPiDecision", + "Hlt2BHadB02PpPpPmPmDecision", + "Hlt2Bc2JpsiXTFBc2JpsiMuXDecision", + "Hlt2BeamGasDecision", + "Hlt2BottomoniumDiKstarTurboDecision", + "Hlt2BottomoniumDiPhiDecision", + "Hlt2Bs2PhiPhiDecision", + "Hlt2CaloPIDBd2KstGammaTurboCalibDecision", + "Hlt2CaloPIDBs2PhiGammaTurboCalibDecision", + "Hlt2CaloPIDD2EtapPiTurboCalibDecision", + "Hlt2CaloPIDDsst2DsGammaTurboCalibDecision", + "Hlt2CaloPIDDstD02KPiPi0_MergedPi0TurboCalibDecision", + "Hlt2CaloPIDDstD02KPiPi0_ResolvedPi0TurboCalibDecision", + "Hlt2CaloPIDEta2MuMuGammaTurboCalibDecision", + "Hlt2CcDiHadronDiPhiDecision", + "Hlt2CcDiHadronDiProtonDecision", + "Hlt2CcDiHadronDiProtonHighTurboDecision", + "Hlt2CcDiHadronDiProtonLowMultDecision", + "Hlt2CcDiHadronDiProtonTurboDecision", + "Hlt2CharmHadD02KPi_XSecTurboDecision", + "Hlt2CharmHadD02KmPipTurboDecision", + "Hlt2CharmHadDp2EtaKp_Eta2EmEpGDecision", + "Hlt2CharmHadDp2EtaKp_Eta2PimPipGDecision", + "Hlt2CharmHadDp2EtaKp_Eta2PimPipPi0_Pi0MDecision", + "Hlt2CharmHadDp2EtaKp_Eta2PimPipPi0_Pi0RDecision", + "Hlt2CharmHadDp2EtaPip_Eta2EmEpGDecision", + "Hlt2CharmHadDp2EtaPip_Eta2PimPipGDecision", + "Hlt2CharmHadDp2EtaPip_Eta2PimPipPi0_Pi0MDecision", + "Hlt2CharmHadDp2EtaPip_Eta2PimPipPi0_Pi0RDecision", + "Hlt2CharmHadDp2EtapKp_Etap2EtaPimPip_EtaRDecision", + "Hlt2CharmHadDp2EtapKp_Etap2PimPipGDecision", + "Hlt2CharmHadDp2EtapPip_Etap2EtaPimPip_EtaRDecision", + "Hlt2CharmHadDp2EtapPip_Etap2PimPipGDecision", + "Hlt2CharmHadDp2KS0KS0KpTurboDecision", + "Hlt2CharmHadDp2KS0KS0PipTurboDecision", + "Hlt2CharmHadDp2KS0KmKpPip_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0KmKpPip_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0KmPipPip_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0KmPipPip_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0KpKpPim_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0KpKpPim_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0KpPimPip_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0KpPimPip_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0Kp_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0Kp_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0PimPipPip_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0PimPipPip_KS0LLTurboDecision", + "Hlt2CharmHadDp2KS0Pip_KS0DDTurboDecision", + "Hlt2CharmHadDp2KS0Pip_KS0LLTurboDecision", + "Hlt2CharmHadDp2KmKmKpPipPipTurboDecision", + "Hlt2CharmHadDp2KmKpPimPipPipTurboDecision", + "Hlt2CharmHadDp2KmPimPipPipPipTurboDecision", + "Hlt2CharmHadDp2KpPi0_Pi02EmEpGDecision", + "Hlt2CharmHadDp2PipPi0_Pi02EmEpGDecision", + "Hlt2CharmHadDpDsp2KmKpKpPi0Decision", + "Hlt2CharmHadDpDsp2KmKpPipPi0Decision", + "Hlt2CharmHadDpDsp2KmPipPipPi0Decision", + "Hlt2CharmHadDpDsp2KpKpPimPi0Decision", + "Hlt2CharmHadDpDsp2KpPimPipPi0Decision", + "Hlt2CharmHadDpDsp2PimPipPipPi0Decision", + "Hlt2CharmHadDpToKmKpKpTurboDecision", + "Hlt2CharmHadDpToKmKpPipTurboDecision", + "Hlt2CharmHadDpToKmPipPipTurboDecision", + "Hlt2CharmHadDpToKmPipPip_ForKPiAsymDecision", + "Hlt2CharmHadDpToKmPipPip_ForKPiAsymTurboDecision", + "Hlt2CharmHadDpToKmPipPip_LTUNBTurboDecision", + "Hlt2CharmHadDpToKpKpPimTurboDecision", + "Hlt2CharmHadDpToKpPimPipTurboDecision", + "Hlt2CharmHadDpToPimPipPipTurboDecision", + "Hlt2CharmHadDpm2KKPi_XSecTurboDecision", + "Hlt2CharmHadDpm2KPiPi_XSecTurboDecision", + "Hlt2CharmHadDs2KKPi_XSecTurboDecision", + "Hlt2CharmHadDs2PiPiPi_XSecTurboDecision", + "Hlt2CharmHadDsp2KS0KS0KpTurboDecision", + "Hlt2CharmHadDsp2KS0KS0PipTurboDecision", + "Hlt2CharmHadDsp2KS0KmKpPip_KS0DDTurboDecision", + "Hlt2CharmHadDsp2KS0KmKpPip_KS0LLTurboDecision", + "Hlt2CharmHadDsp2KS0KmPipPip_KS0DDTurboDecision", + "Hlt2CharmHadDsp2KS0KmPipPip_KS0LLTurboDecision", + "Hlt2CharmHadDsp2KS0KpKpPim_KS0DDTurboDecision", + "Hlt2CharmHadDsp2KS0KpKpPim_KS0LLTurboDecision", + "Hlt2CharmHadDsp2KS0KpPimPip_KS0DDTurboDecision", + "Hlt2CharmHadDsp2KS0KpPimPip_KS0LLTurboDecision", + "Hlt2CharmHadDsp2KS0PimPipPip_KS0DDTurboDecision", + "Hlt2CharmHadDsp2KS0PimPipPip_KS0LLTurboDecision", + "Hlt2CharmHadDsp2KmKmKpPipPipTurboDecision", + "Hlt2CharmHadDsp2KmKpPimPipPipTurboDecision", + "Hlt2CharmHadDsp2KmPimPipPipPipTurboDecision", + "Hlt2CharmHadDspToKmKpKpTurboDecision", + "Hlt2CharmHadDspToKmKpPipDecision", + "Hlt2CharmHadDspToKmKpPipTurboDecision", + "Hlt2CharmHadDspToKmKpPip_LTUNBTurboDecision", + "Hlt2CharmHadDspToKmPipPipTurboDecision", + "Hlt2CharmHadDspToKpKpPimTurboDecision", + "Hlt2CharmHadDspToKpPimPipTurboDecision", + "Hlt2CharmHadDspToPimPipPipTurboDecision", + "Hlt2CharmHadDst2PiD02KKGammaDecision", + "Hlt2CharmHadDst2PiD02KPiGammaDecision", + "Hlt2CharmHadDst2PiD02PiPiGammaDecision", + "Hlt2CharmHadDst_2D0Gamma_D02KPi_XSecTurboDecision", + "Hlt2CharmHadDst_2D0Pi0_D02KPi_XSecTurboDecision", + "Hlt2CharmHadDst_2D0Pi_D02K3Pi_XSecTurboDecision", + "Hlt2CharmHadDst_2D0Pi_D02KPi_XSecTurboDecision", + "Hlt2CharmHadDst_2DsGamma_Ds2KKPi_XSecTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02EmEpDecision", + "Hlt2CharmHadDstp2D0Pip_D02GG_G2EmEpDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0LLTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0LL_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DDDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DD_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DD_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LLDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LLTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LL_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LL_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DDDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DD_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LLDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LLTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LL_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DDDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DD_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LLDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LLTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LL_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DDDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DDTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DD_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DD_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LLDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LLTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LL_LTUNBDecision", + "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LL_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKmKpPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKpKpPimTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKpPi0_Pi0MDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKpPi0_Pi0RDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKpPimPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKpTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmKp_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmPimPipPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmPipPi0_Pi0MDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmPipPi0_Pi0RDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KmPip_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KpPimPi0_Pi0MDecision", + "Hlt2CharmHadDstp2D0Pip_D02KpPimPi0_Pi0RDecision", + "Hlt2CharmHadDstp2D0Pip_D02KpPimPimPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KpPimTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02KpPim_LTUNBTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02PimPimPipPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02PimPipPi0_Pi0MDecision", + "Hlt2CharmHadDstp2D0Pip_D02PimPipPi0_Pi0RDecision", + "Hlt2CharmHadDstp2D0Pip_D02PimPipTurboDecision", + "Hlt2CharmHadDstp2D0Pip_D02PimPip_LTUNBTurboDecision", + "Hlt2CharmHadInclDst2PiD02HHXBDTDecision", + "Hlt2CharmHadInclLcpToKmPpPipBDTDecision", + "Hlt2CharmHadInclLcpToKmPpPipBDTTurboDecision", + "Hlt2CharmHadInclOmegacToPpKmKmPipBDTTurboDecision", + "Hlt2CharmHadInclSigc2PiLc2HHXBDTDecision", + "Hlt2CharmHadInclXic0ToPpKmKmPipBDTTurboDecision", + "Hlt2CharmHadInclXicpToKmPpPipBDTTurboDecision", + "Hlt2CharmHadLc2KPK_XSecTurboDecision", + "Hlt2CharmHadLc2KPPi_XSecTurboDecision", + "Hlt2CharmHadLc2LambdaPipPimPip_LamDDDecision", + "Hlt2CharmHadLc2LambdaPipPimPip_LamLLDecision", + "Hlt2CharmHadLc2PiPPi_XSecTurboDecision", + "Hlt2CharmHadLc2XimKpPip_XimDDDDecision", + "Hlt2CharmHadLc2XimKpPip_XimDDLDecision", + "Hlt2CharmHadLc2XimKpPip_XimLLLDecision", + "Hlt2CharmHadLcp2KS0KS0PpTurboDecision", + "Hlt2CharmHadLcp2LamKmKpPip_Lam2PpPimTurboDecision", + "Hlt2CharmHadLcp2LamKmPipPip_Lam2PpPimTurboDecision", + "Hlt2CharmHadLcp2LamKp_LamDDTurboDecision", + "Hlt2CharmHadLcp2LamKp_LamLLTurboDecision", + "Hlt2CharmHadLcp2LamPip_LamDDTurboDecision", + "Hlt2CharmHadLcp2LamPip_LamLLTurboDecision", + "Hlt2CharmHadLcpToKmPpKpPi0TurboDecision", + "Hlt2CharmHadLcpToPpKmKmPipPipTurboDecision", + "Hlt2CharmHadLcpToPpKmKpPimPipTurboDecision", + "Hlt2CharmHadLcpToPpKmKpTurboDecision", + "Hlt2CharmHadLcpToPpKmPimPipPipTurboDecision", + "Hlt2CharmHadLcpToPpKmPipTurboDecision", + "Hlt2CharmHadLcpToPpKmPip_LTUNBTurboDecision", + "Hlt2CharmHadLcpToPpKpKpPimPimTurboDecision", + "Hlt2CharmHadLcpToPpKpPimPimPipTurboDecision", + "Hlt2CharmHadLcpToPpKpPimTurboDecision", + "Hlt2CharmHadLcpToPpPimPimPipPipTurboDecision", + "Hlt2CharmHadLcpToPpPimPipTurboDecision", + "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KmKpTurboDecision", + "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KmPipTurboDecision", + "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KpPimTurboDecision", + "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02PimPipTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02KmKmKpPipTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02KmKpKpPimTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02KmKpPimPipTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02KmPimPipPipTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02KpPimPimPipTurboDecision", + "Hlt2CharmHadMuTag_Dstp_D02PimPimPipPipTurboDecision", + "Hlt2CharmHadOmccp2DpPpKmKmPip_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadOmccp2LcpKmKmPipPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadOmccp2Xic0KmPipPip_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadOmccp2XicpKmPim_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadOmccp2XicpKmPip_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadOmm2LamKm_DDDDecision", + "Hlt2CharmHadOmm2LamKm_DDDTurboDecision", + "Hlt2CharmHadOmm2LamKm_DDLDecision", + "Hlt2CharmHadOmm2LamKm_DDLTurboDecision", + "Hlt2CharmHadOmm2LamKm_LLLDecision", + "Hlt2CharmHadOmm2LamKm_LLLTurboDecision", + "Hlt2CharmHadPentaToPhiPpPimTurboDecision", + "Hlt2CharmHadPentaToPhiPpTurboDecision", + "Hlt2CharmHadPromptH2LamLamBar_LamDDTurboDecision", + "Hlt2CharmHadPromptH2LamLamBar_LamLLTurboDecision", + "Hlt2CharmHadPromptH2LamLamBar_LamLL_LamDDTurboDecision", + "Hlt2CharmHadPromptH2LamLam_LamDDTurboDecision", + "Hlt2CharmHadPromptH2LamLam_LamLLTurboDecision", + "Hlt2CharmHadPromptH2LamLam_LamLL_LamDDTurboDecision", + "Hlt2CharmHadSecondaryH2LamPipPmDDDDTurboDecision", + "Hlt2CharmHadSecondaryH2LamPipPmDDLLTurboDecision", + "Hlt2CharmHadSecondaryH2LamPipPmLLLLTurboDecision", + "Hlt2CharmHadSecondaryH2LamPpPimDDDDTurboDecision", + "Hlt2CharmHadSecondaryH2LamPpPimDDLLTurboDecision", + "Hlt2CharmHadSecondaryH2LamPpPimLLLLTurboDecision", + "Hlt2CharmHadSigmac_2LcPi_XSecTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_EtaTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_GammaTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_KpmTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_KsTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_LambdaTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_Pi0TurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_PiTurboDecision", + "Hlt2CharmHadSpec_D0ToK3Pi_PrTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_EtaTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_GammaTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_KpmTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_KsTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_LambdaTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_Pi0TurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_PiTurboDecision", + "Hlt2CharmHadSpec_D0ToKPi_PrTurboDecision", + "Hlt2CharmHadSpec_DpEtaTurboDecision", + "Hlt2CharmHadSpec_DpGammaTurboDecision", + "Hlt2CharmHadSpec_DpKpmTurboDecision", + "Hlt2CharmHadSpec_DpKsTurboDecision", + "Hlt2CharmHadSpec_DpLambdaTurboDecision", + "Hlt2CharmHadSpec_DpPi0TurboDecision", + "Hlt2CharmHadSpec_DpPiTurboDecision", + "Hlt2CharmHadSpec_DpPrTurboDecision", + "Hlt2CharmHadSpec_DsEtaTurboDecision", + "Hlt2CharmHadSpec_DsGammaTurboDecision", + "Hlt2CharmHadSpec_DsKpmTurboDecision", + "Hlt2CharmHadSpec_DsKsTurboDecision", + "Hlt2CharmHadSpec_DsLambdaTurboDecision", + "Hlt2CharmHadSpec_DsPi0TurboDecision", + "Hlt2CharmHadSpec_DsPiTurboDecision", + "Hlt2CharmHadSpec_DsPrTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_EtaTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_GammaTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_KpmTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_KsTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_LambdaTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_Pi0TurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_PiTurboDecision", + "Hlt2CharmHadSpec_Dst_K3Pi_PrTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_EtaTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_GammaTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_KpmTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_KsTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_LambdaTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_Pi0TurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_PiTurboDecision", + "Hlt2CharmHadSpec_Dst_KPi_PrTurboDecision", + "Hlt2CharmHadSpec_LcEtaTurboDecision", + "Hlt2CharmHadSpec_LcGammaTurboDecision", + "Hlt2CharmHadSpec_LcKpmTurboDecision", + "Hlt2CharmHadSpec_LcKsTurboDecision", + "Hlt2CharmHadSpec_LcLambdaTurboDecision", + "Hlt2CharmHadSpec_LcPi0TurboDecision", + "Hlt2CharmHadSpec_LcPiTurboDecision", + "Hlt2CharmHadSpec_LcPrTurboDecision", + "Hlt2CharmHadXcsud2KmKmPimPipTurboDecision", + "Hlt2CharmHadXcsud2KmKmPipPipTurboDecision", + "Hlt2CharmHadXcsud2KmKpPipPipTurboDecision", + "Hlt2CharmHadXic02PKKPi_XSecTurboDecision", + "Hlt2CharmHadXic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXic0ToPpKmKmPip_LTUNBTurboDecision", + "Hlt2CharmHadXic2LambdaKmPipPip_LamDDDecision", + "Hlt2CharmHadXic2LambdaKmPipPip_LamLLDecision", + "Hlt2CharmHadXic2LambdaKmPip_LamDDDecision", + "Hlt2CharmHadXic2LambdaKmPip_LamLLDecision", + "Hlt2CharmHadXic2LambdaKpKm_LamDDDecision", + "Hlt2CharmHadXic2LambdaKpKm_LamLLDecision", + "Hlt2CharmHadXic2XimKp_XimDDDDecision", + "Hlt2CharmHadXic2XimKp_XimDDLDecision", + "Hlt2CharmHadXic2XimKp_XimLLLDecision", + "Hlt2CharmHadXic2XimPipPimPip_XimDDDDecision", + "Hlt2CharmHadXic2XimPipPimPip_XimDDLDecision", + "Hlt2CharmHadXic2XimPipPimPip_XimLLLDecision", + "Hlt2CharmHadXic2XimPipPip_XimDDDDecision", + "Hlt2CharmHadXic2XimPipPip_XimDDLDecision", + "Hlt2CharmHadXic2XimPipPip_XimLLLDecision", + "Hlt2CharmHadXic2XimPip_XimDDDDecision", + "Hlt2CharmHadXic2XimPip_XimDDLDecision", + "Hlt2CharmHadXic2XimPip_XimLLLDecision", + "Hlt2CharmHadXiccp2D0PpKmPim_D02KmPipTurboDecision", + "Hlt2CharmHadXiccp2D0PpKmPip_D02KmPipTurboDecision", + "Hlt2CharmHadXiccp2D0PpKpPim_D02KmPipTurboDecision", + "Hlt2CharmHadXiccp2D0Pp_D02KmPipTurboDecision", + "Hlt2CharmHadXiccp2DpPpKm_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccp2DpPpKp_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccp2DpPpPim_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccp2DspPpKm_Dsp2KmKpPipTurboDecision", + "Hlt2CharmHadXiccp2LcpKmPim_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2LcpKmPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2LcpKpPim_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2LcpPimPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2Xic0Kp_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccp2Xic0Pim_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccp2Xic0Pip_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccp2XicpKpPim_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2XicpPimPim_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccp2XicpPimPip_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2D0PpKmPimPip_D02KmPipTurboDecision", + "Hlt2CharmHadXiccpp2D0PpKmPipPip_D02KmPipTurboDecision", + "Hlt2CharmHadXiccpp2D0PpKpPimPip_D02KmPipTurboDecision", + "Hlt2CharmHadXiccpp2D0PpPip_D02KmPipTurboDecision", + "Hlt2CharmHadXiccpp2DpPpKmPim_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccpp2DpPpKmPip_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccpp2DpPpKpPip_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccpp2DpPp_Dp2KmPipPipTurboDecision", + "Hlt2CharmHadXiccpp2DspPpKmPip_Dsp2KmKpPipTurboDecision", + "Hlt2CharmHadXiccpp2LcpKmPimPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2LcpKmPipPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2LcpKpPimPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2LcpPim_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2LcpPip_Lcp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2Omc0KpKp_Omc0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccpp2Xic0KpPip_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccpp2Xic0PimPip_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccpp2Xic0PipPip_Xic0ToPpKmKmPipTurboDecision", + "Hlt2CharmHadXiccpp2XicpKp_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2XicpPim_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXiccpp2XicpPip_Xicp2PpKmPipTurboDecision", + "Hlt2CharmHadXicpToPpKmPipDecision", + "Hlt2CharmHadXicpToPpKmPipTurboDecision", + "Hlt2CharmHadXim2LamPim_DDDDecision", + "Hlt2CharmHadXim2LamPim_DDDTurboDecision", + "Hlt2CharmHadXim2LamPim_DDLDecision", + "Hlt2CharmHadXim2LamPim_DDLTurboDecision", + "Hlt2CharmHadXim2LamPim_LLLDecision", + "Hlt2CharmHadXim2LamPim_LLLTurboDecision", + "Hlt2DPS2mu2HcDecision", + "Hlt2DPS2muHcDecision", + "Hlt2DPS2x2muDecision", + "Hlt2DPS2x2muHcDecision", + "Hlt2DPS2xHcDecision", + "Hlt2DPS3x2muDecision", + "Hlt2DPS3xHcDecision", + "Hlt2DPS:2mu&HcDecision", + "Hlt2DPS:2x2muDecision", + "Hlt2DPS:2xHcDecision", + "Hlt2DebugEventDecision", + "Hlt2DiElectronElSoftDecision", + "Hlt2DiElectronJPsiEETurboDecision", + "Hlt2DiMuonBDecision", + "Hlt2DiMuonBPromptDecision", + "Hlt2DiMuonBTurboDecision", + "Hlt2DiMuonBUBDecision", + "Hlt2DiMuonChicXTurboDecision", + "Hlt2DiMuonDetachedDecision", + "Hlt2DiMuonDetachedHeavyDecision", + "Hlt2DiMuonDetachedJPsiDecision", + "Hlt2DiMuonDetachedPsi2SDecision", + "Hlt2DiMuonJPsiDecision", + "Hlt2DiMuonJPsiHighPTDecision", + "Hlt2DiMuonJPsiTurboDecision", + "Hlt2DiMuonPsi2SDecision", + "Hlt2DiMuonPsi2SHighPTDecision", + "Hlt2DiMuonPsi2STurboDecision", + "Hlt2DiMuonSoftDecision", + "Hlt2DiMuonUpsilonTurboDecision", + "Hlt2DiMuonZDecision", + "Hlt2DiPhiDecision", + "Hlt2DiProtonDecision", + "Hlt2DiProtonLowMultDecision", + "Hlt2DisplVerticesDoubleDecision", + "Hlt2DisplVerticesDoublePSDecision", + "Hlt2DisplVerticesSingleDecision", + "Hlt2DisplVerticesSingleHighFDDecision", + "Hlt2DisplVerticesSingleHighMassDecision", + "Hlt2DisplVerticesSingleLoosePSDecision", + "Hlt2DisplVerticesSinglePSDecision", + "Hlt2DisplVerticesSingleVeryHighFDDecision", + "Hlt2EWConvPhotonDDHighPtDecision", + "Hlt2EWConvPhotonDDVHighPtDecision", + "Hlt2EWConvPhotonLLHighPtDecision", + "Hlt2EWConvPhotonLLVHighPtDecision", + "Hlt2EWDiElectronDYDecision", + "Hlt2EWDiElectronHighMassDecision", + "Hlt2EWDiMuonDY1Decision", + "Hlt2EWDiMuonDY2Decision", + "Hlt2EWDiMuonDY3Decision", + "Hlt2EWDiMuonDY4Decision", + "Hlt2EWDiMuonZDecision", + "Hlt2EWSingleElectronHighPtDecision", + "Hlt2EWSingleElectronLowPtDecision", + "Hlt2EWSingleElectronVHighPtDecision", + "Hlt2EWSingleMuonHighPtDecision", + "Hlt2EWSingleMuonHighPtNoMUIDDecision", + "Hlt2EWSingleMuonLowPtDecision", + "Hlt2EWSingleMuonVHighPtDecision", + "Hlt2EWSingleTauHighPt2ProngDecision", + "Hlt2EWSingleTauHighPt3ProngDecision", + "Hlt2ErrorEventDecision", + "Hlt2ExoticaDiMuonNoIPSSTurboDecision", + "Hlt2ExoticaDiMuonNoIPTurboDecision", + "Hlt2ExoticaDisplDiEDecision", + "Hlt2ExoticaDisplDiELowMassDecision", + "Hlt2ExoticaDisplDiMuonDecision", + "Hlt2ExoticaDisplDiMuonNoPointDecision", + "Hlt2ExoticaDisplPhiPhiDecision", + "Hlt2ExoticaEtaToDiEGammaDecision", + "Hlt2ExoticaLFVPrmptDecision", + "Hlt2ExoticaLFVPrmptSSTurboDecision", + "Hlt2ExoticaLFVPrmptTurboDecision", + "Hlt2ExoticaPi0ToDiEGammaDecision", + "Hlt2ExoticaPrmptDiMuonSSTurboDecision", + "Hlt2ExoticaPrmptDiMuonTurboDecision", + "Hlt2ExoticaQuadMuonNoIPDecision", + "Hlt2ExoticaRHNuDecision", + "Hlt2Exoticaf1gammaConvTurboDecision", + "Hlt2Exoticaf1mumuTurboDecision", + "Hlt2Exoticasigma0lbgammaTurboDecision", + "Hlt2ForwardDecision", + "Hlt2GlobalDecision", + "Hlt2Hb2V0V0Hb2KSKSDDDecision", + "Hlt2Hb2V0V0Hb2KSKSLDDecision", + "Hlt2Hb2V0V0Hb2KSKSLLDecision", + "Hlt2HcetacPPmumuTurboDecision", + "Hlt2HcetacPhiPhimumuTurboDecision", + "Hlt2IncPhiDecision", + "Hlt2JetsDiJetDisplacedSVSVLowPtDecision", + "Hlt2JetsDiJetMuMuDecision", + "Hlt2JetsDiJetMuMuLowPtDecision", + "Hlt2JetsDiJetSVDecision", + "Hlt2JetsDiJetSVHighPtDecision", + "Hlt2JetsDiJetSVLowPtDecision", + "Hlt2JetsDiJetSVMuDecision", + "Hlt2JetsDiJetSVMuLowPtDecision", + "Hlt2JetsDiJetSVSVDecision", + "Hlt2JetsDiJetSVSVLowPtDecision", + "Hlt2JetsJetDisplacedSVDecision", + "Hlt2JetsJetLowPtDecision", + "Hlt2JetsJetSVDecision", + "Hlt2LFVJpsiMuETurboDecision", + "Hlt2LFVPhiMuETurboDecision", + "Hlt2LFVPromptPhiMuETurboDecision", + "Hlt2LFVUpsilonMuETurboDecision", + "Hlt2Lb2PKDecision", + "Hlt2Lb2PPiDecision", + "Hlt2LowMultChiC2HHDecision", + "Hlt2LowMultChiC2HHHHDecision", + "Hlt2LowMultChiC2HHHHWSDecision", + "Hlt2LowMultChiC2HHWSDecision", + "Hlt2LowMultChiC2PPDecision", + "Hlt2LowMultChiC2PPWSDecision", + "Hlt2LowMultD2K3PiDecision", + "Hlt2LowMultD2K3PiWSDecision", + "Hlt2LowMultD2KKPiDecision", + "Hlt2LowMultD2KKPiWSDecision", + "Hlt2LowMultD2KPiDecision", + "Hlt2LowMultD2KPiPiDecision", + "Hlt2LowMultD2KPiPiWSDecision", + "Hlt2LowMultD2KPiWSDecision", + "Hlt2LowMultDiElectronDecision", + "Hlt2LowMultDiElectron_noTrFiltDecision", + "Hlt2LowMultDiMuonDecision", + "Hlt2LowMultDiMuon_PSDecision", + "Hlt2LowMultDiPhotonDecision", + "Hlt2LowMultDiPhoton_HighMassDecision", + "Hlt2LowMultHadron_noTrFiltDecision", + "Hlt2LowMultL2pPiDecision", + "Hlt2LowMultL2pPiWSDecision", + "Hlt2LowMultLMR2HHDecision", + "Hlt2LowMultLMR2HHHHDecision", + "Hlt2LowMultLMR2HHHHWSDecision", + "Hlt2LowMultLMR2HHHHWS_heavyPSDecision", + "Hlt2LowMultLMR2HHHHWS_mediumPSDecision", + "Hlt2LowMultLMR2HHHH_heavyPSDecision", + "Hlt2LowMultLMR2HHHH_mediumPSDecision", + "Hlt2LowMultLMR2HHWSDecision", + "Hlt2LowMultLMR2HHWS_heavyPSDecision", + "Hlt2LowMultLMR2HHWS_mediumPSDecision", + "Hlt2LowMultLMR2HH_heavyPSDecision", + "Hlt2LowMultLMR2HH_mediumPSDecision", + "Hlt2LowMultMuonDecision", + "Hlt2LowMultPi0Decision", + "Hlt2LowMultTechnical_MinBiasDecision", + "Hlt2LumiDecision", + "Hlt2MBNoBiasDecision", + "Hlt2MajoranaBLambdaMuDDDecision", + "Hlt2MajoranaBLambdaMuLLDecision", + "Hlt2NoBiasNonBeamBeamDecision", + "Hlt2PIDB2KJPsiEENegTaggedTurboCalibDecision", + "Hlt2PIDB2KJPsiEEPosTaggedTurboCalibDecision", + "Hlt2PIDB2KJPsiMuMuNegTaggedTurboCalibDecision", + "Hlt2PIDB2KJPsiMuMuPosTaggedTurboCalibDecision", + "Hlt2PIDB2KJPsiPPNegTaggedTurboCalibDecision", + "Hlt2PIDB2KJPsiPPPosTaggedTurboCalibDecision", + "Hlt2PIDD02KPiPiPiTagTurboCalibDecision", + "Hlt2PIDD02KPiPiPiTurboCalibDecision", + "Hlt2PIDD02KPiTagTurboCalibDecision", + "Hlt2PIDDetJPsiEENegTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiEEPosNegTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiEEPosTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiMuMuNegTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiMuMuPosTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiPPNegTaggedTurboCalibDecision", + "Hlt2PIDDetJPsiPPPosTaggedTurboCalibDecision", + "Hlt2PIDDetPhiKKNegTaggedTurboCalibDecision", + "Hlt2PIDDetPhiKKPosTaggedTurboCalibDecision", + "Hlt2PIDDetPhiKKUnbiasedTurboCalibDecision", + "Hlt2PIDDetPhiMuMuNegTaggedTurboCalibDecision", + "Hlt2PIDDetPhiMuMuPosTaggedTurboCalibDecision", + "Hlt2PIDDs2PiPhiKKNegTaggedTurboCalibDecision", + "Hlt2PIDDs2PiPhiKKPosTaggedTurboCalibDecision", + "Hlt2PIDDs2PiPhiKKUnbiasedTurboCalibDecision", + "Hlt2PIDDs2PiPhiMuMuNegTaggedTurboCalibDecision", + "Hlt2PIDDs2PiPhiMuMuPosTaggedTurboCalibDecision", + "Hlt2PIDKs2PiPiDDTurboCalibDecision", + "Hlt2PIDKs2PiPiLLTurboCalibDecision", + "Hlt2PIDLambda2PPiDDTurboCalibDecision", + "Hlt2PIDLambda2PPiDDhighPTTurboCalibDecision", + "Hlt2PIDLambda2PPiDDveryhighPTTurboCalibDecision", + "Hlt2PIDLambda2PPiLLTurboCalibDecision", + "Hlt2PIDLambda2PPiLLhighPTTurboCalibDecision", + "Hlt2PIDLambda2PPiLLisMuonTurboCalibDecision", + "Hlt2PIDLambda2PPiLLveryhighPTTurboCalibDecision", + "Hlt2PIDLb2LcMuNuTurboCalibDecision", + "Hlt2PIDLb2LcPiTurboCalibDecision", + "Hlt2PIDLc2KPPiTurboCalibDecision", + "Hlt2PIDOmega2LambdaKDDDTurboCalibDecision", + "Hlt2PIDOmega2LambdaKLLLTurboCalibDecision", + "Hlt2PIDSc02LcPiTurboCalibDecision", + "Hlt2PIDScpp2LcPiTurboCalibDecision", + "Hlt2PassThroughDecision", + "Hlt2Phi2KsKsDecision", + "Hlt2Phi2KsKsD0CtrlDecision", + "Hlt2PhiBs2PhiPhiDecision", + "Hlt2PhiIncPhiDecision", + "Hlt2PhiPhi2EETurboDecision", + "Hlt2PhiPhi2KsKsDecision", + "Hlt2PhiPhi2KsKsD0CtrlDecision", + "Hlt2PhiPhi2MuMuTurboDecision", + "Hlt2PhiPromptPhi2EETurboDecision", + "Hlt2RadiativeB2GammaGammaDecision", + "Hlt2RadiativeB2GammaGammaDDDecision", + "Hlt2RadiativeB2GammaGammaDoubleDecision", + "Hlt2RadiativeB2GammaGammaLLDecision", + "Hlt2RadiativeBd2KstGammaDecision", + "Hlt2RadiativeBd2KstGammaULUnbiasedDecision", + "Hlt2RadiativeBs2PhiGammaDecision", + "Hlt2RadiativeBs2PhiGammaUnbiasedDecision", + "Hlt2RadiativeHypb2L0HGammaOmDecision", + "Hlt2RadiativeHypb2L0HGammaOmEEDecision", + "Hlt2RadiativeHypb2L0HGammaXiDecision", + "Hlt2RadiativeHypb2L0HGammaXiEEDecision", + "Hlt2RadiativeIncHHGammaDecision", + "Hlt2RadiativeIncHHGammaEEDecision", + "Hlt2RadiativeIncHHHGammaDecision", + "Hlt2RadiativeIncHHHGammaEEDecision", + "Hlt2RadiativeLb2L0GammaEELLDecision", + "Hlt2RadiativeLb2L0GammaLLDecision", + "Hlt2RareCharmD02EMuDecision", + "Hlt2RareCharmD02KKMuMuDecision", + "Hlt2RareCharmD02KKMuMuFilterDecision", + "Hlt2RareCharmD02KKMueDecision", + "Hlt2RareCharmD02KKMueFilterDecision", + "Hlt2RareCharmD02KKeeDecision", + "Hlt2RareCharmD02KKeeFilterDecision", + "Hlt2RareCharmD02KMuDecision", + "Hlt2RareCharmD02KPiDecision", + "Hlt2RareCharmD02KPiMuMuDecision", + "Hlt2RareCharmD02KPiMuMuFilterDecision", + "Hlt2RareCharmD02KPiMuMuSSDecision", + "Hlt2RareCharmD02KPiMuMuSSFilterDecision", + "Hlt2RareCharmD02KPiMuMuUntagDecision", + "Hlt2RareCharmD02KPiMueDecision", + "Hlt2RareCharmD02KPiMueFilterDecision", + "Hlt2RareCharmD02KPieeDecision", + "Hlt2RareCharmD02KPieeFilterDecision", + "Hlt2RareCharmD02MuMuDecision", + "Hlt2RareCharmD02PiPiDecision", + "Hlt2RareCharmD02PiPiMuMuDecision", + "Hlt2RareCharmD02PiPiMuMuFilterDecision", + "Hlt2RareCharmD02PiPiMueDecision", + "Hlt2RareCharmD02PiPiMueFilterDecision", + "Hlt2RareCharmD02PiPieeDecision", + "Hlt2RareCharmD02PiPieeFilterDecision", + "Hlt2RareCharmD2KEEOSDecision", + "Hlt2RareCharmD2KEESSDecision", + "Hlt2RareCharmD2KEEWSDecision", + "Hlt2RareCharmD2KEMuOSDecision", + "Hlt2RareCharmD2KMuEOSDecision", + "Hlt2RareCharmD2KMuESSDecision", + "Hlt2RareCharmD2KMuEWSDecision", + "Hlt2RareCharmD2KMuMuFilterDecision", + "Hlt2RareCharmD2KMuMuOSDecision", + "Hlt2RareCharmD2KMuMuSSDecision", + "Hlt2RareCharmD2KMuMuSSFilterDecision", + "Hlt2RareCharmD2KMuMuWSDecision", + "Hlt2RareCharmD2KMueFilterDecision", + "Hlt2RareCharmD2KMueSSFilterDecision", + "Hlt2RareCharmD2KeeFilterDecision", + "Hlt2RareCharmD2KeeSSFilterDecision", + "Hlt2RareCharmD2PiEEOSDecision", + "Hlt2RareCharmD2PiEESSDecision", + "Hlt2RareCharmD2PiEEWSDecision", + "Hlt2RareCharmD2PiEMuOSDecision", + "Hlt2RareCharmD2PiMuEOSDecision", + "Hlt2RareCharmD2PiMuESSDecision", + "Hlt2RareCharmD2PiMuEWSDecision", + "Hlt2RareCharmD2PiMuMuFilterDecision", + "Hlt2RareCharmD2PiMuMuOSDecision", + "Hlt2RareCharmD2PiMuMuSSDecision", + "Hlt2RareCharmD2PiMuMuSSFilterDecision", + "Hlt2RareCharmD2PiMuMuWSDecision", + "Hlt2RareCharmD2PiMueFilterDecision", + "Hlt2RareCharmD2PiMueSSFilterDecision", + "Hlt2RareCharmD2PieeFilterDecision", + "Hlt2RareCharmD2PieeSSFilterDecision", + "Hlt2RareCharmLc2PMuMuDecision", + "Hlt2RareCharmLc2PMuMuFilterDecision", + "Hlt2RareCharmLc2PMuMuSSDecision", + "Hlt2RareCharmLc2PMuMuSSFilterDecision", + "Hlt2RareCharmLc2PMueDecision", + "Hlt2RareCharmLc2PMueFilterDecision", + "Hlt2RareCharmLc2PeeDecision", + "Hlt2RareCharmLc2PeeFilterDecision", + "Hlt2RareStrangeKPiMuMuDecision", + "Hlt2RareStrangeKPiMuMuSSDecision", + "Hlt2RareStrangeKsPiPiEETOSDecision", + "Hlt2RareStrangeSigmaPMuMuDecision", + "Hlt2RareWZD0GammaTurboDecision", + "Hlt2RareWZDiMuonGammaTurboDecision", + "Hlt2RareWZDpGammaTurboDecision", + "Hlt2RareWZDsGammaTurboDecision", + "Hlt2RareWZGammaGammaTurboDecision", + "Hlt2RareWZJPsiDiJetsTurboDecision", + "Hlt2RareWZKaonGammaTurboDecision", + "Hlt2RareWZKs0GammaTurboDecision", + "Hlt2RareWZKstGammaTurboDecision", + "Hlt2RareWZPhiGammaTurboDecision", + "Hlt2RareWZPi0GammaTurboDecision", + "Hlt2RareWZPi0Pi0TurboDecision", + "Hlt2RareWZPionGammaTurboDecision", + "Hlt2RareWZRho0GammaTurboDecision", + "Hlt2SLB_B2D0Mu_D02KmKpTurboDecision", + "Hlt2SLB_B2D0Mu_D02KmPipTurboDecision", + "Hlt2SLB_B2D0Mu_D02PimPipTurboDecision", + "Hlt2SLB_B2DstMu_D02KmKpTurboDecision", + "Hlt2SLB_B2DstMu_D02KmPipTurboDecision", + "Hlt2SLB_B2DstMu_D02PimPipTurboDecision", + "Hlt2SingleMuonDecision", + "Hlt2SingleMuonHighPTDecision", + "Hlt2SingleMuonLowPTDecision", + "Hlt2SingleMuonNoSPDDecision", + "Hlt2SingleMuonRareDecision", + "Hlt2SingleMuonVHighPTDecision", + "Hlt2StrangeKPiPiPiTurboDecision", + "Hlt2StrangeLFVMuonElectronSoftDecision", + "Hlt2TFBc2JpsiMuXDecision", + "Hlt2Topo2BodyDecision", + "Hlt2Topo3BodyDecision", + "Hlt2Topo4BodyDecision", + "Hlt2TopoE2BodyDecision", + "Hlt2TopoE3BodyDecision", + "Hlt2TopoE4BodyDecision", + "Hlt2TopoEE2BodyDecision", + "Hlt2TopoEE3BodyDecision", + "Hlt2TopoEE4BodyDecision", + "Hlt2TopoMu2BodyDecision", + "Hlt2TopoMu3BodyDecision", + "Hlt2TopoMu4BodyDecision", + "Hlt2TopoMuE2BodyDecision", + "Hlt2TopoMuE3BodyDecision", + "Hlt2TopoMuE4BodyDecision", + "Hlt2TopoMuMu2BodyDecision", + "Hlt2TopoMuMu3BodyDecision", + "Hlt2TopoMuMu4BodyDecision", + "Hlt2TopoMuMuDDDecision", + "Hlt2TrackEffDiMuonDownstreamMinusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamMinusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamMinusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamMinusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamMinusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamMinusTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonDownstreamPlusTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTMinusTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonMuonTTPlusTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonMinusTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusHighStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusHighStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusLowStatMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusLowStatTaggedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusMatchedTurboCalibDecision", + "Hlt2TrackEffDiMuonVeloMuonPlusTaggedTurboCalibDecision", + "Hlt2TrackEffElectronDetachedEEKTurboCalibDecision", + "Hlt2TrackEffElectronDetachedEEKstarTurboCalibDecision", + "Hlt2TrackEffElectronDetachedEEPhiTurboCalibDecision", + "Hlt2TrackEffElectronDetachedEKTurboCalibDecision", + "Hlt2TrackEffElectronDetachedEPiTurboCalibDecision", + "Hlt2TrackEffElectronDetachedMuKTurboCalibDecision", + "Hlt2TrackEffElectronDetachedMuMuKTurboCalibDecision", + "Hlt2TrackEffElectronDetachedMuMuKstarTurboCalibDecision", + "Hlt2TrackEffElectronDetachedMuMuPhiTurboCalibDecision", + "Hlt2TrackEffElectronDetachedMuPiTurboCalibDecision", + "Hlt2TrackEffElectronDetachedProtonProtonPhiTurboCalibDecision", + "Hlt2TrackEff_D0ToK3piPionProbeTurboDecision", + "Hlt2TrackEff_D0ToKpiKaonProbeDecision", + "Hlt2TrackEff_D0ToKpiKaonProbeTurboDecision", + "Hlt2TrackEff_D0ToKpiPionProbeDecision", + "Hlt2TrackEff_D0ToKpiPionProbeTurboDecision", + "Hlt2TrackEff_DsToPhiPiKaonProbeTurboDecision", + "Hlt2TransparentDecision", + "Hlt2TriMuonDetachedDecision", + "Hlt2TriMuonTau23MuDecision", + "Hlt2Xc3PiXForTauD02KpiDecision", + "Hlt2Xc3PiXForTauD02KpiNonPhysDecision", + "Hlt2Xc3PiXForTauD02KpiWSDecision", + "Hlt2Xc3PiXForTauDp2KpipiDecision", + "Hlt2Xc3PiXForTauDp2KpipiNonPhysDecision", + "Hlt2Xc3PiXForTauDp2KpipiWSDecision", + "Hlt2Xc3PiXForTauDs2kkpiDecision", + "Hlt2Xc3PiXForTauDs2kkpiNonPhysDecision", + "Hlt2Xc3PiXForTauDs2kkpiWSDecision", + "Hlt2Xc3PiXForTauJpsi2mumuDecision", + "Hlt2Xc3PiXForTauJpsi2mumuNonPhysDecision", + "Hlt2Xc3PiXForTauLc2pkpiDecision", + "Hlt2Xc3PiXForTauLc2pkpiNonPhysDecision", + "Hlt2Xc3PiXForTauLc2pkpiWSDecision", + "Hlt2XcMuXForTauB2XcFakeMuDecision", + "Hlt2XcMuXForTauB2XcFakePDecision", + "Hlt2XcMuXForTauB2XcMuDecision", + "Hlt2XcMuXForTauB2XcSSPDecision", + "Hlt2XcMuXForTauB2XcSSPFakePDecision", + ] + +def allRun1Lines(): + return [ "Hlt1BeamGasBeam1Decision", + "Hlt1BeamGasBeam2Decision", + "Hlt1BeamGasCrossingEnhancedBeam1Decision", + "Hlt1BeamGasCrossingEnhancedBeam2Decision", + "Hlt1BeamGasCrossingForcedRecoDecision", + "Hlt1BeamGasCrossingForcedRecoFullZDecision", + "Hlt1BeamGasCrossingParasiticDecision", + "Hlt1BeamGasHighRhoVerticesDecision", + "Hlt1BeamGasNoBeamBeam1Decision", + "Hlt1BeamGasNoBeamBeam2Decision", + "Hlt1CharmCalibrationNoBiasDecision", + "Hlt1DiMuonHighMassDecision", + "Hlt1DiMuonLowMassDecision", + "Hlt1DiProtonDecision", + "Hlt1DiProtonLowMultDecision", + "Hlt1ErrorEventDecision", + "Hlt1GlobalDecision", + "Hlt1L0AnyDecision", + "Hlt1L0AnyNoSPDDecision", + "Hlt1L0AnyNoSPDRateLimitedDecision", + "Hlt1L0AnyRateLimitedDecision", + "Hlt1L0HighSumETJetDecision", + "Hlt1LumiDecision", + "Hlt1LumiMidBeamCrossingDecision", + "Hlt1MBMicroBiasTStationDecision", + "Hlt1MBMicroBiasTStationRateLimitedDecision", + "Hlt1MBMicroBiasVeloDecision", + "Hlt1MBMicroBiasVeloRateLimitedDecision", + "Hlt1MBNoBiasDecision", + "Hlt1NoPVPassThroughDecision", + "Hlt1ODINTechnicalDecision", + "Hlt1SingleElectronNoIPDecision", + "Hlt1SingleMuonHighPTDecision", + "Hlt1SingleMuonNoIPDecision", + "Hlt1Tell1ErrorDecision", + "Hlt1TrackAllL0Decision", + "Hlt1TrackAllL0TightDecision", + "Hlt1TrackForwardPassThroughDecision", + "Hlt1TrackForwardPassThroughLooseDecision", + "Hlt1TrackMuonDecision", + "Hlt1TrackPhotonDecision", + "Hlt1VeloClosingMicroBiasDecision", + "Hlt1VertexDisplVertexDecision", + "Hlt2B2HHDecision", + "Hlt2B2HHLTUnbiasedDecision", + "Hlt2B2HHLTUnbiasedDetachedDecision", + "Hlt2B2HHPi0_MergedDecision", + "Hlt2Bd2KstGammaDecision", + "Hlt2Bd2KstGammaWideBMassDecision", + "Hlt2Bd2KstGammaWideKMassDecision", + "Hlt2Bs2PhiGammaDecision", + "Hlt2Bs2PhiGammaWideBMassDecision", + "Hlt2CharmHadD02HHHHDecision", + "Hlt2CharmHadD02HHHHDst_2K2piDecision", + "Hlt2CharmHadD02HHHHDst_2K2piWideMassDecision", + "Hlt2CharmHadD02HHHHDst_3KpiDecision", + "Hlt2CharmHadD02HHHHDst_3KpiWideMassDecision", + "Hlt2CharmHadD02HHHHDst_4piDecision", + "Hlt2CharmHadD02HHHHDst_4piWideMassDecision", + "Hlt2CharmHadD02HHHHDst_K3piDecision", + "Hlt2CharmHadD02HHHHDst_K3piWideMassDecision", + "Hlt2CharmHadD02HHHHDst_KKpipiDecision", + "Hlt2CharmHadD02HHHHDst_KKpipiWideMassDecision", + "Hlt2CharmHadD02HHHHWideMassDecision", + "Hlt2CharmHadD02HHHH_2K2piDecision", + "Hlt2CharmHadD02HHHH_2K2piWideMassDecision", + "Hlt2CharmHadD02HHHH_3KpiDecision", + "Hlt2CharmHadD02HHHH_3KpiWideMassDecision", + "Hlt2CharmHadD02HHHH_4piDecision", + "Hlt2CharmHadD02HHHH_4piWideMassDecision", + "Hlt2CharmHadD02HHHH_K3piDecision", + "Hlt2CharmHadD02HHHH_K3piWideMassDecision", + "Hlt2CharmHadD02HHHH_KKpipiDecision", + "Hlt2CharmHadD02HHHH_KKpipiWideMassDecision", + "Hlt2CharmHadD02HHKsDDDecision", + "Hlt2CharmHadD02HHKsLLDecision", + "Hlt2CharmHadD02HHXDst_hhXDecision", + "Hlt2CharmHadD02HHXDst_hhXWideMassDecision", + "Hlt2CharmHadD02HH_D02KKDecision", + "Hlt2CharmHadD02HH_D02KKWideMassDecision", + "Hlt2CharmHadD02HH_D02KPiDecision", + "Hlt2CharmHadD02HH_D02KPiWideMassDecision", + "Hlt2CharmHadD02HH_D02PiPiDecision", + "Hlt2CharmHadD02HH_D02PiPiWideMassDecision", + "Hlt2CharmHadD2HHHDecision", + "Hlt2CharmHadD2HHHWideMassDecision", + "Hlt2CharmHadD2KS0H_D2KS0DDKDecision", + "Hlt2CharmHadD2KS0H_D2KS0DDPiDecision", + "Hlt2CharmHadD2KS0H_D2KS0KDecision", + "Hlt2CharmHadD2KS0H_D2KS0PiDecision", + "Hlt2CharmHadD2KS0KS0Decision", + "Hlt2CharmHadD2KS0KS0WideMassDecision", + "Hlt2CharmHadLambdaC2KPKDecision", + "Hlt2CharmHadLambdaC2KPKWideMassDecision", + "Hlt2CharmHadLambdaC2KPPiDecision", + "Hlt2CharmHadLambdaC2KPPiWideMassDecision", + "Hlt2CharmHadLambdaC2PiPKDecision", + "Hlt2CharmHadLambdaC2PiPKWideMassDecision", + "Hlt2CharmHadLambdaC2PiPPiDecision", + "Hlt2CharmHadLambdaC2PiPPiWideMassDecision", + "Hlt2CharmHadMinBiasD02KKDecision", + "Hlt2CharmHadMinBiasD02KPiDecision", + "Hlt2CharmHadMinBiasDplus2hhhDecision", + "Hlt2CharmHadMinBiasLambdaC2KPPiDecision", + "Hlt2CharmHadMinBiasLambdaC2LambdaPiDecision", + "Hlt2CharmRareDecayD02MuMuDecision", + "Hlt2CharmSemilep3bodyD2KMuMuDecision", + "Hlt2CharmSemilep3bodyD2KMuMuSSDecision", + "Hlt2CharmSemilep3bodyD2PiMuMuDecision", + "Hlt2CharmSemilep3bodyD2PiMuMuSSDecision", + "Hlt2CharmSemilep3bodyLambdac2PMuMuDecision", + "Hlt2CharmSemilep3bodyLambdac2PMuMuSSDecision", + "Hlt2CharmSemilepD02HHMuMuDecision", + "Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuonsDecision", + "Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuonsWideMassDecision", + "Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuonsDecision", + "Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuonsWideMassDecision", + "Hlt2CharmSemilepD02HHMuMuWideMassDecision", + "Hlt2CharmSemilepD02HMuNu_D02KMuNuDecision", + "Hlt2CharmSemilepD02HMuNu_D02KMuNuTightDecision", + "Hlt2CharmSemilepD02HMuNu_D02KMuNuWSDecision", + "Hlt2CharmSemilepD02HMuNu_D02PiMuNuDecision", + "Hlt2CharmSemilepD02HMuNu_D02PiMuNuWSDecision", + "Hlt2CharmSemilepD02KKMuMuDecision", + "Hlt2CharmSemilepD02KPiMuMuDecision", + "Hlt2CharmSemilepD02PiPiMuMuDecision", + "Hlt2CharmSemilepD2HMuMuDecision", + "Hlt2CharmSemilepD2HMuMuWideMassDecision", + "Hlt2DebugEventDecision", + "Hlt2DiElectronBDecision", + "Hlt2DiElectronHighMassDecision", + "Hlt2DiMuonDecision", + "Hlt2DiMuonAndD0Decision", + "Hlt2DiMuonAndDpDecision", + "Hlt2DiMuonAndDsDecision", + "Hlt2DiMuonAndGammaDecision", + "Hlt2DiMuonAndLcDecision", + "Hlt2DiMuonAndMuonDecision", + "Hlt2DiMuonBDecision", + "Hlt2DiMuonDY1Decision", + "Hlt2DiMuonDY2Decision", + "Hlt2DiMuonDY3Decision", + "Hlt2DiMuonDY4Decision", + "Hlt2DiMuonDetachedDecision", + "Hlt2DiMuonDetachedHeavyDecision", + "Hlt2DiMuonDetachedJPsiDecision", + "Hlt2DiMuonDetachedPsi2SDecision", + "Hlt2DiMuonJPsiDecision", + "Hlt2DiMuonJPsiHighPTDecision", + "Hlt2DiMuonLowMassDecision", + "Hlt2DiMuonPsi2SDecision", + "Hlt2DiMuonPsi2SHighPTDecision", + "Hlt2DiMuonZDecision", + "Hlt2DiPhiDecision", + "Hlt2DiProtonDecision", + "Hlt2DiProtonLowMultDecision", + "Hlt2DiProtonLowMultTFDecision", + "Hlt2DiProtonTFDecision", + "Hlt2DisplVerticesDoubleDecision", + "Hlt2DisplVerticesDoublePSDecision", + "Hlt2DisplVerticesDoublePostScaledDecision", + "Hlt2DisplVerticesHighFDSingleDecision", + "Hlt2DisplVerticesHighMassSingleDecision", + "Hlt2DisplVerticesLowMassSingleDecision", + "Hlt2DisplVerticesSingleDecision", + "Hlt2DisplVerticesSingleDownDecision", + "Hlt2DisplVerticesSingleHighFDDecision", + "Hlt2DisplVerticesSingleHighFDPostScaledDecision", + "Hlt2DisplVerticesSingleHighMassDecision", + "Hlt2DisplVerticesSingleHighMassPostScaledDecision", + "Hlt2DisplVerticesSingleLoosePSDecision", + "Hlt2DisplVerticesSingleMVPostScaledDecision", + "Hlt2DisplVerticesSinglePSDecision", + "Hlt2DisplVerticesSinglePostScaledDecision", + "Hlt2DisplVerticesSingleVeryHighFDDecision", + "Hlt2DoubleDiMuonDecision", + "Hlt2Dst2PiD02KMuDecision", + "Hlt2Dst2PiD02KPiDecision", + "Hlt2Dst2PiD02MuMuDecision", + "Hlt2Dst2PiD02PiPiDecision", + "Hlt2ErrorEventDecision", + "Hlt2ExpressBeamHaloDecision", + "Hlt2ExpressD02KPiDecision", + "Hlt2ExpressDStar2D0PiDecision", + "Hlt2ExpressDs2PhiPiDecision", + "Hlt2ExpressHLT1PhysicsDecision", + "Hlt2ExpressJPsiDecision", + "Hlt2ExpressJPsiTagProbeDecision", + "Hlt2ExpressKSDecision", + "Hlt2ExpressLambdaDecision", + "Hlt2ForwardDecision", + "Hlt2GlobalDecision", + "Hlt2IncPhiDecision", + "Hlt2IncPhiSidebandsDecision", + "Hlt2LambdaC_LambdaC2Lambda0DDKDecision", + "Hlt2LambdaC_LambdaC2Lambda0DDPiDecision", + "Hlt2LambdaC_LambdaC2Lambda0LLKDecision", + "Hlt2LambdaC_LambdaC2Lambda0LLPiDecision", + "Hlt2LowMultChiC2HHDecision", + "Hlt2LowMultChiC2HHHHDecision", + "Hlt2LowMultChiC2HHHHWSDecision", + "Hlt2LowMultChiC2HHWSDecision", + "Hlt2LowMultD2K3PiDecision", + "Hlt2LowMultD2K3PiWSDecision", + "Hlt2LowMultD2KPiDecision", + "Hlt2LowMultD2KPiPiDecision", + "Hlt2LowMultD2KPiPiWSDecision", + "Hlt2LowMultD2KPiWSDecision", + "Hlt2LowMultDDIncDecision", + "Hlt2LowMultElectronDecision", + "Hlt2LowMultElectron_nofilterDecision", + "Hlt2LowMultHadronDecision", + "Hlt2LowMultHadron_nofilterDecision", + "Hlt2LowMultMuonDecision", + "Hlt2LowMultPhotonDecision", + "Hlt2LumiDecision", + "Hlt2MuonFromHLT1Decision", + "Hlt2PassThroughDecision", + "Hlt2RadiativeTopoPhotonDecision", + "Hlt2RadiativeTopoPhotonL0Decision", + "Hlt2RadiativeTopoTrackDecision", + "Hlt2RadiativeTopoTrackTOSDecision", + "Hlt2SingleElectronTFHighPtDecision", + "Hlt2SingleElectronTFLowPtDecision", + "Hlt2SingleMuonDecision", + "Hlt2SingleMuonHighPTDecision", + "Hlt2SingleMuonLowPTDecision", + "Hlt2SingleMuonVHighPTDecision", + "Hlt2SingleTFElectronDecision", + "Hlt2SingleTFVHighPtElectronDecision", + "Hlt2TFBc2JpsiMuXDecision", + "Hlt2TFBc2JpsiMuXSignalDecision", + "Hlt2Topo2BodyBBDTDecision", + "Hlt2Topo2BodySimpleDecision", + "Hlt2Topo3BodyBBDTDecision", + "Hlt2Topo3BodySimpleDecision", + "Hlt2Topo4BodyBBDTDecision", + "Hlt2Topo4BodySimpleDecision", + "Hlt2TopoE2BodyBBDTDecision", + "Hlt2TopoE3BodyBBDTDecision", + "Hlt2TopoE4BodyBBDTDecision", + "Hlt2TopoMu2BodyBBDTDecision", + "Hlt2TopoMu3BodyBBDTDecision", + "Hlt2TopoMu4BodyBBDTDecision", + "Hlt2TopoRad2BodyBBDTDecision", + "Hlt2TopoRad2plus1BodyBBDTDecision", + "Hlt2TransparentDecision", + "Hlt2TriMuonDetachedDecision", + "Hlt2TriMuonTauDecision", + "Hlt2diPhotonDiMuonDecision", + ] + +def allLines(run): + if (1==run): return allRun1Lines() + else: return allRun2Lines() + +def L0Lines(): + return ["L0HadronDecision", + "L0MuonDecision", + "L0MuonLooseDecision", + "L0DiMuonDecision", + "L0ElectronDecision", + "L0ElectronLooseDecision", + "L0PhotonDecision"] + +def L0LowMultLines(): + return ["L0DiEM,lowMultDecision", + "L0DiHadron,lowMultDecision", + "L0DiMuon,lowMultDecision", + "L0Electron,lowMultDecision", + "L0Muon,lowMultDecision", + "L0Photon,lowMultDecision", + ] + +def commonLines(run): + a = allLines(run) + l = L0Lines() + for i in a: + if 'TrackAll' in i: + if (1==run): l.append(i) # run1 + if 'TrackMVA' in i: + if (2==run): l.append(i) # run2 + if (2==run): # run2 -> short + if (i=="Hlt2Topo2BodyDecision" or i=="Hlt2Topo3BodyDecision" or i=="Hlt2Topo4BodyDecision"): l.append(i) + if (1==run): # run1 -> long + if (i=="Hlt2Topo2BodyBBDTDecision" or i=="Hlt2Topo3BodyBBDTDecision" or i=="Hlt2Topo4BodyBBDTDecision"): l.append(i) + return l + +def muonLines(run): + a = allLines(run) + l = topoMuLines(run) + for i in a: + if 'Muon' in i and not ('DY' in i or 'Charm' in i or 'DiMuonAnd' in i or 'DiMuonZ' in i or 'Double' in i or 'TriMuon' in i or "PhotonDiMuon" in i or "TrackEff" in i or "PID" in i or "Calib" in i) : l.append(i) + return l + +def topoMuLines(run): + a = allLines(run) + l = commonLines(run) + for i in a: + if (2==run): # run2 -> short + if (i=="Hlt2TopoMu2BodyDecision" or i=="Hlt2TopoMu3BodyDecision" or i=="Hlt2TopoMu4BodyDecision"): l.append(i) + if (1==run): # run1 -> long + if (i=="Hlt2Topo2MuBodyBBDTDecision" or i=="Hlt2TopoMu3BodyBBDTDecision" or i=="Hlt2TopoMu4BodyBBDTDecision"): l.append(i) + return l + +def electronLines(run): + a = allLines(run) + l = commonLines(run) + for i in a: + if 'Electron' in i: l.append(i) + if 'TopoE' in i: l.append(i) + return l + +def cepLines(run): + a = allLines(run) + l = L0LowMultLines() + l.append('Hlt1LowMultDecision') + for i in a: + # Cristina: add all LowMult lines + if 'CalibHighPT' in i: l.append(i) + if 'Hlt1CEP' in i: l.append(i) + if 'Hlt1LowMult' in i: l.append(i) + if 'Hlt1DiProtonLowMult' in i: l.append(i) + if 'Hlt2DiProtonLowMult' in i: l.append(i) + if 'Hlt2LowMultDi' in i: l.append(i) + if 'Hlt2LowMultHadron' in i: l.append(i) + if 'Hlt2LowMultMuon' in i: l.append(i) + # Code from Patrick commented out: + #if 'LowMultMuon' not in i: continue + #if 'Muon' in i: l.append(i) + #if 'Electron' in i: l.append(i) + #if 'Leptons' in i: l.append(i) + #if 'PassThrough' in i: l.append(i) + return l + +def jpsi2eeAllL0HLT1Lines(run): + a = allLines(run) + l = L0Lines() + for i in a: + if 'Hlt1' in i: l.append(i) + if 'Hlt2' and 'Electron' in i: l.append(i) + for i in a: + if (2==run): # run2 -> short + if (i=="Hlt2TopoMu2BodyDecision" or i=="Hlt2TopoMu3BodyDecision" or i=="Hlt2TopoMu4BodyDecision"): l.append(i) + return l diff --git a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py new file mode 100644 index 0000000000..7ef2f7340a --- /dev/null +++ b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py @@ -0,0 +1,490 @@ +from Gaudi.Configuration import * +from DecayTreeTuple.Configuration import * +from AllTriggerLines import * + +# Decays +Bd2JpsiKS0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(KS0 -> ^pi+ ^pi-)" +Psi2S2Jpsipipi = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-" +Psi2S2JpsiMuMupipi = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-" +Psi2S2JpsiEEpipi = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi+ ^pi-" +Psi2S2JpsiMuMupi0pi0 = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0 ^pi0" +Psi2S2JpsiEEpi0pi0 = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi0 ^pi0" +Psi2S2Chic0MuMuGamma = "psi(2S) -> ^(chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma" +Psi2S2Chic0EEGamma = "psi(2S) -> ^(chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma" +Psi2S2Chic1MuMuGamma = "psi(2S) -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma" +Psi2S2Chic1EEGamma = "psi(2S) -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma" +Psi2S2Chic2MuMuGamma = "psi(2S) -> ^(chi_c2(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma" +Psi2S2Chic2EEGamma = "psi(2S) -> ^(chi_c2(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma" +Psi2S2JpsiMuMuEta = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^eta" +Psi2S2JpsiEEEta = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^eta" +Psi2S2JpsiMuMupi0 = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0" +Psi2S2JpsiEEpi0 = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi0" +X2Jpsipipi = "X_1(3872) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-" +X2JpsiKK = "X_1(3872) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+ ^K-" +Jpsi2MuMu = "J/psi(1S) -> ^mu+ ^mu-" +Chic02JpsiMuMuGamma = "chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma" +Chic02JpsiEEGamma = "chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma" +Chic12JpsiMuMuGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma" +Chic12JpsiEEGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma" +Chic22JpsiMuMuGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma" +Chic22JpsiEEGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma" +Jpsi2ee = "J/psi(1S) -> ^e+ ^e-" +Jpsi2MuMuSS = "[J/psi(1S) -> ^mu+ ^mu+]CC" +Bu2MuMuK = "[B+ -> ^(J/psi(1S) -> ^mu- ^mu+) ^K+ ]CC" +Bu2eeK = "[B+ -> ^(J/psi(1S) -> ^e- ^e+) ^K+ ]CC" +Bu2MueK = "[B+ -> ^(J/psi(1S) -> ^mu- ^e+) ^K+ ]CC" +Bu2eMuK = "[B+ -> ^(J/psi(1S) -> ^e- ^mu+) ^K+ ]CC" +Bu2JpsiPi = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+]CC" +Bu2JpsiK = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" +Bs2JpsiPhi = "B_s0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(phi(1020) -> ^K+ ^K-)" +Bd2JpsiPi0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0" +Bd2JpsiKstar = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC" + +Bd2eeKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" +Bd2MuMuKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" +Bd2MuMuKstSS = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu+) ^(K*(892)0 -> ^K+ ^pi-) ]CC" +Bd2MueKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" +Bd2eMuKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" +Lambdab2MuMupK = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda(1520)0 -> ^p+ ^K-) ]CC" + +Lambdab2Jpsippi = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^p+ ^pi-]CC" +Lambdab2JpsiLambda = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)]CC" +Xib2Lambdabpi = "[Xi_b- -> ^(Lambda_b0 -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)) ^pi- ]CC" +Xib2LambdabpiWS = "[Xi_b~+ -> ^(Lambda_b0 -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)) ^pi+ ]CC" +Xib2PsiLpi = "[Xi_b- -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-) ^pi- ]CC" +Xib2PsiLpiWS = "[Xi_b~+ -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-) ^pi+ ]CC" + +############################################################################## +# +# Tuple maker +# +def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=["DTF","Resonant"], Inputs = [] ): + from Configurables import DecayTreeTuple, PrintDecayTree, FilterDesktop, GaudiSequencer, PrintHeader, TESCheck, CheckPV, DaVinci + + if shortname == "": shortname = name + shortname = shortname+"_Tuple" # +datatype + shortname = shortname.replace("MCMC","MC") + seq = GaudiSequencer("Seq"+shortname) + dtf = ("DTF" in options) + resonant = ("Resonant" in options) + short = ("Short" in options) + run = 2 + if ("Run1" in options): run = 1 + + if not Inputs : Inputs = [ name+"/Particles" ] + +# if ("MC"==datatype or ""==datatype): location = "/Event/Phys/"+name+"/Particles" +# if ("TURBO"!=datatype): +# from Configurables import LoKi__HDRFilter +# filter = TESCheck("Check"+shortname, Inputs = Inputs, Stop = False) +# else : # I am not running the selection, hence the stripping decision must be here +# filter = LoKi__HDRFilter( "Check"+shortname, +# Code = "HLT_PASS('Stripping"+name+"Decision')", +# Location="/Event/Strip/Phys/DecReports" ) +# seq.Members += [ filter ] # PrintHeader(), + + tuple = DecayTreeTuple(shortname) + if (short): tuple.ToolList = [] + isMDST = (datatype.upper()=="MDST") + isTURBO = (datatype.upper()=="TURBO") + tuple.Inputs = Inputs + +# tuple.OutputLevel = 1 + tuple.ToolList = [] + + tuple.Decay = decay + + if (not short): + tg = tuple.addTupleTool("TupleToolGeometry") + if not isMDST and not isTURBO: tg.FillMultiPV = True + + tlist = [] + if ( "AllLines" in options): + tlist = allLines(run) + elif ( "L0eLines+AllLines" in options): + tlist = jpsi2eeAllL0HLT1Lines(run) + elif ( "CEP" in options): + tlist = cepLines(run) + elif ("e+" in decay): + tlist = electronLines(run) + elif ( decay == Jpsi2MuMu or decay == Jpsi2MuMuSS or decay == Psi2S2Jpsipipi or decay == X2Jpsipipi or decay == X2JpsiKK or decay == Chic12JpsiMuMuGamma or decay == Chic02JpsiMuMuGamma or decay == Chic22JpsiMuMuGamma): + tlist = muonLines(run) + elif ("mu+" in decay): + tlist = muonLines(run) + tlist.append(topoMuLines(run)) + if ( False ): + tlist = allLines(run) + print tlist + + # psi branch + Psi = tuple.addTupleTool("TupleToolDecay/Psi") + if ( Jpsi2ee != decay and Jpsi2MuMu != decay): bpsi = (decay.replace("^","")).replace("(J/psi(1S)","^(J/psi(1S)") + else : bpsi = "^("+decay.replace("^","")+")" + print "J/psi branch is `` ", bpsi, "''" + tuple.Branches["Psi"] = bpsi + + # sort out kstars + if "892" in decay: + bkstar = (decay.replace("^","")).replace("(K*(892)","^(K*(892)") + tuple.Branches["Kstar"] = bkstar + Kstar = tuple.addTupleTool("TupleToolDecay/Kstar") + + from Configurables import TupleToolTISTOS + tistos = TupleToolTISTOS(TriggerList = tlist, VerboseHlt1 = True, VerboseHlt2 = True, VerboseL0 = True)#, TUS = True, TPS = True) + #tistos.OutputLevel = 1 + + if ( not Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay and not X2Jpsipipi==decay and not X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay or Psi2S2Jpsipipi == decay): + Psi.addTool(tistos) + Psi.ToolList += [ "TupleToolTISTOS" ] +# if (not isMDST): +# vi = tuple.Psi.addTupleTool("TupleToolVtxIsoln") +# vi.InputParticles = [ "/Event/Phys/MyGoodPions" ] + + if ( Jpsi2ee == decay or Jpsi2MuMu == decay or Jpsi2MuMuSS == decay ): # Psi + if (dtf): + pvfit = tuple.Psi.addTupleTool("TupleToolDecayTreeFitter/PVFit") # fit with all constraints I can think of + pvfit.Verbose = True + pvfit.constrainToOriginVertex = ( "Constrain" in options ) # Usually not + + elif ( Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay or X2Jpsipipi==decay or X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay or Psi2S2Jpsipipi == decay): # X(3872) and so + if (Psi2S2Jpsipipi == decay or Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay or X2Jpsipipi==decay or X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay): theX = "psi_2S" + elif (X2Jpsipipi==decay or X2JpsiKK==decay): theX = "X" + psipipi = tuple.addTupleTool("TupleToolDecay/"+theX) + tuple.Branches[theX] = "^("+decay.replace("^","")+")" + psipipi.addTool(tistos) + psipipi.ToolList += [ "TupleToolTISTOS" ] + if (dtf): + psifit = psipipi.addTupleTool("TupleToolDecayTreeFitter/JpsiFit") + psifit.Verbose = True + psifit.constrainToOriginVertex = False + psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi + + elif ( Chic12JpsiMuMuGamma == decay or Chic02JpsiMuMuGamma == decay or Chic22JpsiMuMuGamma == decay or Chic12JpsiEEGamma == decay or Chic02JpsiEEGamma == decay or Chic22JpsiEEGamma == decay or "chi" in decay): # chic + chic = tuple.addTupleTool("TupleToolDecay/Chic") + tuple.Branches["Chic"] = "^("+decay.replace("^","")+")" + chic.addTool(tistos) + chic.ToolList += [ "TupleToolTISTOS" ] + if (dtf): + psifit = chic.addTupleTool("TupleToolDecayTreeFitter/JpsiFit") + psifit.Verbose = True + psifit.constrainToOriginVertex = False + psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi + + else: # it's a b-hadron. Dtf will be done + B = tuple.addTupleTool("TupleToolDecay/B") + bh = "UNDEFINED" + if ('Xi_b-' in decay ): bh = 'Xi_b-' + elif ('Xi_b~+' in decay ): bh = 'Xi_b~+' + elif ('Lambda_b0' in decay ): bh = 'Lambda_b0' + elif ('B0' in decay): bh = 'B0' + elif ('B+' in decay ): bh = 'B+' + elif ('B_s0' in decay ): bh = 'B_s0' + if ('CC' in decay): bh = '['+bh+']cc' + print "Branch will be ``", bh+" : "+decay.replace("^",""), "''" + + tuple.Branches["B"] = "^("+decay.replace("^","")+")" + + # This is needed for ConstB + bhh = bh.replace('[','').replace(']cc','') + + if ( Psi2S2Jpsipipi == decay or X2Jpsipipi==decay or X2JpsiKK==decay): + B.addTool(tistos) + B.ToolList += [ "TupleToolTISTOS" ] + + if ( Bs2JpsiPhi==decay ): + p2vv = B.addTupleTool("TupleToolP2VV") + p2vv.Calculator = "Bs2JpsiPhiAngleCalculator" + elif ( "K*(892)0" in decay and not Bd2MuMuKstSS==decay ): + p2vv = B.addTupleTool("TupleToolP2VV") + p2vv.Calculator = "Bd2KstarMuMuAngleCalculator" + if (Lambdab2Jpsippi==decay ): B.addTupleTool("TupleToolDalitz") + + if (('pi0' not in decay) and ('KS0' not in decay) and ('Lambda0' not in decay)): +# B.ToolList += [ "TupleToolAngles"] + tta = tuple.addTupleTool("TupleToolAngles") + if (not resonant): tta.WRTMother = False +# if (( 'K*(892)0' in decay) or ('phi' in decay)): tuple.B.ToolList += [ "TupleToolP2VV" ] # really wants a VV + if (dtf): + FullFit = B.addTupleTool("TupleToolDecayTreeFitter/FullFit") + FullFit.Verbose = True # fills daughters + FullFit.constrainToOriginVertex = True # else constrain pointing + FullFit.daughtersToConstrain += [ "J/psi(1S)" ] # even non resonant + + if ("ConstBFit" in verbose): + ConstBFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBFit") + ConstBFit.Verbose = True + ConstBFit.constrainToOriginVertex = True + ConstBFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well + ConstBFit.UpdateDaughters = True # Maurizio's daughters + + for d in [ 'KS0', 'pi0', 'Lambda0' ]: + if d in decay: + FullFit.daughtersToConstrain += [ d ] + if ( "ConstBFit" in verbose ): ConstBFit.daughtersToConstrain += [ d ] + if (not resonant): + NoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/NoPsiFit") + NoPsiFit.Verbose = True + NoPsiFit.constrainToOriginVertex = True + if (not resonant): #b constraint for calculating qsq + ConstBNoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBNoPsiFit") + ConstBNoPsiFit.Verbose = True + ConstBNoPsiFit.constrainToOriginVertex = True + ConstBNoPsiFit.daughtersToConstrain += [ bhh ] # constrain B as well + ConstBNoPsiFit.UpdateDaughters = True # Maurizio's daughters + + #if (resonant and ('KS0' in decay or "pi0" in decay or 'Lambda0' in decay)): + # OnlyPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/OnlyPsiFit") + # OnlyPsiFit.Verbose = True + # OnlyPsiFit.constrainToOriginVertex = True + # OnlyPsiFit.daughtersToConstrain += [ "J/psi(1S)" ] + if ('phi' in decay): + substitute1 = { 'Beauty -> Meson (Strange -> ^K+ K-)': 'pi+' } + from Configurables import TupleToolDecayTreeFitter + subDTF = TupleToolDecayTreeFitter("SubPipKm", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute1) + B.addTool(subDTF) + B.ToolList += [ "TupleToolDecayTreeFitter/SubPipKm" ] + + B.addTool(subDTF) + substitute2 = { 'Beauty -> Meson (Strange -> K+ ^K-)': 'pi-' } + B.addTool(subDTF.clone("SubKpPim",Substitutions=substitute2)) + B.ToolList += [ "TupleToolDecayTreeFitter/SubKpPim" ] + + if ( Lambdab2Jpsippi==decay ): + substitute1 = { 'Beauty -> Meson p+ ^pi-': 'K-', 'Beauty -> Meson p~- ^pi+': 'K+' } + from Configurables import TupleToolDecayTreeFitter + B.addTupleTool(TupleToolDecayTreeFitter("SubpK", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute1)) + + substitute2 = { 'Beauty -> Meson ^p+ pi-': 'K+', 'Beauty -> Meson ^p~- pi+': 'K-' } + B.addTupleTool(TupleToolDecayTreeFitter("SubKpi", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute2)) + if ("ConstBFit" in verbose): + ConstBSubFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBSubFit") + ConstBSubFit.Substitutions=substitute1 # substitute and then constrain + ConstBSubFit.Verbose = True + ConstBSubFit.constrainToOriginVertex = True + ConstBSubFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well + ConstBSubFit.UpdateDaughters = True # Maurizio's daughters + + if ( Bd2JpsiKS0==decay ): + substitute1 = { 'Beauty -> Meson (Strange -> ^pi+ pi-)' : 'K+' } + substitute2 = { 'Beauty -> Meson (Strange -> pi+ ^pi-)' : 'K-' } + from Configurables import TupleToolDecayTreeFitter + B.addTupleTool(TupleToolDecayTreeFitter("PsiKppim", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute1)) + + B.addTupleTool(TupleToolDecayTreeFitter("PsiKmpip", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute2)) + + if ( Bu2JpsiK == decay): + + substitute2 = { 'Beauty -> Meson ^K+': 'pi+', 'Beauty -> Meson ^K-': 'pi-' } + subDTF2 = B.addTupleTool(TupleToolDecayTreeFitter("Subpi", Verbose=False, + daughtersToConstrain = [ "J/psi(1S)" ], + constrainToOriginVertex=True, + Substitutions=substitute2)) + + if ( Bu2eeK == decay or Bu2MuMuK == decay or Bu2MueK == decay or Bu2eMuK == decay): + if Bu2eeK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" , + "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" } + elif Bu2MuMuK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" , + "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" } + elif Bu2MueK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" , + "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" } + elif Bu2eMuK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" , + "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" } + + from Configurables import TupleToolDecayTreeFitter + subDTF = B.addTupleTool(TupleToolDecayTreeFitter("Subpipi", Verbose=False, + constrainToOriginVertex=True, + Substitutions=substitute1, + UpdateDaughters = True)) # Maurizio's daughters + +# """ +# if (('KS0' in decay) or ("K*(892)" in decay) or ("Lambda0" in decay)): +# mh = tuple.addTupleTool("TupleToolMassHypo") +# if ("KS0" in decay): +# mh.PIDReplacements = { "pi+" : "p+" } +# #if ("K*(892)" in decay): +# # mh.PIDReplacements = { "pi-" : "K+" } +# if ("Lambda0" in decay): +# mh.PIDReplacements = { "p+" : "pi+" } +# """ + + B.addTool(tistos) + B.ToolList += [ "TupleToolTISTOS" ] + + + if (not short): + rs = tuple.addTupleTool("TupleToolRecoStats") + rs.Verbose = ("RecoStats" in verbose) + ei = tuple.addTupleTool("TupleToolEventInfo") + ei.Verbose = ("EventInfo" in verbose) # gives GpsYear, month, day, etc + ki = tuple.addTupleTool("TupleToolKinematic") # gives _AtVtx_P + ki.Verbose= ("Kinematic" in verbose) + if ("CEP" not in options): tuple.addTupleTool("TupleToolPrimaries") + ti = tuple.addTupleTool("TupleToolTrackInfo") + ti.Verbose = ("TrackInfo" in verbose) # gives many more chi2 + if ('e+' in decay or "TrackInfo" in verbose): ti.StoredMeasurements = [ "FirstMeasurement", "AtTT" ] # gives all track parameters + if ( "TrackPosition" in verbose): # extrapolates to TT, IT + tp1 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionTT") + tp2 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionIT") + tp1.ExtraName = "TT" + tp2.ExtraName = "IT" + tp2.Z = 7800 + if (not short): + pid = tuple.addTupleTool("TupleToolPid") + pid.Verbose = ("Pid" in verbose) # many more vars in RICH + tuple.addTupleTool("TupleToolANNPID") + if ('e+' in decay): + brem = tuple.addTupleTool("TupleToolBremInfo") + calo = tuple.addTupleTool("TupleToolL0Calo") + calo.WhichCalo = "ECAL" + # Get the trigger ET information + calo.TriggerClusterLocation = "/Event/Trig/L0/Calo" + if ('mu+' in decay): + calo = tuple.addTupleTool("TupleToolL0Calo") + calo.WhichCalo = "ECAL" + # Get the trigger ET information + calo.TriggerClusterLocation = "/Event/Trig/L0/Calo" + + #isolation + if "iso" in verbose : + # lines from Greg Ciezarek + #from configIso import configIso + #configIso() + # this is work in progress + #will be comitted to SVN properly at a future date as of 3/4/14 + from Configurables import TupleToolApplyIsolation + tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") + tuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" + tuple.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml" + tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"] + tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") + tuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" + tuple.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml" + tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"] + #vtxiso = tuple.B.addTupleTool("TupleToolVtxIsoln") + #tuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 + #tuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 +# tuple.addTupleTool("TupleToolPropertime") + if ( "Stripping" in verbose ): # not reading stripping output + tts = tuple.addTupleTool("TupleToolStripping") + tts.StrippingList = [ + "StrippingBetaSBd2JpsiKsDetachedLineDecision", + "StrippingBetaSBd2JpsiKsPrescaledLineDecision", + "StrippingBetaSBd2JpsiKstarDetachedLineDecision", + "StrippingBetaSBd2JpsiKstarPrescaledLineDecision", + "StrippingBetaSBs2ChicPhi_Chic2KKPiPiNominalLineDecision", + "StrippingBetaSBs2ChicPhi_Chic2PiPiPiPiNominalLineDecision", + "StrippingBetaSBs2EtacPhiNominalLineDecision", + "StrippingBetaSBs2JpsiEtaDetachedLineDecision", + "StrippingBetaSBs2JpsiEtaPrescaledLineDecision", + "StrippingBetaSBs2JpsiKstarLineDecision", + "StrippingBetaSBs2JpsiPhiDetachedLineDecision", + "StrippingBetaSBs2JpsiPhiPrescaledLineDecision", + "StrippingBetaSBs2JpsieePhiDetachedLineDecision", + "StrippingBetaSBs2JpsieePhiLineDecision", + "StrippingBetaSBs2Jpsif0LineDecision", + "StrippingBetaSBs2K0stK0stNominalLineDecision", + "StrippingBetaSBs2KstKstNominalLineDecision", + "StrippingBetaSBs2KstKstSameChargeLineDecision", + "StrippingBetaSBs2PhiKstNominalLineDecision", + "StrippingBetaSBs2PhiPhiLineDecision", + "StrippingBetaSBs2PhiPhiWideLineDecision", + "StrippingBetaSBs2Q2Body4piLineDecision", + "StrippingBetaSBu2JpsiKDetachedLineDecision", + "StrippingBetaSBu2JpsiKNoPIDDetachedLineDecision", + "StrippingBetaSBu2JpsiKPrescaledLineDecision", + "StrippingBetaSJpsi2MuMuDetachedLineDecision", + "StrippingBetaSJpsi2MuMuLineDecision", + "StrippingBetaSLambdab2JpsiLambdaUnbiasedLineDecision", + "StrippingBu2LLK_eeLineDecision", + "StrippingBu2LLK_mmLineDecision", + "StrippingBd2KstarMuMu_BdToKstarMuMuLineDecision", + "StrippingBd2KstarMuMu_BdToKstarMuMuLowPLineDecision", + "StrippingBd2KstarMuMu_BdToKstarMuMuSSLineDecision", + "StrippingBd2KstarMuMu_BdToKstarMuMuSSLowPLineDecision", + "StrippingBd2KstarMuMu_BuToKMuMuLineDecision", + "StrippingBd2KstarMuMu_BuToKMuMuSSLineDecision" ] + + if ( "CEP" in options and not datatype=="MC" ): + tth = tuple.addTupleTool("TupleToolHerschel") + tth.OutputLevel = 6 + if "2015" in options : tth.DigitsLocation="Raw/HC/CorrectedDigits" + ttpd = tuple.addTupleTool("TupleToolProtoPData") + ttpd.DataList = ['CaloNeutralID'] + + if (not short): + tuple.addTupleTool("TupleToolPhotonInfo") + tuple.addTupleTool("TupleToolPi0Info") +# tuple.OutputLevel = 1 + if ( datatype == "MC" ): # it's MC! + tmc = tuple.addTupleTool("TupleToolMCTruth") +# tmc.addTupleTool("MCTupleToolKinematic") + for tool in tmc.ToolList: + if ( "MCTupleToolHierarchy" not in tmc.ToolList ): + tmc.addTupleTool("MCTupleToolHierarchy") + tuple.addTupleTool("TupleToolMCBackgroundInfo") + + if ("ElectronVars" in verbose): + #tev = tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + #tev.Variables = { + tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.ElectronVars.Variables = { + "eta" : "ETA", + "phi" : "PHI", + #"TRACK_PT" : "PPINFO(505,-100,-200)", + #"TRACK_P" : "PPINFO(504,-100,-200)", + #"TRACK_GhostProb" : "TRGHOSTPROB", + #"TRACK_Chi2DOF" : "TRCHI2DOF", + "RichPIDe" : "PPINFO(100,-10000,-20000)", + "inBremAcc" : "PPINFO(304,-1,-2)", + "BremPIDe" : "PPINFO(362,-10000,-20000)", + #"VeloCharge" : "PPINFO(400,-1,-2)", + "CaloTrMatch" : "PPINFO(310,-1,-1000)", + "CaloElectronMatch" : "PPINFO(311,-1,-2)", + "CaloBremMatch" : "PPINFO(312,-1,-2)", + "CaloEoverP" : "PPINFO(338,-1,-2)", + "CaloSpdE" : "PPINFO(330,-1,-2)", + "CaloPrsE" : "PPINFO(331,-1,-2)", + "CaloEcalE" : "PPINFO(332,-1,-1000)", + "CaloHcalE" : "PPINFO(333,-1,-1000)", + "ClusterAsX" : "PPINFO(390,-100000,-200000)", + "ClusterAsY" : "PPINFO(391,-100000,-200000)", + "PrsPIDe" : "PPINFO(361,-1000,-2000)", + "EcalPIDe" : "PPINFO(360,-1000,-2000)", + "HcalPIDe" : "PPINFO(363,-1000,-2000)"} + + if (isMDST): + seq.Members += [ #PrintDecayTree( Inputs = [ location]), + EventNodeKiller(Nodes=["DAQ"] ) ] + + if ( datatype == "MC" ): # it's not MC! + from Configurables import TrackSmearState as SMEAR + smear = SMEAR() +# seq.Members += [ smear ]+ + elif (not isMDST and not isTURBO): # it's not mdst + from Configurables import TrackScaleState as SCALER + scaler = SCALER('StateScale') + seq.Members += [ scaler ] + + if ("NoCheckPV" not in options): + seq.Members += [ CheckPV() ] + if ("CEP" in options): + CheckPV().MinPVs = 0 + CheckPV().MaxPVs = 0 + + seq.Members += [ tuple ] + return [ seq ] diff --git a/CEP_Jpsi2ll/DiLeptonTuple/__init__.py b/CEP_Jpsi2ll/DiLeptonTuple/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/CEP_Jpsi2ll/README.md b/CEP_Jpsi2ll/README.md new file mode 100644 index 0000000000..1e5f42b24c --- /dev/null +++ b/CEP_Jpsi2ll/README.md @@ -0,0 +1,11 @@ +# CEP2016 ntuple options + +Includes the option files for creating ntuples for the CEP `J/\psi \rightarrow ll, \ l=e,\mu` analysis. + +## Datasets +The LOWMULT stream is used to make ntuples for 2016, 2017 and 2018 data. Reconstructed are: + +- Dimuon mass spectrum from 0 to 8 GeV. +- Dielectron mass spectrum from 0.1 to 8 GeV. +- `\chi_{c_{J}} \rightarrow J/\psi(\rightarrow \mu^{+} \mu^{-}) \gamma` (feed-down background) +- `\chi_{c_{J}} \rightarrow J/\psi(\rightarrow e^{+} e^{-}) \gamma` (feed-down background) diff --git a/CEP_Jpsi2ll/__init__.py b/CEP_Jpsi2ll/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/CEP_Jpsi2ll/info.yaml b/CEP_Jpsi2ll/info.yaml new file mode 100644 index 0000000000..aa2a45d4ee --- /dev/null +++ b/CEP_Jpsi2ll/info.yaml @@ -0,0 +1,75 @@ +defaults: + wg: QEE + inform: + - cristina.sanchez.gras@cern.ch + +2016_MagDown_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/LOWMULT.DST" + options: + - DataTypes/2016.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2016.ROOT + + +2016_MagUp_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco16/Stripping28r2/90000000/LOWMULT.DST" + options: + - DataTypes/2016.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2016.ROOT + + +2017_MagDown_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision17/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco17/90600000/FULL.DST" + options: + - DataTypes/2017.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2017.ROOT + + +2017_MagUp_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision17/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco17/90600000/FULL.DST" + options: + - DataTypes/2017.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2017.ROOT + + +2018_MagDown_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision18/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco18/90600000/FULL.DST" + options: + - DataTypes/2018.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2018.ROOT + + +2018_MagUp_CEP_Jpsi2ll: + application: DaVinci/v45r5 + turbo: no + input: + bk_query: "/LHCb/Collision18/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco18/90600000/FULL.DST" + options: + - DataTypes/2018.py + - DataTypes/real_data.py + - DVJpsiCEP_AP.py + output: CEP_JPSI2LL_2018.ROOT -- GitLab From 3fa71e986f7a20e4bc427c0d6066063dc513f8b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Tue, 20 Oct 2020 15:51:00 +0200 Subject: [PATCH 2/7] fix LaTeX --- CEP_Jpsi2ll/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/CEP_Jpsi2ll/README.md b/CEP_Jpsi2ll/README.md index 1e5f42b24c..82e0e35335 100644 --- a/CEP_Jpsi2ll/README.md +++ b/CEP_Jpsi2ll/README.md @@ -1,11 +1,11 @@ -# CEP2016 ntuple options +# CEP $J/\psi \rightarrow \mu\mu,ee$ ntuple options -Includes the option files for creating ntuples for the CEP `J/\psi \rightarrow ll, \ l=e,\mu` analysis. +Includes the option files for creating ntuples for the CEP $J/\psi \rightarrow ll, \ l=e,\mu$ analysis. ## Datasets The LOWMULT stream is used to make ntuples for 2016, 2017 and 2018 data. Reconstructed are: - Dimuon mass spectrum from 0 to 8 GeV. - Dielectron mass spectrum from 0.1 to 8 GeV. -- `\chi_{c_{J}} \rightarrow J/\psi(\rightarrow \mu^{+} \mu^{-}) \gamma` (feed-down background) -- `\chi_{c_{J}} \rightarrow J/\psi(\rightarrow e^{+} e^{-}) \gamma` (feed-down background) +- $`\chi_{c_{J}} \rightarrow J/\psi(\rightarrow \mu^{+} \mu^{-}) \gamma`$ (feed-down background) +- $`\chi_{c_{J}} \rightarrow J/\psi(\rightarrow e^{+} e^{-}) \gamma`$ (feed-down background) -- GitLab From c4f745dfbb1de6479ad8e1de7681777b51f0ae21 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Tue, 20 Oct 2020 15:51:50 +0200 Subject: [PATCH 3/7] fix LaTeX title --- CEP_Jpsi2ll/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CEP_Jpsi2ll/README.md b/CEP_Jpsi2ll/README.md index 82e0e35335..4422337ad6 100644 --- a/CEP_Jpsi2ll/README.md +++ b/CEP_Jpsi2ll/README.md @@ -1,6 +1,6 @@ -# CEP $J/\psi \rightarrow \mu\mu,ee$ ntuple options +# CEP $`J/\psi \rightarrow \mu\mu,ee`$ ntuple options -Includes the option files for creating ntuples for the CEP $J/\psi \rightarrow ll, \ l=e,\mu$ analysis. +Includes the option files for creating ntuples for the CEP $`J/\psi \rightarrow ll, \ l=e,\mu`$ analysis. ## Datasets The LOWMULT stream is used to make ntuples for 2016, 2017 and 2018 data. Reconstructed are: -- GitLab From 80a849649831253296d6bee1cc4ae3a4057af414 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Tue, 20 Oct 2020 15:52:30 +0200 Subject: [PATCH 4/7] change title --- CEP_Jpsi2ll/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CEP_Jpsi2ll/README.md b/CEP_Jpsi2ll/README.md index 4422337ad6..040152ec80 100644 --- a/CEP_Jpsi2ll/README.md +++ b/CEP_Jpsi2ll/README.md @@ -1,4 +1,4 @@ -# CEP $`J/\psi \rightarrow \mu\mu,ee`$ ntuple options +# CEP $`J/\psi \rightarrow ll`$ ntuple options Includes the option files for creating ntuples for the CEP $`J/\psi \rightarrow ll, \ l=e,\mu`$ analysis. -- GitLab From 548ac2e9530c01dd5ccb62af0b315e0de4a93d79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Tue, 1 Dec 2020 20:11:55 +0100 Subject: [PATCH 5/7] add branches for chic CEP analysis --- CEP_Jpsi2ll/DVJpsiCEP_AP.py | 182 ++++++++----------- CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py | 10 +- CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py | 108 +++++++++-- 3 files changed, 178 insertions(+), 122 deletions(-) diff --git a/CEP_Jpsi2ll/DVJpsiCEP_AP.py b/CEP_Jpsi2ll/DVJpsiCEP_AP.py index c961d1be40..ba2260eada 100644 --- a/CEP_Jpsi2ll/DVJpsiCEP_AP.py +++ b/CEP_Jpsi2ll/DVJpsiCEP_AP.py @@ -21,7 +21,7 @@ from Configurables import PrintHeader, PrintDecayTree, StoreExplorerAlg, FilterD from PhysSelPython.Wrappers import Selection, DataOnDemand, SelectionSequence from CommonParticles.Utils import * -from Configurables import DiElectronMaker, ProtoParticleCALOFilter, DaVinciInit, TrackSelector +from Configurables import DiElectronMaker, ProtoParticleCALOFilter, DaVinciInit, TrackSelector, ParticleTransporter, LoKi__VertexFitter from Configurables import LoKi__HDRFilter from GaudiKernel.SystemOfUnits import * from PhysConf.Selections import ( StrippingSelection ) @@ -38,18 +38,28 @@ dieLL.DiElectronMassMax = 8000.*MeV dieLL.DiElectronMassMin = 100.*MeV dieLL.DiElectronPtMin = 0.*MeV -# Use upstream electrons too -""" -dieLL2 = DiElectronMaker('StdDiElectronFromTracks2') -dieLL2.Particle = "J/psi(1S)" -dieLL2.addTool( TrackSelector, name='TrackSelector' ) -dieLL2.TrackSelector.TrackTypes = ["Long","Upstream"] -dieLL2.addTool( ProtoParticleCALOFilter, name='Electron' ) -dieLL2.Electron.Selection = ["CombDLL(e-pi)>'-100'"] -dieLL2.DiElectronMassMax = 8000.*MeV -dieLL2.DiElectronMassMin = 100.*MeV -dieLL2.DiElectronPtMin = 0.*MeV -""" +# Converted-photon candidates using downstream electrons +dieDD_homemade = DiElectronMaker('StdAllLooseGammaDD_homemade') +dieDD_homemade.DecayDescriptor = "gamma -> e+ e-" +selector_DD = trackSelector( dieDD_homemade ,trackTypes = ["Downstream"]) +dieDD_homemade.addTool( ProtoParticleCALOFilter, name = 'Electron' ) +dieDD_homemade.Electron.Selection = ["RequiresDet='CALO' CombDLL(e-pi)>'-2000.0'"] +dieDD_homemade.DeltaY = 3.0 +dieDD_homemade.DeltaYmax = 200 * mm +dieDD_homemade.DiElectronMassMax = 200.0 * MeV +dieDD_homemade.DiElectronPtMin = 0.0 * MeV +dieDD_homemade.ElectronPtMin = 0.0 * MeV +#-- improved vertex fitter settings +dieDD_homemade.UseCombinePair = True +dieDD_homemade.addTool( ParticleTransporter,name = 'TransporterDie' ) +dieDD_homemade.TransporterDie.TrackExtrapolator = "TrackRungeKuttaExtrapolator" +dieDD_homemade.ParticleCombiners.update( {"" : "LoKi::VertexFitter"} ) +dieDD_homemade.addTool( LoKi__VertexFitter ) +dieDD_homemade.LoKi__VertexFitter.addTool( ParticleTransporter,name = 'Transporter' ) +dieDD_homemade.LoKi__VertexFitter.Transporter.TrackExtrapolator = "TrackRungeKuttaExtrapolator" +dieDD_homemade.LoKi__VertexFitter.DeltaDistance = 100 * mm +locations = updateDoD ( dieDD_homemade ) +StdAllLooseGammaDD_homemade=dieDD_homemade # Dimuon candidates _StdLooseDiMuon = DataOnDemand( Location = 'Phys/StdLooseDiMuon/Particles' ) @@ -58,7 +68,7 @@ _MuMu = FilterDesktop( "DiMuons", Code = "(M>0*MeV) & (M<8000*MeV)" ) # Selections SelEE = Selection("SelEE", Algorithm = dieLL ) SelMM = Selection("SelMM", Algorithm = _MuMu, RequiredSelections = [ _StdLooseDiMuon ]) -#SelLUee = Selection("SelLUee", Algorithm = dieLL2 ) +SelGammaEE = Selection("SelGammaEE", Algorithm = dieDD_homemade ) # Build a filter to choose candidates passing stripping/Hlt2 if (year == "2016"): @@ -66,11 +76,8 @@ if (year == "2016"): Code = "HLT_PASS('StrippingLowMultDiElectronLineDecision')", # StrippingLowMultDiElectronLine Location="/Event/Strip/Phys/DecReports") SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[filterEE] ) - # Upstream electrons - #SeqLUee = SelectionSequence("SeqLUee", TopSelection = SelLUee, EventPreSelector=[filterEE] ) # just E dos not work - filterMM = LoKi__HDRFilter( "filterMM", - Code = "HLT_PASS('StrippingLowMultDiMuonLineDecision')", # StrippingLowMultDiElectronLine + Code = "HLT_PASS('StrippingLowMultDiMuonLineDecision') | HLT_PASS('StrippingLowMultMuonLineDecision')", # StrippingLowMultDiMuonLine Location="/Event/Strip/Phys/DecReports") SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[filterMM] ) elif (year == "2017" or year == "2018"): @@ -79,11 +86,8 @@ elif (year == "2017" or year == "2018"): Code = "HLT_PASS('Hlt2LowMultDiElectronDecision')", # Hlt2LowMultDiElectronDecision Location="Hlt2/DecReports") SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[Hlt2FilterEE] ) - # Upstream electrons - #SeqLUee = SelectionSequence("SeqLUee", TopSelection = SelLUee, EventPreSelector=[Hlt2FilterEE] ) # just E dos not work - Hlt2FilterMM = LoKi__HDRFilter( "Hlt2FilterMM", - Code = "HLT_PASS('Hlt2LowMultDiMuonDecision')", # Hlt2LowMultDiMuonDecision + Code = "HLT_PASS('Hlt2LowMultDiMuonDecision') | HLT_PASS('StrippingLowMultMuonLineDecision')", # Hlt2LowMultDiMuonDecision Location="Hlt2/DecReports") SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[Hlt2FilterMM] ) @@ -92,125 +96,99 @@ elif (year == "2017" or year == "2018"): # Fill the chi_c_0,1,2 branches if (fillChic): _Gamma = DataOnDemand( Location = 'Phys/StdVeryLooseAllPhotons/Particles' ) - _Chic0MM = CombineParticles("chic0", + _Chic2JpsiMM = CombineParticles("chicMM", DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, - CombinationCut = "(AM<5500)", - MotherCut = "(M<6000)") - - _Chic1MM = CombineParticles("chic1", - DecayDescriptor = "chi_c1(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, + DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3800)", "gamma" : "ALL" }, CombinationCut = "(AM<5500)", MotherCut = "(M<6000)") - _Chic2MM = CombineParticles("chic2", - DecayDescriptor = "chi_c2(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3400)", "gamma" : "ALL" }, - CombinationCut = "(AM<5500)", - MotherCut = "(M<6000)") - - _Chic0EE = CombineParticles("chic0", + _Chic2JpsiEE = CombineParticles("chicEE", DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, + DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3800)", "gamma" : "ALL" }, CombinationCut = "(AM<5500)", MotherCut = "(M<6000)") - _Chic1EE = CombineParticles("chic1", - DecayDescriptor = "chi_c1(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, - CombinationCut = "(AM<5500)", - MotherCut = "(M<6000)") + _ChicMMGammaEE = CombineParticles("chicMMGammaEE", + DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", +# DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" }, + DaughtersCuts = { "J/psi(1S)" : "ALL", "gamma" : "(PT > 0 * MeV)" }, + CombinationCut = "(AM<4700)", + MotherCut = "(M<4500) & (M - M1 > 0)") - _Chic2EE = CombineParticles("chic2", - DecayDescriptor = "chi_c2(1P) -> J/psi(1S) gamma", - DaughtersCuts = { "J/psi(1S)" : "(M>2000) & (M<3400)", "gamma" : "ALL" }, - CombinationCut = "(AM<5500)", - MotherCut = "(M<6000)") + _ChicEEGammaEE = CombineParticles("chicEEGammaEE", + DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", +# DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" }, + DaughtersCuts = { "J/psi(1S)" : "ALL", "gamma" : "(PT > 0 * MeV)" }, + CombinationCut = "(AM<4700)", + MotherCut = "(M<4500) & (M - M1 > 0)") - SelChic0MM = Selection("SelChic0MM", Algorithm = _Chic0MM, RequiredSelections = [ SelMM, _Gamma ]) - SelChic1MM = Selection("SelChic1MM", Algorithm = _Chic1MM, RequiredSelections = [ SelMM, _Gamma ]) - SelChic2MM = Selection("SelChic2MM", Algorithm = _Chic2MM, RequiredSelections = [ SelMM, _Gamma ]) - SelChic0EE = Selection("SelChic0EE", Algorithm = _Chic0EE, RequiredSelections = [ SelEE, _Gamma ]) - SelChic1EE = Selection("SelChic1EE", Algorithm = _Chic1EE, RequiredSelections = [ SelEE, _Gamma ]) - SelChic2EE = Selection("SelChiC2EE", Algorithm = _Chic2EE, RequiredSelections = [ SelEE, _Gamma ]) + SelChicMM = Selection("SelChicMM", Algorithm = _Chic2JpsiMM, RequiredSelections = [ SelMM, _Gamma ]) + SelChicEE = Selection("SelChicEE", Algorithm = _Chic2JpsiEE, RequiredSelections = [ SelEE, _Gamma ]) + SelChicMMGammaEE = Selection("SelChicMMGammaEE", Algorithm = _ChicMMGammaEE, RequiredSelections = [SelMM, SelGammaEE ]) + SelChicEEGammaEE = Selection("SelChicEEGammaEE", Algorithm = _ChicEEGammaEE, RequiredSelections = [SelEE, SelGammaEE ]) if (year == "2016"): - SeqChic0MM = SelectionSequence("SeqChic0MM", TopSelection = SelChic0MM, EventPreSelector=[filterMM] ) - SeqChic1MM = SelectionSequence("SeqChic1MM", TopSelection = SelChic1MM, EventPreSelector=[filterMM] ) - SeqChic2MM = SelectionSequence("SeqChic2MM", TopSelection = SelChic2MM, EventPreSelector=[filterMM] ) - SeqChic0EE = SelectionSequence("SeqChic0EE", TopSelection = SelChic0EE, EventPreSelector=[filterEE] ) - SeqChic1EE = SelectionSequence("SeqChic1EE", TopSelection = SelChic1EE, EventPreSelector=[filterEE] ) - SeqChic2EE = SelectionSequence("SeqChic2EE", TopSelection = SelChic2EE, EventPreSelector=[filterEE] ) + SeqChicMM = SelectionSequence("SeqChicMM", TopSelection = SelChicMM, EventPreSelector=[filterMM] ) + SeqChicEE = SelectionSequence("SeqChicEE", TopSelection = SelChicEE, EventPreSelector=[filterEE] ) + SeqChicMMGammaEE = SelectionSequence("SeqChicMMGammaEE", TopSelection = SelChicMMGammaEE, EventPreSelector=[filterMM] ) + SeqChicEEGammaEE = SelectionSequence("SeqChicEEGammaEE", TopSelection = SelChicEEGammaEE, EventPreSelector=[filterEE] ) elif (year == "2017" or year == "2018"): - SeqChic0MM = SelectionSequence("SeqChic0MM", TopSelection = SelChic0MM, EventPreSelector=[Hlt2FilterMM] ) - SeqChic1MM = SelectionSequence("SeqChic1MM", TopSelection = SelChic1MM, EventPreSelector=[Hlt2FilterMM] ) - SeqChic2MM = SelectionSequence("SeqChic2MM", TopSelection = SelChic2MM, EventPreSelector=[Hlt2FilterMM] ) - SeqChic0EE = SelectionSequence("SeqChic0EE", TopSelection = SelChic0EE, EventPreSelector=[Hlt2FilterEE] ) - SeqChic1EE = SelectionSequence("SeqChic1EE", TopSelection = SelChic1EE, EventPreSelector=[Hlt2FilterEE] ) - SeqChic2EE = SelectionSequence("SeqChic2EE", TopSelection = SelChic2EE, EventPreSelector=[Hlt2FilterEE] ) + SeqChicMM = SelectionSequence("SeqChicMM", TopSelection = SelChicMM, EventPreSelector=[Hlt2FilterMM] ) + SeqChicEE = SelectionSequence("SeqChicEE", TopSelection = SelChicEE, EventPreSelector=[Hlt2FilterEE] ) + SeqChicMMGammaEE = SelectionSequence("SeqChicMMGammaEE", TopSelection = SelChicMMGammaEE, EventPreSelector=[Hlt2FilterMM] ) + SeqChicEEGammaEE = SelectionSequence("SeqChicEEGammaEE", TopSelection = SelChicEEGammaEE, EventPreSelector=[Hlt2FilterEE] ) ######################################################################################## # Needed for Herschel from Configurables import HCRawBankDecoder decoder = HCRawBankDecoder() +CondDB().LocalTags["DQFLAGS"] = ["herschel-20161018"] # DQ masking runs where Herschel was absent # Fill ntuple DaVinci().appendToMainSequence( [ decoder ] ) DaVinci().appendToMainSequence( [SeqEE.sequence() ]) -#DaVinci().appendToMainSequence( [SeqLUee.sequence() ]) # Upstream electrons -#DaVinci().appendToMainSequence( [ PrintDecayTree(Inputs=['Phys/SelLUee/Particles']) ]) DaVinci().appendToMainSequence( [SeqMM.sequence() ]) if (fillChic): - DaVinci().appendToMainSequence( [SeqChic0MM.sequence() ]) - #DaVinci().appendToMainSequence( [SeqChic1MM.sequence() ]) - #DaVinci().appendToMainSequence( [SeqChic2MM.sequence() ]) - DaVinci().appendToMainSequence( [SeqChic0EE.sequence() ]) - #DaVinci().appendToMainSequence( [SeqChic1EE.sequence() ]) - #DaVinci().appendToMainSequence( [SeqChic2EE.sequence() ]) + DaVinci().appendToMainSequence( [SeqChicMM.sequence() ]) + DaVinci().appendToMainSequence( [SeqChicEE.sequence() ]) + DaVinci().appendToMainSequence( [dieDD_homemade] ) + DaVinci().appendToMainSequence( [SeqChicMMGammaEE.sequence() ]) + DaVinci().appendToMainSequence( [SeqChicEEGammaEE.sequence() ]) -#from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Psi2S2Jpsipipi, Chic02JpsiMuMuGamma, Chic12JpsiMuMuGamma, Chic22JpsiMuMuGamma, Chic02JpsiEEGamma, Chic12JpsiEEGamma, Chic22JpsiEEGamma -#from CEP_Jpsi2ll import DiLeptonTuple -import CEP_Jpsi2ll +#import CEP_Jpsi2ll from CEP_Jpsi2ll.DiLeptonTuple import DiLeptonTuple as DLT -DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) -#DaVinci().appendToMainSequence( DLT.addTuple(name="SelLUee", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelLUee/Particles'], options = ["CEP"] ) ) # Upstream electrons -DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) -if (fillChic): - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic0MM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic0MM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic0EE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChic0EE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) -# DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic1MM", decay=DLT.Chic12JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic1MM/Particles'], options = ["CEP"]) ) -# DaVinci().appendToMainSequence( DLT.addTuple(name="SelChic2MM", decay=DLT.Chic22JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic2MM/Particles'], options = ["CEP"]) ) +#from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Chic02JpsiMuMuGamma, Chic02JpsiEEGamma, Chic02JpsiMuMuGammaEE, Chic02JpsiEEGammaEE """ -DaVinci().appendToMainSequence( [SeqEE.sequence() ]) # -#DaVinci().appendToMainSequence( [SeqLUee.sequence() ]) # Upstream electrons -DaVinci().appendToMainSequence( [SeqMM.sequence() ]) # -if (fillChic): - DaVinci().appendToMainSequence( [SeqChic0.sequence() ]) - DaVinci().appendToMainSequence( [SeqChic1.sequence() ]) - DaVinci().appendToMainSequence( [SeqChic2.sequence() ]) -#DaVinci().appendToMainSequence( [ PrintDecayTree(Inputs=['Phys/SelLUee/Particles']) ]) # -from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Psi2S2Jpsipipi, Chic12JpsiMuMuGamma -DaVinci().appendToMainSequence( addTuple(name="SelEE", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], options = ["CEP"] ) ) -#DaVinci().appendToMainSequence( addTuple(name="SelLUee", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelLUee/Particles'], options = ["CEP"] ) ) -DaVinci().appendToMainSequence( addTuple(name="SelMM", decay=Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], options = ["CEP"]) ) +DaVinci().appendToMainSequence( addTuple(name="SelEE", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) +DaVinci().appendToMainSequence( addTuple(name="SelMM", decay=Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) + if (fillChic): - DaVinci().appendToMainSequence( addTuple(name="SelChic0", decay=Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic0/Particles'], options = ["CEP"]) ) - DaVinci().appendToMainSequence( addTuple(name="SelChic1", decay=Chic12JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic1/Particles'], options = ["CEP"]) ) - DaVinci().appendToMainSequence( addTuple(name="SelChic2", decay=Chic22JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChic2/Particles'], options = ["CEP"]) ) + DaVinci().appendToMainSequence( addTuple(name="ChicMM", decay=Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( addTuple(name="ChicEE", decay=Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( addTuple(name="ChicMMGammaEE", decay=Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( addTuple(name="ChicEEGammaEE", decay=Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) """ +DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) +DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) + +if (fillChic): + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMMGammaEE", decay=DLT.Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEEGammaEE", decay=DLT.Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + + nev = -1 DaVinci().EvtMax = nev DaVinci().PrintFreq = 10000 -#DaVinci().DataType = year DaVinci().Lumi = True DaVinci().TupleFile = "CEP.root" if ( nev>0 and nev<100): DaVinciInit("DaVinciInitAlg").PrintEvent = True from GaudiConf import IOHelper -#IOHelper().inputFiles([ '/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103400_00053594_1.lowmult.dst','/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103804_00002271_1.lowmult.dst','/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103804_00004991_1.lowmult.dst' ], clear=True) +#IOHelper().inputFiles([ '/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103400_00053594_1.lowmult.dst'], clear=True) if (allInfoTISTOS): diff --git a/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py index 17f5eb74f7..cb35de3bf6 100644 --- a/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py +++ b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py @@ -1232,13 +1232,17 @@ def cepLines(run): a = allLines(run) l = L0LowMultLines() l.append('Hlt1LowMultDecision') + l.append('Hlt2LowMultChiC2HHDecision') + l.append('Hlt2LowMultLMRDecision') + l.append('Hlt2LowMultLMR2HHDecision') for i in a: # Cristina: add all LowMult lines - if 'CalibHighPT' in i: l.append(i) if 'Hlt1CEP' in i: l.append(i) if 'Hlt1LowMult' in i: l.append(i) - if 'Hlt1DiProtonLowMult' in i: l.append(i) - if 'Hlt2DiProtonLowMult' in i: l.append(i) + if 'Hlt1MBNoBias' in i: l.append(i) + if 'Hlt1NoPV' in i: l.append(i) + if 'Hlt1TrackAllL0' in i: l.append(i) + if 'Hlt1TrackMuon' in i: l.append(i) if 'Hlt2LowMultDi' in i: l.append(i) if 'Hlt2LowMultHadron' in i: l.append(i) if 'Hlt2LowMultMuon' in i: l.append(i) diff --git a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py index 7ef2f7340a..4a63965d9c 100644 --- a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py +++ b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py @@ -28,6 +28,8 @@ Chic12JpsiMuMuGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma" Chic12JpsiEEGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma" Chic22JpsiMuMuGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma" Chic22JpsiEEGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma" +Chic02JpsiMuMuGammaEE = "chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(gamma -> ^e+ ^e-)" +Chic02JpsiEEGammaEE = "chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^(gamma -> ^e+ ^e-)" Jpsi2ee = "J/psi(1S) -> ^e+ ^e-" Jpsi2MuMuSS = "[J/psi(1S) -> ^mu+ ^mu+]CC" Bu2MuMuK = "[B+ -> ^(J/psi(1S) -> ^mu- ^mu+) ^K+ ]CC" @@ -39,7 +41,6 @@ Bu2JpsiK = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" Bs2JpsiPhi = "B_s0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(phi(1020) -> ^K+ ^K-)" Bd2JpsiPi0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0" Bd2JpsiKstar = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC" - Bd2eeKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" Bd2MuMuKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" Bd2MuMuKstSS = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu+) ^(K*(892)0 -> ^K+ ^pi-) ]CC" @@ -120,8 +121,24 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ Psi = tuple.addTupleTool("TupleToolDecay/Psi") if ( Jpsi2ee != decay and Jpsi2MuMu != decay): bpsi = (decay.replace("^","")).replace("(J/psi(1S)","^(J/psi(1S)") else : bpsi = "^("+decay.replace("^","")+")" - print "J/psi branch is `` ", bpsi, "''" - tuple.Branches["Psi"] = bpsi + print "J/psi branch is `` ", bpsi, "''" + if ( Jpsi2ee in decay ): + eplus = tuple.addTupleTool("TupleToolDecay", name = "eplus") + eminus = tuple.addTupleTool("TupleToolDecay", name = "eminus") + tuple.Branches = { + "Psi" : bpsi, + "eplus": "J/psi(1S) -> ^e+ e-", + "eminus" : "J/psi(1S) -> e+ ^e-"} + elif ( Jpsi2MuMu in decay): + muplus = tuple.addTupleTool("TupleToolDecay", name = "muplus") + muminus = tuple.addTupleTool("TupleToolDecay", name = "muminus") + tuple.Branches = { + "Psi" : bpsi, + "muplus": "J/psi(1S) -> ^mu+ mu-", + "muminus" : "J/psi(1S) -> mu+ ^mu-"} + else: + tuple.Branches["Psi"] = bpsi + # sort out kstars if "892" in decay: @@ -159,9 +176,12 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ psifit.constrainToOriginVertex = False psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi - elif ( Chic12JpsiMuMuGamma == decay or Chic02JpsiMuMuGamma == decay or Chic22JpsiMuMuGamma == decay or Chic12JpsiEEGamma == decay or Chic02JpsiEEGamma == decay or Chic22JpsiEEGamma == decay or "chi" in decay): # chic + elif ( Chic12JpsiMuMuGamma == decay or Chic02JpsiMuMuGamma == decay or Chic22JpsiMuMuGamma == decay or Chic12JpsiEEGamma == decay or Chic02JpsiEEGamma == decay or Chic22JpsiEEGamma == decay ): # chic chic = tuple.addTupleTool("TupleToolDecay/Chic") - tuple.Branches["Chic"] = "^("+decay.replace("^","")+")" + gamma = tuple.addTupleTool("TupleToolDecay/gamma") + tuple.Branches = { + "Chic" : "^("+decay.replace("^","")+")", + "gamma" : decay.replace("^","").replace("gamma","^gamma")} chic.addTool(tistos) chic.ToolList += [ "TupleToolTISTOS" ] if (dtf): @@ -170,6 +190,21 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ psifit.constrainToOriginVertex = False psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi + elif ( Chic02JpsiMuMuGammaEE == decay or Chic02JpsiEEGammaEE == decay ): # chic + chic = tuple.addTupleTool("TupleToolDecay/Chic") + gamma = tuple.addTupleTool("TupleToolDecay/gamma") + tuple.Branches = { + "Chic" : "^("+decay.replace("^","")+")", + "gamma" : decay.replace("^","").replace("(gamma -> e+ e-)","^(gamma -> e+ e-)")} + chic.addTool(tistos) + chic.ToolList += [ "TupleToolTISTOS" ] + if (dtf): + psifit = chic.addTupleTool("TupleToolDecayTreeFitter/JpsiFit") + psifit.Verbose = True + psifit.constrainToOriginVertex = False + psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi + + else: # it's a b-hadron. Dtf will be done B = tuple.addTupleTool("TupleToolDecay/B") bh = "UNDEFINED" @@ -333,6 +368,16 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ ei.Verbose = ("EventInfo" in verbose) # gives GpsYear, month, day, etc ki = tuple.addTupleTool("TupleToolKinematic") # gives _AtVtx_P ki.Verbose= ("Kinematic" in verbose) + + bspot = tuple.addTupleTool("TupleToolBeamSpot") + bspot.Verbose = ("BeamSpot" in verbose) + + fillsc = tuple.addTupleTool("TupleToolFillingScheme") + + allphot = tuple.addTupleTool("TupleToolAllPhotons") + + partstat = tuple.addTupleTool("TupleToolParticleStats") + if ("CEP" not in options): tuple.addTupleTool("TupleToolPrimaries") ti = tuple.addTupleTool("TupleToolTrackInfo") ti.Verbose = ("TrackInfo" in verbose) # gives many more chi2 @@ -349,11 +394,7 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ tuple.addTupleTool("TupleToolANNPID") if ('e+' in decay): brem = tuple.addTupleTool("TupleToolBremInfo") - calo = tuple.addTupleTool("TupleToolL0Calo") - calo.WhichCalo = "ECAL" - # Get the trigger ET information - calo.TriggerClusterLocation = "/Event/Trig/L0/Calo" - if ('mu+' in decay): + if ('e+' or 'mu+' in decay): calo = tuple.addTupleTool("TupleToolL0Calo") calo.WhichCalo = "ECAL" # Get the trigger ET information @@ -418,13 +459,22 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ "StrippingBd2KstarMuMu_BdToKstarMuMuSSLowPLineDecision", "StrippingBd2KstarMuMu_BuToKMuMuLineDecision", "StrippingBd2KstarMuMu_BuToKMuMuSSLineDecision" ] - + if ( "CEP" in options ): + tts = tuple.addTupleTool("TupleToolStripping") + tts.Verbose = True + tts.StrippingList = [ + "StrippingLowMultDiMuonLineDecision", + "StrippingLowMultDiPhotonLineDecision", + "StrippingLowMultLMR2HHHHLineDecision", + "StrippingLowMultLMR2HHLineDecision", + "StrippingLowMultMuonLineDecision", + "StrippingLowMultPi0LineDecision", + "StrippingLowMultTMPLineDecision", + "StrippingLowMultDiElectronLineDecision" ] if ( "CEP" in options and not datatype=="MC" ): tth = tuple.addTupleTool("TupleToolHerschel") tth.OutputLevel = 6 if "2015" in options : tth.DigitsLocation="Raw/HC/CorrectedDigits" - ttpd = tuple.addTupleTool("TupleToolProtoPData") - ttpd.DataList = ['CaloNeutralID'] if (not short): tuple.addTupleTool("TupleToolPhotonInfo") @@ -441,8 +491,7 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ if ("ElectronVars" in verbose): #tev = tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") #tev.Variables = { - tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") - tuple.ElectronVars.Variables = { + dictElectronVars = { "eta" : "ETA", "phi" : "PHI", #"TRACK_PT" : "PPINFO(505,-100,-200)", @@ -450,22 +499,47 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ #"TRACK_GhostProb" : "TRGHOSTPROB", #"TRACK_Chi2DOF" : "TRCHI2DOF", "RichPIDe" : "PPINFO(100,-10000,-20000)", - "inBremAcc" : "PPINFO(304,-1,-2)", + "InAccBrem" : "PPINFO(304,-1,-2)", "BremPIDe" : "PPINFO(362,-10000,-20000)", #"VeloCharge" : "PPINFO(400,-1,-2)", "CaloTrMatch" : "PPINFO(310,-1,-1000)", "CaloElectronMatch" : "PPINFO(311,-1,-2)", "CaloBremMatch" : "PPINFO(312,-1,-2)", + "CaloBremChi2" : "PPINFO(335,-1,-1000)", "CaloEoverP" : "PPINFO(338,-1,-2)", "CaloSpdE" : "PPINFO(330,-1,-2)", "CaloPrsE" : "PPINFO(331,-1,-2)", "CaloEcalE" : "PPINFO(332,-1,-1000)", "CaloHcalE" : "PPINFO(333,-1,-1000)", + "CaloNeutralID" : "PPINFO(328,-1,-1000)", "ClusterAsX" : "PPINFO(390,-100000,-200000)", "ClusterAsY" : "PPINFO(391,-100000,-200000)", "PrsPIDe" : "PPINFO(361,-1000,-2000)", "EcalPIDe" : "PPINFO(360,-1000,-2000)", - "HcalPIDe" : "PPINFO(363,-1000,-2000)"} + "HcalPIDe" : "PPINFO(363,-1000,-2000)", + "IsPhoton" : "PPINFO(381,-1,-1000)", + "IsNotE" : "PPINFO(382,-1,-1000)", + "IsNotH" : "PPINFO(383,-1,-1000)", + "InAccBrem" : "PPINFO(304,-1,-1000)", + "PhotonID" : "PPINFO(380,-1,-1000)"} + + if ( Jpsi2ee in decay ): + tuple.eplus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.eplus.ElectronVars.Variables = dictElectronVars + tuple.eminus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.eminus.ElectronVars.Variables = dictElectronVars + elif ( Jpsi2MuMu in decay): + tuple.muplus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.muplus.ElectronVars.Variables = dictElectronVars + tuple.muminus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.muminus.ElectronVars.Variables = dictElectronVars + elif ( "gamma" in decay): + tuple.gamma.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.gamma.ElectronVars.Variables = dictElectronVars + else: + tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars") + tuple.ElectronVars.Variables = dictElectronVars + if (isMDST): seq.Members += [ #PrintDecayTree( Inputs = [ location]), -- GitLab From bc4136070b8f20f8814cf248d0f9cbe028ebfd92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Fri, 4 Dec 2020 10:20:04 +0100 Subject: [PATCH 6/7] add J/psi mass cuts back in --- CEP_Jpsi2ll/DVJpsiCEP_AP.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CEP_Jpsi2ll/DVJpsiCEP_AP.py b/CEP_Jpsi2ll/DVJpsiCEP_AP.py index ba2260eada..9cdd0bbd9c 100644 --- a/CEP_Jpsi2ll/DVJpsiCEP_AP.py +++ b/CEP_Jpsi2ll/DVJpsiCEP_AP.py @@ -111,14 +111,14 @@ if (fillChic): _ChicMMGammaEE = CombineParticles("chicMMGammaEE", DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", # DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" }, - DaughtersCuts = { "J/psi(1S)" : "ALL", "gamma" : "(PT > 0 * MeV)" }, + DaughtersCuts = { "J/psi(1S)" : "(M > 2800 * MeV) & (M < 3800 * MeV)", "gamma" : "(PT > 0 * MeV)" }, CombinationCut = "(AM<4700)", MotherCut = "(M<4500) & (M - M1 > 0)") _ChicEEGammaEE = CombineParticles("chicEEGammaEE", DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma", # DaughtersCuts = { "J/psi(1S)" : "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" }, - DaughtersCuts = { "J/psi(1S)" : "ALL", "gamma" : "(PT > 0 * MeV)" }, + DaughtersCuts = { "J/psi(1S)" : "(M > 2800 * MeV) & (M < 3800 * MeV)", "gamma" : "(PT > 0 * MeV)" }, CombinationCut = "(AM<4700)", MotherCut = "(M<4500) & (M - M1 > 0)") -- GitLab From 96396766d0c51f7eb09718abcf6ea767b682b92e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristina=20S=C3=A1nchez=20Gras?= <cristina.sanchez.gras@cern.ch> Date: Thu, 17 Dec 2020 18:31:49 +0100 Subject: [PATCH 7/7] add NoCheckPV fix --- CEP_Jpsi2ll/DVJpsiCEP_AP.py | 24 +++++-------------- CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py | 27 +++++++++++++++------- 2 files changed, 25 insertions(+), 26 deletions(-) diff --git a/CEP_Jpsi2ll/DVJpsiCEP_AP.py b/CEP_Jpsi2ll/DVJpsiCEP_AP.py index 9cdd0bbd9c..5da5587e85 100644 --- a/CEP_Jpsi2ll/DVJpsiCEP_AP.py +++ b/CEP_Jpsi2ll/DVJpsiCEP_AP.py @@ -159,25 +159,14 @@ if (fillChic): #import CEP_Jpsi2ll from CEP_Jpsi2ll.DiLeptonTuple import DiLeptonTuple as DLT -#from DiLeptonTuple.DiLeptonTuple import addTuple, Jpsi2MuMu, Jpsi2ee, Chic02JpsiMuMuGamma, Chic02JpsiEEGamma, Chic02JpsiMuMuGammaEE, Chic02JpsiEEGammaEE -""" -DaVinci().appendToMainSequence( addTuple(name="SelEE", decay=Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) -DaVinci().appendToMainSequence( addTuple(name="SelMM", decay=Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) +DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","NoCheckPV"] ) ) +DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","NoCheckPV"]) ) if (fillChic): - DaVinci().appendToMainSequence( addTuple(name="ChicMM", decay=Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( addTuple(name="ChicEE", decay=Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( addTuple(name="ChicMMGammaEE", decay=Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( addTuple(name="ChicEEGammaEE", decay=Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) -""" -DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"] ) ) -DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP"]) ) - -if (fillChic): - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMMGammaEE", decay=DLT.Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) - DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEEGammaEE", decay=DLT.Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMMGammaEE", decay=DLT.Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"]) ) + DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEEGammaEE", decay=DLT.Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"]) ) nev = -1 @@ -188,7 +177,6 @@ DaVinci().TupleFile = "CEP.root" if ( nev>0 and nev<100): DaVinciInit("DaVinciInitAlg").PrintEvent = True from GaudiConf import IOHelper -#IOHelper().inputFiles([ '/eos/lhcb/user/c/crsanche/CEP2016/MagDown_fromRun178960_Lumi/00103400_00053594_1.lowmult.dst'], clear=True) if (allInfoTISTOS): diff --git a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py index 4a63965d9c..3687a427b2 100644 --- a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py +++ b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py @@ -41,6 +41,7 @@ Bu2JpsiK = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" Bs2JpsiPhi = "B_s0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(phi(1020) -> ^K+ ^K-)" Bd2JpsiPi0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0" Bd2JpsiKstar = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC" + Bd2eeKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" Bd2MuMuKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC" Bd2MuMuKstSS = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu+) ^(K*(892)0 -> ^K+ ^pi-) ]CC" @@ -95,9 +96,12 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ tuple.Decay = decay + multiPV = False if (not short): tg = tuple.addTupleTool("TupleToolGeometry") - if not isMDST and not isTURBO: tg.FillMultiPV = True + if not isMDST and not isTURBO and not "CEP" in options and "NoCheckPV" not in options : + multiPV = True + tg.FillMultiPV = True tlist = [] if ( "AllLines" in options): @@ -115,13 +119,13 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ tlist.append(topoMuLines(run)) if ( False ): tlist = allLines(run) - print tlist + print(tlist) # psi branch Psi = tuple.addTupleTool("TupleToolDecay/Psi") if ( Jpsi2ee != decay and Jpsi2MuMu != decay): bpsi = (decay.replace("^","")).replace("(J/psi(1S)","^(J/psi(1S)") else : bpsi = "^("+decay.replace("^","")+")" - print "J/psi branch is `` ", bpsi, "''" + print("J/psi branch is ``{0}''".format(bpsi)) if ( Jpsi2ee in decay ): eplus = tuple.addTupleTool("TupleToolDecay", name = "eplus") eminus = tuple.addTupleTool("TupleToolDecay", name = "eminus") @@ -139,7 +143,6 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ else: tuple.Branches["Psi"] = bpsi - # sort out kstars if "892" in decay: bkstar = (decay.replace("^","")).replace("(K*(892)","^(K*(892)") @@ -215,7 +218,7 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ elif ('B+' in decay ): bh = 'B+' elif ('B_s0' in decay ): bh = 'B_s0' if ('CC' in decay): bh = '['+bh+']cc' - print "Branch will be ``", bh+" : "+decay.replace("^",""), "''" + print("Branch will be ``{0} : {1}''".format(bh,decay.replace("^",""))) tuple.Branches["B"] = "^("+decay.replace("^","")+")" @@ -554,11 +557,19 @@ def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=[ scaler = SCALER('StateScale') seq.Members += [ scaler ] - if ("NoCheckPV" not in options): - seq.Members += [ CheckPV() ] + if (("NoCheckPV" not in options) and ("CEP" not in options)): + # add checkPV but only if not CEP and not disabled + seq.Members += [ CheckPV("CheckPV_"+name) ] + elif multiPV: + import sys + print("You cannot run MultiPV and not CheckPV") + sys.exit() + + """ if ("CEP" in options): CheckPV().MinPVs = 0 CheckPV().MaxPVs = 0 - + """ + seq.Members += [ tuple ] return [ seq ] -- GitLab