def tuple_spec_data(name, sel_seq, template,
B_meson='b', weights='./weights_soft.xml',
tools=[
"TupleToolKinematic",
"TupleToolPrimaries",
"TupleToolEventInfo",
"TupleToolTrackInfo",
"TupleToolRecoStats"
],
trigger_list=[
# L0
'L0HadronDecision',
'L0MuonDecision',
'L0DiMuonDecision',
'L0ElectronDecision',
# HLT 1
'Hlt1TrackMVADecision',
'Hlt1TwoTrackMVADecision',
'Hlt1TrackMuonDecision',
# HLT 2
'Hlt2DiMuonDetachedHeavyDecision',
]
):
tp = DecayTreeTuple(name)
tp.NTupleDir = '' # From Greg, might be interesting
tp.TupleName = name
tp_input = sel_seq if isinstance(sel_seq, str) else sel_seq.outputLocation()
tp.Inputs = [tp_input]
tp.setDescriptorTemplate(template)
tp.ToolList += tools
tt_pid = really_add_tool(tp, 'TupleToolPid')
tt_pid.Verbose = True
tt_geo = really_add_tool(tp, 'TupleToolGeometry')
tt_geo.Verbose = True
tt_tistos = really_add_tool(tp, 'TupleToolTISTOS')
tt_tistos.Verbose = True
tt_tistos.TriggerList = trigger_list
tt_l0_calo = really_add_tool(tp, 'TupleToolL0Calo')
tt_l0_calo.WhichCalo = "HCAL"
tt_l0_calo.TriggerClusterLocation = "/Event/Trig/L0/Calo"
tt_app_iso = getattr(tp, B_meson).addTupleTool('TupleToolApplyIsolation')
tt_app_iso.WeightsFile = weights
return tp
def MakeDecayTreeTulple(name, location, decay_channel, TupleToolList):
# create the tuple
dtt = DecayTreeTuple(name)
dtt.Inputs = [location]
dtt.Decay = decay_channel
# AddToople tool
if TupleToolList is not None and len(TupleToolList) > 0:
for TupleTool in TupleToolList:
ok_module = TestModule(TupleTool)
if ok_module:
dtt.addTupleTool(TupleTool)
else:
print "Cannot add TupleTool {}, did you import it ?".format(
TupleTool)
return dtt
KsPiPi.CombinationCut = "ADAMASS('KS0')<100*MeV"
KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
KsPiPi.DaughtersCuts = { "pi+" : "ALL",
"pi-" : "ALL" }
KsPiPi.MotherCut = "(M > 400) & (M < 600) & (BPVVDCHI2 > 100.) & (VFASPF(VCHI2/VDOF) < 10)"
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdNoPIDsDownPions, StdLoosePions
LooseKsPiPi = Selection("SelLooseKsPiPi",
Algorithm = KsPiPi,
RequiredSelections = [StdNoPIDsDownPions ])
#RequiredSelections = [StdLoosePions])
from PhysSelPython.Wrappers import SelectionSequence
SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi)
KsPiPiTuple = DecayTreeTuple("KsPiPiTuple")
# input locations
KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ]
# decay descriptors
KsPiPiTuple.Decay = "KS0 -> ^pi+ ^pi-"
# define the tools and configure them
KsPiPiTuple.ToolList = [
"TupleToolKinematic"
,"TupleToolGeometry"
,"TupleToolPid"
,"TupleToolANNPID"
#,"TupleToolTrackInfo"
,"TupleToolRecoStats"
,"TupleToolTrigger"
,"TupleToolPrimaries"
sc = StrippingConf(HDRLocation="DecReports")
sstream = StrippingStream("TestStream")
sstream.appendLines(B2XMuMuLines)
sstream.OutputLevel = 2
sc.appendStream(sstream)
#---------------------------
# Run fixing XmumuLine
#---------------------------
from Configurables import PromptNeutrinoTupleTool
stripping_line = 'B2XMuMu_Line'
stream = 'AllStreams'
tuple = DecayTreeTuple('PromptNeutrinoTupleTool')
tuple.OutputLevel = INFO
tuple.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, stripping_line)]
tuple.Decay = "[B+ -> ^( J/psi(1S) -> ^mu- ^mu+ ) ^pi+]CC"
tuple.Branches = {
"B": "[B+ -> ( J/psi(1S) -> mu- mu+ ) pi+ ]CC",
"Jpsi": "[B+ -> ^(J/psi(1S) -> mu- mu+) pi+]CC",
"mu_prim": "[B+ -> (J/psi(1S) -> mu- ^mu+) pi+]CC",
"mu_sec": "[B+ -> (J/psi(1S) -> ^mu- mu+) pi+]CC",
"pi": "[B+ -> (J/psi(1S) -> mu- mu+) ^pi+]CC",
}
tuple.ToolList = [
"TupleToolKinematic",
"TupleToolPid",
'Charm -> (D~0 -> K+ ^K-) Meson': 'pi-'
}
)
# create a selection using the substitution algorithm
selSub = Selection(
'Dst2D0pi_D02pipi_Sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
# in order to add the selection into the program make a sequence
selSeq = SelectionSequence('SelSeq', TopSelection=selSub)
# Create an ntuple to capture D*+ decays from the new selection
dtt = DecayTreeTuple('TupleDstToD0pi_D0Topipi')
dtt.Inputs = [selSeq.outputLocation()]
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^pi- ^pi+) ^pi+]CC'
# Configure DaVinci
# add our new selection and the tuple into the sequencer
seq = GaudiSequencer('MyTupleSeq')
seq.Members += [selSeq.sequence()]
seq.Members += [dtt]
DaVinci().appendToMainSequence([seq])
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
DaVinci().PrintFreq = 1000
DaVinci().DataType = '2016'
from Gaudi.Configuration import *
from Configurables import (DaVinci, GaudiSequencer)
from DecayTreeTuple.Configuration import *
#from Configurables import ( ANNGlobalPID__ChargedProtoANNPIDTrainingTuple )
#pidtuple = ANNGlobalPID__ChargedProtoANNPIDTrainingTuple("ANNPID")
#pidtuple.NTupleLUN = "ANNPIDTUPLE"
#DaVinci().UserAlgorithms += [ pidtuple ]
from Configurables import (DecayTreeTuple, LoKi__Hybrid__TupleTool)
tuple = DecayTreeTuple("ANNPID")
tuple.Decay = "[pi+]cc"
tuple.NTupleLUN = "ANNPIDTUPLE"
tuple.Inputs = [
'Phys/StdAllNoPIDsPions/Particles', 'Phys/StdNoPIDsUpPions/Particles',
'Phys/StdNoPIDsDownPions/Particles'
]
tuple.ToolList = ["TupleToolANNPIDTraining", "TupleToolGeometry"]
#lokiT = tuple.addTupleTool( LoKi__Hybrid__TupleTool, name = "LokiTool" )
#lokiT.Variables = { "MIPCHI2_PRIMARY" : "MIPCHI2DV(PRIMARY)" }
DaVinci().UserAlgorithms += [tuple]
DaVinci().EvtMax = -1
DaVinci().PrintFreq = 1000
#DaVinci().SkipEvents = 100000
DaVinci().InputType = 'DST'
DaVinci().Simulation = True
DaVinci().DataType = "2011"
##############################################################################################
##### TOOLS AND TRIGGERS AND STRIPPING LINES AND LOKI VARIABLES
##############################################################################################
enablePacking = True
from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass
from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter, TupleToolL0Calo
from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid
from Configurables import TupleToolANNPID
from Configurables import TupleToolSLTruth
from Configurables import TupleToolMCTruth
from Configurables import TupleToolPropertime
from Configurables import TupleToolTauMuDiscrVarsLcMassConstraint
from DecayTreeTuple.Configuration import *
tupleB = DecayTreeTuple("tupleout")
tupleB.Inputs = ["Phys/b2LcMuXB2DMuForTauMuLine/Particles"]
tupleB.Decay = "[B- -> ^(Lambda_c+ -> ^p+ ^K- ^pi+) ^mu-]CC"
tupleB.ToolList += [
"TupleToolKinematic",
"TupleToolEventInfo",
"TupleToolRecoStats",
"TupleToolGeometry",
"TupleToolMCBackgroundInfo" #comment out for data
,
"TupleToolMCTruth" #comment out for data
,
"TupleToolSLTruth",
"TupleToolL0Calo" #for Calorimeter info
] # Probably need to add many more Tools.
SelSeqJPsi = SelectionSequence("SeqJPsi", TopSelection=jPsiNBSel)
SelSeqMuMu = SelectionSequence("SeqMuMu", TopSelection=mumuNBSel)
SelSeqMuMuAll = SelectionSequence("SeqMuMuAll", TopSelection=mumuSel)
SeqJPsi = SelSeqJPsi.sequence()
SeqMuMu = SelSeqMuMu.sequence()
SeqMuMuAll = SelSeqMuMuAll.sequence()
########################################################################
#
# NTupling
#
from Configurables import DecayTreeTuple
tupleMuMu = DecayTreeTuple("tupleMuMu")
tupleMuMu.InputLocations = [SelSeqMuMu.outputLocation()]
tupleMuMu.Decay = "J/psi(1S) -> ^mu+ ^mu-"
tupleMuMu.ToolList += [
"TupleToolGeometry", "TupleToolKinematic", "TupleToolPrimaries",
"TupleToolTrackInfo", "TupleToolPid", "TupleToolEventInfo",
"TupleToolPropertime", "LoKi::Hybrid::TupleTool/LoKiTupleMuMu"
]
from Configurables import LoKi__Hybrid__TupleTool
LoKiTupleMuMu = LoKi__Hybrid__TupleTool("LoKiTupleMuMu")
LoKiTupleMuMu.Variables = {
"Charge": "Q",
"DOCA": "DOCA(1,2)",
"DOCAMAX": "DOCAMAX",
"NetOut": "INFO(LHCb.Particle.LastGlobal+1, -999)",
from PhysSelPython.Wrappers import SelectionSequence
noPIDsKaons = DataOnDemand(Location = 'Phys/StdNoPIDsKaons')
BhhSel = Selection("BhhSel" , Algorithm = Bhh , RequiredSelections = [noPIDsKaons])
BhhNBSel = Selection("BhhNBSel" , Algorithm = BhhNB , RequiredSelections = [ BhhSel ] )
SelSeqBhh = SelectionSequence("SeqBhh" , TopSelection = BhhNBSel)
SeqBhh = SelSeqBhh.sequence()
########################################################################
#
# NTupling
#
from Configurables import DecayTreeTuple
tupleBhh = DecayTreeTuple("tupleBhh")
tupleBhh.InputLocations = [SelSeqBhh.outputLocation()]
tupleBhh.Decay = "B_s0 -> K+ K-"
tupleBhh.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPrimaries"
, "TupleToolTrackInfo"
, "TupleToolPid"
, "TupleToolEventInfo"
, "TupleToolPropertime"
,"LoKi::Hybrid::TupleTool/LoKiTupleBhh"
]
from Configurables import LoKi__Hybrid__TupleTool
LoKiTupleBhh = LoKi__Hybrid__TupleTool("LoKiTupleBhh")
LoKiTupleBhh.Variables = {
## sc.appendStream( sstream )
#---------------------------
# Make Ntuples
#---------------------------
#from Configurables import PrintDecayTree, PrintDecayTreeTool
#printer = PrintDecayTree("Printer")
#printer.addTool( PrintDecayTreeTool, name = "PrintDecay" )
#printer.PrintDecay.Information = "Name M P Px Py Pz Pt chi2"
#printer.Inputs = TupleInputs
#---------------------------
# Configure lines and Decay
#---------------------------
tuple = DecayTreeTuple('DetachedN')
TupleInputs = []
for line in B2Lambda0MuLines:
TupleInputs.append(line.outputLocation())
tuple.Inputs = TupleInputs
tuple.OutputLevel = INFO
tuple.Decay = "[B- -> ^(Lambda0 -> ^mu- ^pi+) ^mu-]CC"
tuple.addBranches({
"B": "[B- -> (Lambda0 -> mu- pi+) mu-]CC",
"N": "[B- -> ^(Lambda0 -> mu- pi+) mu-]CC",
"mu_prim": "[B- -> (Lambda0 -> mu- pi+) ^mu-]CC",
"mu_sec": "[B- -> (Lambda0 -> ^mu- pi+) mu-]CC",
"pi": "[B- -> (Lambda0 -> mu- ^pi+) mu-]CC"
})
taganaBu.BHypoCriterium = "MinChi2"
taganaBu.RequireTisTos = True
if data != 'mc10':
taganaBu.EnableMC = False
taganaBu.OutputLevel = 6 #2
taganaBu.addTool(TriggerTisTos)
taganaBu.TriggerTisTos.OutputLevel = 6
taganaBu.addTool(TaggingUtilsChecker)
taganaBu.TaggingUtilsChecker.OutputLevel = 6
##############################################################################################
#TUPLE
TupleSeq = GaudiSequencer('TupleSeq')
################################################################################################
BuTuple = DecayTreeTuple("BuTuple")
BuTuple.ToolList += [
"TupleToolTrigger", "TupleToolGeometry", "TupleToolKinematic",
"TupleToolPropertime", "TupleToolPrimaries", "TupleToolTagging",
"TupleToolEventInfo", "TupleToolTrackInfo", "TupleToolRecoStats",
"TupleToolTrackPosition"
]
BuTuple.Inputs = [BuPartVtxlocation] #
BuTuple.Decay = Budecaydcr
BuTuple.ReFitPVs = True
TupleToolTrackPosition = TupleToolTrackPosition('TupleToolTrackPosition')
TupleToolTrackPosition.Z = 7500.
BuTuple.addTool(TupleToolTrackPosition)
TupleToolRecoStats = TupleToolRecoStats('TupleToolRecoStats')
subsel = Selection("subsel",
Algorithm=subalg,
RequiredSelections=[_selDimuons])
# Try and make B->J/psi K
_B = CombineParticles()
_B.DaughtersCuts = {"K+": "PT>500*MeV"}
_B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)<25.0)" #need to check these cuts
_B.DecayDescriptors = ["[B+ -> J/psi(1S) K+]cc"]
_BdecaySelection = Selection("TurboB",
Algorithm=_B,
RequiredSelections=[subsel, kaons])
SeqB = SelectionSequence('SeqB', TopSelection=_BdecaySelection)
tupleB = DecayTreeTuple("bae-muon-MC")
tupleB.Inputs = [SeqB.outputLocation()]
tupleB.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
tupleB.ToolList = [
"TupleToolKinematic",
"TupleToolEventInfo",
"TupleToolRecoStats",
"TupleToolMCBackgroundInfo",
"TupleToolMCBackgroundInfo", #comment out for data
"TupleToolMCTruth", #comment out for data
"TupleToolTrigger",
"TupleToolPid",
"TupleToolPrimaries",
"TupleToolAngles",
## More space for output
MessageSvc().Format = "% F%30W%S%15W%R%T %0W%M"
from Gaudi.Configuration import *
from Configurables import ( DaVinci, MessageSvc, FilterDesktop )
# Make the DecayTreeTuple
from Configurables import DecayTreeTuple
dtt = DecayTreeTuple (
'SwimmingDTT',
## print histos
HistoPrint = True,
## N-tuple LUN
NTupleLUN = "DTT",
## input particles from selection:
Inputs = [ '/Event/SwimStrippingD2hhMDST_v14r8/CharmToBeSwum/Phys/D2hhPromptD2KPiLine/Particles' ],
## Primary vertices from mDST
P2PVInputLocations = [ '/Event/SwimStrippingD2hhMDST_v14r8/CharmToBeSwum/Phys/D2hhPromptD2KPiLine/Particle2VertexRelations'],
UseP2PVRelations = True,
WriteP2PVRelations = False,
Decay = "[[D0]cc -> ^K- ^pi+]cc"
)
from DecayTreeTuple.Configuration import *
## Add appropriate tools
from Configurables import EventNodeKiller
killer=EventNodeKiller( Nodes = ["/Event/DAQ","/Event/pRec"] )
dtt.addBranches({
"D" : "[D0]cc : [[D0]cc -> K- pi+]cc"
})
# The MC truth Tuple
#
from Configurables import MCDecayTreeTuple
mcTuple = MCDecayTreeTuple("MCTuple")
mcTuple.Decay = "[KS0 -> ^pi+ ^pi- {, gamma}{, gamma}]cc"
mcTuple.ToolList = [
"MCTupleToolKinematic", "TupleToolEventInfo", "MCTupleToolReconstructed",
"MCTupleToolAngles"
]
#mcTuple.OutputLevel = 1
########################################################################
#
# The reconstructed tuple
#
from Configurables import DecayTreeTuple
tuple = DecayTreeTuple("Tuple")
tuple.ToolList += [
"TupleToolMCTruth", "TupleToolMCBackgroundInfo", "TupleToolAngles",
"TupleToolPrimaries", "TupleToolGeometry", "TupleToolKinematic",
"TupleToolEventInfo", "TupleToolTrackInfo"
]
tuple.InputLocations = ["StdLooseKsLL", "StdLooseKsDD"]
tuple.Decay = "[KS0 -> ^pi+ ^pi-]cc"
########################################################################
#
# DaVinci
#
from Configurables import DaVinci
DaVinci().EvtMax = 100000
DaVinci().PrintFreq = 100
from Configurables import DaVinci
# Configure DaVinci
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
DaVinci().PrintFreq = 1000
DaVinci().DataType = '2011'
DaVinci().Simulation = True
# Only ask for luminosity information when not using simulated data
DaVinci().EvtMax = -1
DaVinci().CondDBtag = 'sim-20130522-vc-md100'
DaVinci().DDDBtag = 'dddb-20130929'
#MessageSvc().OutputLevel = DEBUG
# Create an ntuple to capture B decays from the StrippingLine line
dtt = DecayTreeTuple('Bu2LLK_ee')
dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
#dtt.Decay = '[B0 -> K*(892)0 e- e+]CC'
dtt.Decay = '[B0 -> ^K*(892)0 ^(J/psi(1S) -> ^e- ^e+ )]CC'
#dtt.addBranches({'B0' : '[B0 -> K*(892)0 e- e+]CC',
# 'Kstar' : '[B0 -> ^K*(892)0 e- e+]CC',
# 'eplus' : '[B0 -> K*(892)0 ^e- e+]CC',
# 'eminus': '[B0 -> K*(892)0 e- ^e+]CC'})
dtt.addBranches({
'B0': '[^(B0 -> K*(892)0 (J/psi(1S) -> e- e+ ))]CC',
'Kst_892_0': '[B0 -> ^K*(892)0 (J/psi(1S) -> e- e+ )]CC',
'E1': '[B0 -> K*(892)0 (J/psi(1S) -> ^e- e+ )]CC',
'E2': '[B0 -> K*(892)0 (J/psi(1S) -> e- ^e+ )]CC',
'JPs': '[B0 -> K*(892)0 ^(J/psi(1S) -> e- e+ )]CC'
})
# muons
_muons2 = DataOnDemand(Location='Phys/SmrdLooseMuons')
_filtermuons2 = FilterDesktop("filterMuons2", Code = "TRCHI2DOF<4")
_selMuons2 = Selection("SelFilterMuons2",
Algorithm = _filtermuons,
RequiredSelections = [_muons])
_seqMuons2 = SelectionSequence("SeqFilterMuons2", TopSelection = _selMuons2)
#######################################################################
#
# Decay Tree tuple
#
from Configurables import DecayTreeTuple
decaytuple = DecayTreeTuple("OriginalPionsTuple")
decaytuple.InputLocations = [_seqPions.outputLocation() ]
decaytuple.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolTrackInfo"
, "TupleToolPid"
]
decaytuple.Decay = "[pi+]cc"
from Configurables import TupleToolTrigger
decaytuple.addTool( TupleToolTrigger, name='TupleToolTrigger' )
decaytuple.TupleToolTrigger.Verbose = True
decaytuple.TupleToolTrigger.UseAutomaticTriggerList = False
decaytuple.TupleToolTrigger.TriggerList =[
"Hlt1MBNoBiasDecision",
"Hlt1MBMicroBiasRZVeloDecision",
stripsel = AutomaticData(Location = "Phys/B2XMuMuIncl_InclDiMuLowQ2Line/Particles")
stripfilter = FilterDesktop("stripfilter",
Preambulo = ["from LoKiPhysMC.decorators import *",
"from LoKiPhysMC.functions import mcMatch"],
Code = "ALL")
inclmumu = Selection ("Sel"+name,
Algorithm = stripfilter,
RequiredSelections = [stripsel])
seq = SelectionSequence("seq",
TopSelection = inclmumu)
tuple = DecayTreeTuple("Incl_Tuple")
tuple.Inputs = [stripsel.outputLocation()]
tuple.ToolList = [
"TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
, "TupleToolMCBackgroundInfo"
, "TupleToolGeometry"
, "TupleToolPid"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolTrackInfo"
]
MCtruth = tuple.addTupleTool("TupleToolMCTruth")
MCtruth.addTupleTool("LoKi::Hybrid::MCTupleTool/LoKi_Photos").Variables = {
fname = "PgunElectrons"
from Configurables import DaVinci, LHCbApp
from Configurables import DecayTreeTuple, TupleToolDecay, L0Conf
from DecayTreeTuple.Configuration import *
from Gaudi.Configuration import *
# Use same tags as Gauss (from Gauss/options/Gauss-2012.py)
LHCbApp().DDDBtag = "dddb-20180726-2"
LHCbApp().CondDBtag = "sim-20160321-2-vc-md100"
LHCbApp().Simulation = True
# we did not run Moore, so force the TCK check to false.
L0Conf().EnsureKnownTCK = False
tup = DecayTreeTuple('electrons')
tup.Decay = '[e-]CC'
#tup.setDescriptorTemplate('${eminus}[e-]CC')
tup.Inputs = ["Phys/StdAllLooseElectrons/Particles"]
#tup.ReFitPVs = True
tup.ToolList = []
tup.addTupleTool("TupleToolKinematic") # Momenta
tup.addTupleTool("TupleToolBremInfo") # Info on photon that was BremAdded
tup.addTupleTool("TupleToolCaloInfo") # (custom) dump of ECAL clusters
tup.addTupleTool(
"TupleToolInfoAtCalo") # (custom) info on extrapolated position at ECAL
mctruthtool = tup.addTupleTool("TupleToolMCTruth")
mctruthtool.ToolList += ["MCTupleToolPhotonDaughters"
] # (custom) info of MC bremphoton daughters
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC"
]
_selPions2 = Selection("SelFilterPions2",
Algorithm = _filter2,
RequiredSelections = [_pions2])
_seqPions2 = SelectionSequence("SeqFilterPions2", TopSelection = _selPions2)
#######################################################################
#
# Decay Tree tuple
#
from Configurables import DecayTreeTuple
decaytuple = DecayTreeTuple("OriginalPionsTuple")
decaytuple.InputLocations = [_seqPions.outputLocation() ]
decaytuple.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolTrackInfo"
, "TupleToolPid"
]
decaytuple.Decay = "[pi+]cc"
decaytuple2 = DecayTreeTuple("SmearedPionsTuple")
decaytuple2.InputLocations = [_seqPions2.outputLocation() ]
decaytuple2.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolTrackInfo"
DecayTreeTuple,
DaVinci,
TrackScaleState,
CondDB,
TaggerMuonTool,
CallgrindProfile,
BTaggingTool,
MessageSvc,
)
from Gaudi.Configuration import INFO, DEBUG, WARNING
from DecayTreeTuple.Configuration import *
from FlavourTagging.Tunings import applyTuning
ntuple = DecayTreeTuple("TaggingTest")
descriptor_B = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC"
ntuple.Inputs = ['Dimuon/Phys/BetaSBd2JpsiKstarDetachedLine/Particles']
ntuple.Decay = descriptor_B
ntuple.addBranches({'B0': descriptor_B})
ntuple.ReFitPVs = True
ntuple.ToolList = [
"TupleToolKinematic", "TupleToolPropertime", "TupleToolPrimaries",
"TupleToolPid"
]
# Configure TupleToolTagging
tt_tagging = ntuple.addTupleTool("TupleToolTagging")
KMuMuSSlocation = 'Phys/D2XMuMu_KSSLine/Particles'
PiMuMuOSlocation = 'Phys/D2XMuMu_PiOSLine/Particles'
PiMuMuSSlocation = 'Phys/D2XMuMu_PiSSLine/Particles'
# Source: http://lhcb-release-area.web.cern.ch/LHCb-release-area/DOC/stripping/config/stripping21r1/index.html#charm
rootInTes = "/Event/Charm"
#----------------------------------------
# 1) The code that makes the ntuple
#----------------------------------------
# These are various tupletools that fill the ntuple with different information
from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolSelResults, TupleToolTrackInfo, TupleToolEventInfo, TupleToolVtxIsoln, TupleToolTrackIsolation, TupleToolAngles, TupleToolRecoStats
tuple = DecayTreeTuple()
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolPid"
, "TupleToolEventInfo"
, "TupleToolTrackInfo"
, "TupleToolTrigger"
, "TupleToolTISTOS"
, "TupleToolAngles"
, "TupleToolVtxIsoln"
, "TupleToolTrackIsolation"
from Configurables import DaVinci, LHCbApp
from Configurables import DecayTreeTuple, TupleToolDecay
from DecayTreeTuple.Configuration import *
####################
## Define ntuples
# pions (test)
#tuple_pions = DecayTreeTuple( 'pions' )
#tuple_pions.Decay = '[pi+]CC'
#tuple_pions.Inputs = ["Phys/StdAllLoosePions/Particles"]
#tuple_pions.addTool(TupleToolDecay, name="Pi")
# (prompt) Lc -> p K pi
line1 = "LambdaCForPromptCharm"
tuple_Lc2pKpi = DecayTreeTuple('tuple_Lc2pKpi')
tuple_Lc2pKpi.Inputs = ['Phys/{0}/Particles'.format(line1)]
#tuple_Lc2pKpi.Decay = '[Lambda_c+ -> ^p+ ^K- ^pi+]CC'
tuple_Lc2pKpi.setDescriptorTemplate(
'${lcplus}[Lambda_c+ -> ${pplus}p+ ${kminus}K- ${pplus}pi+]CC')
# add DecayTreeFitter tool to constrain origin to PV and refit kinematics
dtftool = tuple_Lc2pKpi.lcplus.addTupleTool(
'TupleToolDecayTreeFitter/PVConstrainedDTF')
dtftool.constrainToOriginVertex = True
# (detached) B -> (Lc -> p K pi) mu nu
#line = "SelLc2PKPiforCharmFromBSemi"
#tuple_b2Lc2pKpi = DecayTreeTuple( 'tuple_b2Lc2pKpi' )
#tuple_b2Lc2pKpi.Inputs = ['Phys/{0}/Particles'.format(line)]
#tuple_b2Lc2pKpi.Decay = '[ Beauty -> ^( Lambda_c+ -> ^p ^K- ^pi+ ) ^mu- ]CC'
from DecayTreeTuple.Configuration import *
from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolSelResults, TupleToolTrackInfo, TupleToolEventInfo, TupleToolVtxIsoln, TupleToolTrackIsolation, TupleToolAngles, TupleToolRecoStats
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2XMuMu_KOSLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('D2KmumuOSTuple')
dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
dtt.Decay = '[D+ -> ^K+ ^mu+ ^mu-]CC'
dtt.ToolList += [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolPid"
, "TupleToolEventInfo"
, "TupleToolTrackInfo"
, "TupleToolTrigger"
, "TupleToolAngles"
# , "TupleToolVtxIsoln"
, "TupleToolTrackIsolation"
, "TupleToolTrigger"
, "TupleToolTISTOS"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
]
dtt.addTool(TupleToolTISTOS("TupleToolTISTOS"))
# change the column size of timing table
from Configurables import TimingAuditor, SequencerTimerTool
TimingAuditor().addTool(SequencerTimerTool, name="TIMER")
TimingAuditor().TIMER.NameSize = 60
MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
# database
DaVinci().DDDBtag = "dddb-20120831"
DaVinci().CondDBtag = "cond-20121008"
# input file
importOptions("$STRIPPINGSELECTIONSROOT/tests/data/Reco14_Run125113.py")
from Configurables import DecayTreeTuple
Tup = DecayTreeTuple("Tup")
Tup.Inputs = ["Phys/B2DstMuNuInclLine/Particles"]
Tup.Decay = "[B~0 -> ^(D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+) ^mu-]CC"
Tup.Branches = {
"B": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) pi+) mu-]CC",
"Dst": "[B~0 -> ^(D*(2010)+ -> (D0 -> K- pi+) pi+) mu-]CC",
"D0": "[B~0 -> (D*(2010)+ -> ^(D0 -> K- pi+) pi+) mu-]CC",
"Slowpi": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) ^pi+) mu-]CC",
"mu": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) pi+) ^mu-]CC"
}
DaVinci().appendToMainSequence([Tup])
TupWS = DecayTreeTuple("Tup")
TupWS.Inputs = ["Phys/B2DstMuNuInclWSLine/Particles"]
TupWS.Decay = "[B~0 -> ^(D*(2010)- -> ^(D0 -> ^K- ^pi+) ^pi-) ^mu-]CC"
TupWS.Branches = {
from Gaudi.Configuration import *
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolTISTOS, CondDB
from DecayTreeTuple.Configuration import *
tuple = DecayTreeTuple("Jpsi_Tuple")
tuple.Inputs = ["/Event/Dimuon/Phys/B2XMuMu_Line/Particles"]
tuple.ToolList = [
"TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
, "TupleBuKmmFit"
]
tuple.addBranches ({
"Bplus" : "[B+ -> K+ ( J/psi(1S) -> mu+ mu-)]CC",
"Kplus" : "[B+ -> ^K+ ( J/psi(1S) -> mu+ mu-)]CC",
"Jpsi" : "[B+ -> K+ ^( J/psi(1S) -> mu+ mu-)]CC",
"muplus" : "[B+ -> K+ ( J/psi(1S) -> ^mu+ mu-)]CC",
"muminus" : "[B+ -> K+ ( J/psi(1S) -> mu+ ^mu-)]CC",
})
LoKi_All = tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All")
LoKi_All.Variables = {
'MINIPCHI2' : "MIPCHI2DV(PRIMARY)",
'MINIP' : "MIPDV(PRIMARY)",
'IPCHI2_OWNPV' : "BPVIPCHI2()",
'IP_OWNPV' : "BPVIP()"
def __apply_configuration__(self):
from Configurables import (GaudiSequencer, CombineParticles,
OfflineVertexFitter)
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
seq = self.getProp("Sequencer")
if seq == None: raise RuntimeError("ERROR : Sequence not set")
if self.getProp("RunSelection"):
# STD particles
from StandardParticles import StdNoPIDsPions, StdNoPIDsKaons
# phi -> K+ K-
Phi2KKName = self.__sel_name__ + "_Phi2KK"
Phi2KK = CombineParticles(Phi2KKName)
Phi2KK.DecayDescriptor = "phi(1020) -> K+ K-"
Phi2KK.CombinationCut = "(ADAMASS('phi(1020)')<75*MeV)"
Phi2KK.MotherCut = "(ADMASS('phi(1020)')<50*MeV) & (BPVVDCHI2>60) & (MIPDV(PRIMARY)<0.5) & (VFASPF(VCHI2) < 20)"
Phi2KK.DaughtersCuts = {
"K+":
"(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)",
"K-":
"(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)"
}
self.setOptions(Phi2KK)
Phi2KKSel = Selection(Phi2KKName + 'Sel',
Algorithm=Phi2KK,
RequiredSelections=[StdNoPIDsKaons])
# Bs -> J/psi phi
Ds2piPhiName = self.__sel_name__
Ds2piPhi = CombineParticles(Ds2piPhiName)
Ds2piPhi.DecayDescriptor = "[D_s+ -> pi+ phi(1020)]cc"
Ds2piPhi.addTool(OfflineVertexFitter)
Ds2piPhi.ParticleCombiners.update({"": "OfflineVertexFitter"})
Ds2piPhi.OfflineVertexFitter.useResonanceVertex = True
Ds2piPhi.CombinationCut = "(ADAMASS('D_s+')<75*MeV)"
Ds2piPhi.MotherCut = "(ADMASS('D_s+')<50*MeV) & (BPVDIRA>0.9999) & (BPVVDCHI2>85) & (MIPDV(PRIMARY)<0.1) & (VFASPF(VCHI2) < 10)"
Ds2piPhi.DaughtersCuts = {
"pi+":
"(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) >0.1) & (BPVIPCHI2() > 20)"
}
self.setOptions(Ds2piPhi)
Ds2piPhiSel = Selection(
Ds2piPhiName + 'Sel',
Algorithm=Ds2piPhi,
RequiredSelections=[Phi2KKSel, StdNoPIDsPions])
# Selection Sequence
selSeq = SelectionSequence(self.__sel_name__ + 'Seq',
TopSelection=Ds2piPhiSel)
# Run the selection sequence.
seq.Members += [selSeq.sequence()]
# Particle Monitoring plots
if self.getProp("RunMonitors"):
from Configurables import ParticleMonitor
plotter = ParticleMonitor(self.__sel_name__ + "Plots")
if self.getProp("RunSelection"):
plotter.Inputs = ['Phys/' + self.__sel_name__ + 'Sel']
else:
plotter.Inputs = self.getProp("Candidates")
plotter.PeakCut = "(ADMASS('D_s+')<100*MeV)"
plotter.SideBandCut = "(ADMASS('D_s+')>100*MeV)"
plotter.PlotTools = self.getProp("PlotTools")
self.setOptions(plotter)
seq.Members += [plotter]
# Make a DST ?
if self.getProp("MakeSelDST"):
# Prescale
from Configurables import DeterministicPrescaler
scaler = DeterministicPrescaler(
self.__sel_name__ + 'PreScale',
AcceptFraction=self.getProp("DSTPreScaleFraction"))
seq.Members += [scaler]
# Write the DST
MyDSTWriter = SelDSTWriter(self.__sel_name__ + "DST",
SelectionSequences=[selSeq],
OutputPrefix=self.__sel_name__)
seq.Members += [MyDSTWriter.sequence()]
# MC Performance checking ?
if self.getProp("MCChecks"):
from Configurables import ParticleEffPurMoni
mcPerf = ParticleEffPurMoni(Ds2piPhiName + "MCPerf")
mcPerf.Inputs = ['Phys/' + self.__sel_name__ + 'Sel']
self.setOptions(mcPerf)
seq.Members += [mcPerf]
# Ntuple ?
if self.getProp("MakeNTuple"):
outputLevel = INFO
from Configurables import (
DecayTreeTuple, TupleToolDecay, TupleToolMCTruth,
TupleToolMCBackgroundInfo, TupleToolGeometry,
TupleToolKinematic, TupleToolPrimaries, TupleToolEventInfo,
MCTupleToolHierarchy, MCTupleToolKinematic, TupleToolPid,
TupleToolTrackInfo, TupleToolVtxIsoln, LoKi__Hybrid__TupleTool)
Tuple = DecayTreeTuple(Ds2piPhiName + "Tuple")
Tuple.Inputs = ["Phys/" + Ds2piPhiName]
Tuple.Decay = "[D_s+ -> ^pi+ (^phi(1020) => ^K+ ^K-)]cc"
Tuple.Branches = {
"pion": "[D_s+ -> ^pi+ (phi(1020) => K+ K-)]cc",
"kaonplus": "[D_s+ -> pi+ (phi(1020) => ^K+ K-)]cc",
"kaonminus": "[D_s+ -> pi+ (phi(1020) => K+ ^K-)]cc",
"phi": "[D_s+ -> pi+ (^phi(1020) => K+ K-)]cc",
"D_s": "[D_s+]cc :[D_s+ -> pi+ (phi(1020) => K+ K-)]cc"
}
Tuple.addTool(TupleToolDecay, name='pion')
Tuple.addTool(TupleToolDecay, name='phi')
Tuple.addTool(TupleToolDecay, name='kaonplus')
Tuple.addTool(TupleToolDecay, name='kaonminus')
Tuple.addTool(TupleToolDecay, name='D_s')
# k+ specific
kaonplusLoKiTool = LoKi__Hybrid__TupleTool('kaonplusLoKiTool')
kaonplusLoKiTool.Variables = {
"LOKI_PIDK": "PIDK",
"LOKI_PIDe": "PIDe",
"LOKI_PIDpi": "PIDpi",
"LOKI_PIDp": "PIDp",
"LOKI_PIDmu": "PIDmu",
"LOKI_PIDK_PIDpi": "PIDK-PIDpi",
"LOKI_PIDK_PIDe": "PIDK-PIDe",
"LOKI_PIDK_PIDmu": "PIDK-PIDmu",
"LOKI_PIDK_PIDp": "PIDK-PIDp"
}
Tuple.kaonplus.addTool(kaonplusLoKiTool, name='kaonplusLoKiTool')
Tuple.kaonplus.ToolList = [
'LoKi::Hybrid::TupleTool/kaonplusLoKiTool'
]
# k- specific
kaonminusLoKiTool = LoKi__Hybrid__TupleTool('kaonminusLoKiTool')
kaonminusLoKiTool.Variables = {
"LOKI_PIDK": "PIDK",
"LOKI_PIDe": "PIDe",
"LOKI_PIDpi": "PIDpi",
"LOKI_PIDp": "PIDp",
"LOKI_PIDmu": "PIDmu",
"LOKI_PIDK_PIDpi": "PIDK-PIDpi",
"LOKI_PIDK_PIDe": "PIDK-PIDe",
"LOKI_PIDK_PIDmu": "PIDK-PIDmu",
"LOKI_PIDK_PIDp": "PIDK-PIDp"
}
Tuple.kaonminus.addTool(kaonminusLoKiTool,
name='kaonminusLoKiTool')
Tuple.kaonminus.ToolList = [
'LoKi::Hybrid::TupleTool/kaonminusLoKiTool'
]
# pi+ specific
pionLoKiTool = LoKi__Hybrid__TupleTool('pionLoKiTool')
pionLoKiTool.Variables = {
"LOKI_PIDK": "PIDK",
"LOKI_PIDe": "PIDe",
"LOKI_PIDpi": "PIDpi",
"LOKI_PIDp": "PIDp",
"LOKI_PIDmu": "PIDmu",
"LOKI_PIDpi_PIDK": "PIDpi-PIDK",
"LOKI_PIDpi_PIDe": "PIDpi-PIDe",
"LOKI_PIDpi_PIDmu": "PIDpi-PIDmu",
"LOKI_PIDpi_PIDp": "PIDpi-PIDp"
}
Tuple.pion.addTool(pionLoKiTool, name='pionLoKiTool')
Tuple.pion.ToolList = ['LoKi::Hybrid::TupleTool/pionLoKiTool']
# phi specific
phiLoKiTool = LoKi__Hybrid__TupleTool('phiLoKiTool')
phiLoKiTool.Variables = {}
Tuple.phi.addTool(phiLoKiTool, name='phiLoKiTool')
Tuple.phi.ToolList = ['LoKi::Hybrid::TupleTool/phiLoKiTool']
# D_s specific
DsLoKiTool = LoKi__Hybrid__TupleTool('DsLoKiTool')
DsLoKiTool.Variables = {}
Tuple.D_s.addTool(DsLoKiTool, name='DsLoKiTool')
Tuple.D_s.ToolList = ["LoKi::Hybrid::TupleTool/DsLoKiTool"]
# Common to all particles
LoKiTool = LoKi__Hybrid__TupleTool('LoKiTool')
LoKiTool.Variables = {
"LOKI_ABSID": "ABSID",
"LOKI_BPVIPCHI2": "BPVIPCHI2()",
"LOKI_BPVDIRA": "BPVDIRA",
"LOKI_BPVLTFITCHI2":
"BPVLTFITCHI2('PropertimeFitter/properTime:PUBLIC')",
"LOKI_BPVLTCHI2":
"BPVLTCHI2('PropertimeFitter/properTime:PUBLIC')",
"LOKI_BPVLTIME":
"BPVLTIME('PropertimeFitter/properTime:PUBLIC')",
"LOKI_BPVVDCHI2": "BPVVDCHI2",
"LOKI_ID": "ID",
"LOKI_MIPDV_PRIMARY": "MIPDV(PRIMARY)",
"LOKI_MIPCHI2DV_PRIMARY": "MIPCHI2DV(PRIMARY)",
"LOKI_MM": "MM",
"LOKI_M": "M",
"LOKI_P": "P",
"LOKI_PT": "PT",
"LOKI_TRCHI2": "TRCHI2",
"LOKI_TRCHI2DOF": "TRCHI2DOF",
"LOKI_VFASPF_VCHI2": "VFASPF(VCHI2)",
"LOKI_VFASPF_VDOF": "VFASPF(VDOF)"
}
Tuple.addTool(LoKiTool, name='LoKiTool')
Tuple.ToolList = [
"LoKi::Hybrid::TupleTool/LoKiTool", "TupleToolEventInfo",
"TupleToolGeometry", "TupleToolKinematic",
"TupleToolMCBackgroundInfo", "TupleToolPid",
"TupleToolPrimaries", "TupleToolTrackInfo",
"TupleToolVtxIsoln", "TupleToolMCTruth"
]
Tuple.addTool(TupleToolEventInfo)
Tuple.TupleToolEventInfo.OutputLevel = outputLevel
Tuple.addTool(TupleToolGeometry)
Tuple.TupleToolGeometry.OutputLevel = outputLevel
Tuple.addTool(TupleToolKinematic)
Tuple.TupleToolKinematic.OutputLevel = outputLevel
Tuple.addTool(TupleToolMCBackgroundInfo)
Tuple.TupleToolMCBackgroundInfo.OutputLevel = outputLevel
Tuple.addTool(MCTupleToolHierarchy)
Tuple.MCTupleToolHierarchy.OutputLevel = outputLevel
Tuple.addTool(TupleToolMCTruth)
Tuple.TupleToolMCTruth.OutputLevel = outputLevel
Tuple.TupleToolMCTruth.addTool(MCTupleToolKinematic())
Tuple.TupleToolMCTruth.addTool(MCTupleToolHierarchy())
Tuple.TupleToolMCTruth.ToolList = [
"MCTupleToolKinematic", "MCTupleToolHierarchy"
]
Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreKineticInfo = True
Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreVertexInfo = True
Tuple.TupleToolMCTruth.MCTupleToolKinematic.StorePropertimeInfo = True
Tuple.TupleToolMCTruth.MCTupleToolKinematic.OutputLevel = outputLevel
Tuple.addTool(TupleToolPid)
Tuple.TupleToolPid.OutputLevel = outputLevel
Tuple.addTool(TupleToolPrimaries)
Tuple.TupleToolPrimaries.OutputLevel = outputLevel
Tuple.addTool(TupleToolTrackInfo)
Tuple.TupleToolTrackInfo.OutputLevel = outputLevel
Tuple.addTool(TupleToolVtxIsoln)
Tuple.TupleToolVtxIsoln.OutputLevel = outputLevel
seq.Members += [Tuple]
Tuple.NTupleLUN = "DSPHIPI"
from Configurables import NTupleSvc
NTupleSvc().Output = [
"DSPHIPI DATAFILE='DsToPhiPi.root' TYP='ROOT' OPT='NEW'"
]
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
from Configurables import DaVinci
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhPromptDst2D2KKLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK')
dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
dtt.Decay = '[D*(2010)+ -> (D0 -> K- K+) pi+]CC'
# Configure DaVinci
DaVinci().UserAlgorithms += [dtt]
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
DaVinci().PrintFreq = 1000
DaVinci().DataType = '2016'
DaVinci().Simulation = True
# Only ask for luminosity information when not using simulated data
DaVinci().Lumi = not DaVinci().Simulation
DaVinci().EvtMax = -1
DaVinci().CondDBtag = 'sim-20161124-2-vc-md100'
DaVinci().DDDBtag = 'dddb-20150724'
def __apply_configuration__(self) :
from Configurables import ( GaudiSequencer, CombineParticles )
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
if not self.isPropertySet("Sequencer") :
raise RuntimeError("ERROR : Sequence not set")
seq = self.getProp("Sequencer")
if self.getProp("RunSelection") :
# STD particles
from StandardParticles import StdLooseMuons
# J/psi -> mu mu
JPsiMuMuName = self.__sel_name__
JPsiMuMu = CombineParticles(JPsiMuMuName)
JPsiMuMu.DecayDescriptor = "J/psi(1S) -> mu+ mu- "
JPsiMuMu.CombinationCut = "(ADAMASS('J/psi(1S)') < 150*MeV)"
JPsiMuMu.MotherCut = "(ADMASS('J/psi(1S)') < 130*MeV) & (VFASPF(VCHI2/VDOF)<6) & (PT > 2500*MeV)"
JPsiMuMu.DaughtersCuts = {"mu+" : "(PT>1400*MeV)"\
"& (P>5*GeV)"\
"& (TRCHI2DOF<2.0)"\
"& (PPINFO(LHCb.ProtoParticle.MuonBkgLL,-10000)<-2.5)"\
"& (PPINFO(LHCb.ProtoParticle.MuonMuLL,-10000)>-10)"}
self.setOptions(JPsiMuMu)
JPsiMuMuSel = Selection( JPsiMuMuName+'Sel',
Algorithm = JPsiMuMu,
RequiredSelections = [StdLooseMuons] )
# Selection Sequence
selSeq = SelectionSequence( self.__sel_name__+'Seq', TopSelection = JPsiMuMuSel )
# Run the selection sequence.
seq.Members += [selSeq.sequence()]
# Particle Monitoring plots
if self.getProp("RunMonitors") :
from Configurables import ( ParticleMonitor )
plotter = ParticleMonitor(self.__sel_name__+"Plots")
if self.getProp("RunSelection") :
plotter.Inputs = [ 'Phys/'+self.__sel_name__+'Sel' ]
else:
musel = "(PT>1400*MeV) & (P>5*GeV) & (TRCHI2DOF<2.0) & "\
"(PPINFO(LHCb.ProtoParticle.MuonBkgLL,-10000)<-2.5) & "\
"(PPINFO(LHCb.ProtoParticle.MuonMuLL,-10000)>-10)"
_code = "( ( INTREE( ('mu+'==ID) & "+musel+" ) ) | ( INTREE( ('mu-'==ID) & "+musel+" ) ) )"
from Configurables import FilterDesktop
filter = FilterDesktop( name = self.__sel_name__+"RICHFiltered",
Code = _code,
Inputs = self.getProp("Candidates") )
plotter.Inputs = [ 'Phys/'+filter.name() ]
seq.Members += [filter]
plotter.PeakCut = "(ADMASS('J/psi(1S)')<20*MeV)" # Considering sigma = 13
plotter.SideBandCut = "(ADMASS('J/psi(1S)')>20*MeV)" # Considering sigma = 13
plotter.PlotTools = self.getProp("PlotTools")
self.setOptions(plotter)
seq.Members += [plotter]
# Make a DST ?
if self.getProp("MakeSelDST"):
# Prescale
from Configurables import DeterministicPrescaler
scaler = DeterministicPrescaler( self.__sel_name__+'PreScale',
AcceptFraction = self.getProp("DSTPreScaleFraction") )
seq.Members += [scaler]
# Write the DST
MyDSTWriter = SelDSTWriter( self.__sel_name__+"DST",
SelectionSequences = [ selSeq ],
OutputPrefix = self.__sel_name__ )
seq.Members += [MyDSTWriter.sequence()]
# MC Performance checking ?
if self.getProp("MCChecks") :
from Configurables import ParticleEffPurMoni
mcPerf = ParticleEffPurMoni(JPsiMuMuName+"MCPerf")
mcPerf.Inputs = ['Phys/'+self.__sel_name__+'Sel']
self.setOptions(mcPerf)
seq.Members += [mcPerf]
# Ntuple ?
if self.getProp("MakeNTuple") :
from Configurables import ( DecayTreeTuple,
TupleToolDecay,
LoKi__Hybrid__FilterCriterion,
LoKi__Hybrid__TupleTool,
TupleToolMCBackgroundInfo,
BackgroundCategory,
TupleToolTrigger,
TupleToolMCTruth,
MCTupleToolKinematic,
MCTupleToolHierarchy,
TupleToolVtxIsoln,
TupleToolP2VV
)
JPsiMuMuTree = DecayTreeTuple( JPsiMuMuName + 'Tuple')
JPsiMuMuTree.Inputs = [ 'Phys/'+JPsiMuMuName]
JPsiMuMuTree.Decay = 'J/psi(1S) -> ^mu+ ^mu- '
# set some names for ntuple branchs
MyBranch_jpsi = "jpsi"
MyBranch_mup = "mup"
MyBranch_mum = "mum"
# label the branches for the particle tools
JPsiMuMuTree.Branches = {
MyBranch_jpsi : "J/psi(1S) : J/psi(1S) -> mu+ mu- ",
MyBranch_mup : "J/psi(1S) -> ^mu+ mu- ",
MyBranch_mum : "J/psi(1S) -> mu+ ^mu- ",
}
JPsiMuMuTree.ToolList = [
"TupleToolEventInfo"
, "TupleToolGeneration"
, "TupleToolMCTruth"
, "TupleToolMCBackgroundInfo"
, "MCTupleToolKinematic"
, "TupleToolPrimaries"
, "TupleToolVtxIsoln"
, "TupleToolTrackInfo"
, "TupleToolPid"
, "TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPid"
, "TupleToolPrimaries"
, "TupleToolTrigger"
]
JPsiMuMuTree.addTool(BackgroundCategory())
JPsiMuMuTree.BackgroundCategory.SoftPhotonCut = 2000
JPsiMuMuTree.OutputLevel = INFO
JPsiMuMuTree.addTool(TupleToolTrigger())
JPsiMuMuTree.TupleToolTrigger.VerboseL0 = True
JPsiMuMuTree.addTool(TupleToolMCTruth())
JPsiMuMuTree.TupleToolMCTruth.addTool(MCTupleToolKinematic())
JPsiMuMuTree.TupleToolMCTruth.addTool(MCTupleToolHierarchy())
JPsiMuMuTree.TupleToolMCTruth.ToolList = [
"MCTupleToolKinematic" ,
"MCTupleToolHierarchy"
]
JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StoreKineticInfo = True
JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StoreVertexInfo = True
JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StorePropertimeInfo = False
JPsiMuMuTree.addTool(TupleToolVtxIsoln( OutputLevel = 6 ))
JPsiMuMuTree.TupleToolVtxIsoln.IP = 2.0
JPsiMuMuTree.TupleToolVtxIsoln.InputParticles = [ "Phys/StdLooseMuons"]
seq.Members += [JPsiMuMuTree]
JPsiMuMuTree.NTupleLUN = "JPSIMUMU"
from Configurables import NTupleSvc
NTupleSvc().Output = ["JPSIMUMU DATAFILE='JpsiMuMu_Presel.root' TYP='ROOT' OPT='NEW'"]
TISTOSTool.addTool(TriggerTisTos, name="TriggerTisTos")
LoKi_B = LoKi__Hybrid__TupleTool("LoKi_B")
LoKi_B.Variables = {
"ETA": "ETA",
"PHI": "PHI",
"FDCHI2": "BPVVDCHI2",
"FDS": "BPVDLS",
"DIRA": "BPVDIRA",
"pi0veto": "CHILDFUN ( PINFO( 25030 , -1 ) , 'gamma' == ABSID ) ",
}
LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables = {"NSHAREDMU": "NSHAREDMU"}
tuple_B2Kmumu = DecayTreeTuple("Tuple")
tuple_B2Kmumu.Inputs = [location]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[Lambda_b0 -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^p+ ^K-]CC'
tuple_B2Kmumu.Branches = {
"Lambda_b0":
"[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC",
"chi_c":
"[Lambda_b0 -> ^(chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC",
"Jpsi":
"[Lambda_b0 -> (chi_c1(1P) -> ^(J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC",
"gamma":
"[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) ^gamma) p+ K-]CC",
"muplus":
"[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> ^mu+ mu-) gamma) p+ K-]CC",
"muminus":
from MicroDSTConf.TriggerConfUtils import configureL0AndHltDecoding
locationRoot += '/' + mDSTName
configureL0AndHltDecoding(locationRoot)
from Gaudi.Configuration import *
from Configurables import (DaVinci, MessageSvc, FilterDesktop)
# Make the DecayTreeTuple
from Configurables import DecayTreeTuple
dtt = DecayTreeTuple(
'SwimmingDTT',
## print histos
HistoPrint=True,
## N-tuple LUN
NTupleLUN="DTT",
## input particles from selection:
Inputs=[particlePath],
## Primary vertices from mDST
P2PVInputLocations=[p2PVLocation],
UseP2PVRelations=True,
WriteP2PVRelations=False,
)
dtt.Decay = "B_s0 -> (^J/psi(1S) => ^mu+ ^mu-) (^phi(1020) -> ^K+ ^K-)"
if mDST: dtt.RootInTES = locationRoot
from DecayTreeTuple.Configuration import *
## Add appropriate tools
dtt.addBranches(
{"B": "B_s0 : B_s0 -> (J/psi(1S) => mu+ mu-) (phi(1020) -> K+ K-)"})
