def makeDecayTreeTuple( location, decay, alg_name, tuple_name ):
tuple = DecayTreeTuple( alg_name )
dectype = alg_name[-2:]
#triggerList = list(l0hlt1List)
#if 'KK' == dectype:
# for trigger in hlt2List_KK:
# triggerList.append( trigger + 'Decision')
#elif 'Pi' == dectype:
# for trigger in hlt2List_Pi:
# triggerList.append( trigger + 'Decision')
#elif 'RS' == dectype or 'WS' == dectype:
# for trigger in hlt2List_KPi:
# triggerList.append( trigger + 'Decision')
print alg_name, triggerList
#tuple = DecayTreeTuple('TupleKK')
tuple.ToolList = [ "TupleToolPropertime", "TupleToolKinematic", #"TupleToolPropertime/MyPropertimeTool",
"TupleToolGeometry", "TupleToolEventInfo", "TupleToolPrimaries", "TupleToolTISTOS", #"TupleToolTrigger",
"TupleToolPid", "TupleToolTrackInfo", "TupleToolRecoStats", #"TupleToolGeneration"
]
#tuple.addTool( TupleToolPropertime( name="MyPropertimeTool" ) )
#tuple.MyPropertimeTool.ToolName = "PropertimeFitter/MyPropertimeFitter"
#tuple.MyPropertimeTool.ExtraName = "MassConstraint"
#tuple.MyPropertimeTool.addTool( PropertimeFitter( name = "MyPropertimeFitter" ) )
#tuple.MyPropertimeTool.MyPropertimeFitter.applyBMassConstraint = True
tuple.Inputs = [ location ]#_strippingOutput]
#tuple.InputLocations = [ location ]#_strippingOutput]
tuple.Decay = decay
#tuple.Decay = "[D0 -> ^K- ^pi+]CC"
tuple.TupleName = tuple_name
#tuple.TupleName = "D0KKTuple"
tuple.addTool( TupleToolPropertime() )
tuple.TupleToolPropertime.FitToPV = True
#tuple.addTool( TupleToolTrigger() )
#tuple.TupleToolTrigger.TriggerList = triggerList
#tuple.TupleToolTrigger.VerboseL0 = True
#tuple.TupleToolTrigger.VerboseHlt1 = True
#tuple.TupleToolTrigger.VerboseHlt2 = True
#tuple.TupleToolTrigger.Verbose = True
tuple.addTool( TupleToolTISTOS() )
tuple.TupleToolTISTOS.VerboseL0 = True
tuple.TupleToolTISTOS.VerboseHlt1 = True
tuple.TupleToolTISTOS.VerboseHlt2 = True
tuple.TupleToolTISTOS.Verbose = True
tuple.TupleToolTISTOS.TriggerList = triggerList
return tuple
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
TurboConf().PersistReco = True
pions = DataOnDemand('Phys/StdAllNoPIDsPions/Particles')
ks0 = CombineParticles('Ks0Topipi',
DecayDescriptors=['[KS0 -> pi+ pi+]cc'],
CombinationCut=("AM < 320*MeV"), #parent
MotherCut="ALL")
ks0_sel = Selection(
'Sel_Ks0Topipi',
Algorithm=ks0,
RequiredSelections=[pions]
)
ks0_selseq = SelectionSequence(
'SelSeq_Ks0Topipi',
TopSelection=ks0_sel
)
dtt_ks0 = DecayTreeTuple('TupleKs0Topipi')
dtt_ks0.Inputs = ks0_selseq.outputLocations()
dtt_ks0.Decay = '[KS0 -> ^pi+ ^pi+]CC'
dtt_ks0.addBranches({
'Ks0': '[KS0 -> pi+ pi+]CC',
'pi1': '[KS0 -> ^pi+ pi+]CC',
'pi2': '[KS0 -> pi+ ^pi+]CC'
})
DaVinci().UserAlgorithms = [ks0_selseq.sequence(), dtt_ks0]
DaVinci().DataType = '2016'
DaVinci().EvtMax = 1000
DaVinci().TupleFile = 'PersistRecoTuple_ks0_pipi.root'
from GaudiConf import IOHelper
from Configurables import DaVinci, DecayTreeTuple
from DecayTreeTuple.Configuration import *
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhCompleteEventPromptDst2D2RSLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi')
dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
# Note that we mark all particles, otherwise the branches won't work
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+]CC'
track_tool = dtt.addTupleTool('TupleToolTrackInfo')
track_tool.Verbose = True
dtt.addTupleTool('TupleToolPrimaries')
dtt.addBranches({
'Dstar': '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC',
'D0': '[D*(2010)+ -> ^(D0 -> K- pi+) pi+]CC',
'Kminus': '[D*(2010)+ -> (D0 -> ^K- pi+) pi+]CC',
'piplus': '[D*(2010)+ -> (D0 -> K- ^pi+) pi+]CC',
'pisoft': '[D*(2010)+ -> (D0 -> K- pi+) ^pi+]CC'
})
dtt.D0.addTupleTool('TupleToolPropertime')
# Configure DaVinci
DaVinci().UserAlgorithms += [dtt]
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
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")
from Gaudi.Configuration import *
from Configurables import DaVinci
from Configurables import GaudiSequencer
simulation=False
stream='Bhadron'
line='StrippingB2XEtaLb2pKeta3piLine'
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
tuple=DecayTreeTuple()
tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta -> ^pi+ ^pi- ^(pi0 -> ^gamma ^gamma))]CC"
tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta -> pi+ pi- (pi0 -> gamma gamma))]CC"}
tuple.Inputs=['Phys/{0}/Particles'.format(line)]
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolDira"
, "TupleToolAngles"
, "TupleToolPid"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolEventInfo"
, "TupleToolTrackInfo"
, "TupleToolVtxIsoln"
, "TupleToolPhotonInfo"
#, "TupleToolMCTruth"
#, "TupleToolMCBackgroundInfo"
, "TupleToolCaloHypo"
# 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 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'
MaxCandidates = 2000,
AcceptBadEvents = False,
BadEventSelection = filterBadEvents)
DaVinci().appendToMainSequence([event_node_killer,sc.sequence()])
##################Creating NTuples#####################################
from Configurables import DecayTreeTuple
from Configurables import TupleToolL0Calo
from DecayTreeTuple.Configuration import *
line = 'B2XEtaLb2pKeta3piLine'
tuple=DecayTreeTuple()
tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta -> ^pi+ ^pi- ^(pi0 -> ^gamma ^gamma))]CC"
tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta -> pi+ pi- (pi0 -> gamma gamma))]CC"}
tuple.Inputs=['/Event/Phys/{0}/Particles'.format(line)]
tuple.addTool(TupleToolL0Calo())
tuple.TupleToolL0Calo.TriggerClusterLocation="/Event/Trig/L0/Calo"
tuple.TupleToolL0Calo.WhichCalo="HCAL"
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolDira"
, "TupleToolAngles"
# , "TupleToolL0Calo"
, "TupleToolPid"
, "TupleToolKinematic"
########################################################################
#
# J/psi n-tuple
#
# @author Bilas Pal
# @date 2010-11-01
######
########################################################################
from Gaudi.Configuration import *
#
# DecayTreeTuple
#
from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolTagging
from Configurables import FitDecayTrees, TupleToolGeometry
tuple = DecayTreeTuple('Lb2JpsiLTree')
tuple.Inputs = [ 'Phys/Bs2Jpsif0' ]
tuple.TupleName = "mytree"
tuple.ToolList = [
"TupleToolGeometry",
"TupleToolKinematic",
"TupleToolEventInfo",
# "TupleToolTISTOS",
"TupleToolPid",
"TupleToolTrackInfo",
# "TupleToolTagging"
]
tistos = TupleToolTISTOS("tistos")
tistos.VerboseL0 = 1
tistos.VerboseHlt1 = 1
from GaudiConf import IOHelper
from Configurables import DaVinci, DecayTreeTuple
from DecayTreeTuple.Configuration import *
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhCompleteEventPromptDst2D2RSLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi')
dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+]CC'
track_tool = dtt.addTupleTool('TupleToolTrackInfo')
track_tool.Verbose = True
dtt.addTupleTool('TupleToolPrimaries')
dtt.addBranches({
'Dstar': '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC',
'D0': '[D*(2010)+ -> ^(D0 -> K- pi+) pi+]CC',
'Kminus': '[D*(2010)+ -> (D0 -> ^K- pi+) pi+]CC',
'piplus': '[D*(2010)+ -> (D0 -> K- ^pi+) pi+]CC',
'pisoft': '[D*(2010)+ -> (D0 -> K- pi+) ^pi+]CC'
})
dtt.D0.addTupleTool('TupleToolPropertime')
# Configure DaVinci
DaVinci().UserAlgorithms += [dtt]
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
DaVinci().PrintFreq = 1000
def makeTuple(self):
"""
Make tuple
"""
from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool
tuple = DecayTreeTuple('Tuple'+self.name) # I can put as an argument a name if I use more than a DecayTreeTuple
tuple.Inputs = [ self.sequence.outputLocation() ]
tuple.Decay = self.dec
tuple.ToolList = ['TupleToolKinematic',
'TupleToolEventInfo',
'TupleToolTrackInfo',
'TupleToolPid',
'TupleToolGeometry',
'TupleToolAngles', # Helicity angle
# 'TupleToolPropertime', #proper time TAU of reco particles
]
tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary'
# Other event infos
tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt')
tuple.LoKi_Evt.VOID_Variables = {
#"nSPDHits" : " CONTAINS('Raw/Spd/Digits') " ,
'nTracks' : " CONTAINS ('Charm/Rec/Track/Best') " ,
}
# # Other variables
# tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All')
# tuple.LoKi_All.Variables = {
# 'BPVIPCHI2' : 'BPVIPCHI2()',
# 'BPVDIRA' : 'BPVDIRA',
# 'BPVLTFITCHI2' : 'BPVLTFITCHI2()',
# }
tuple.addBranches(self.branches)
tuple.phi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_phi")
tuple.phi.LoKi_phi.Variables = {
'DOCAMAX' : 'DOCAMAX',
"MassDiff_Phi" : "DMASS('phi(1020)')",
"BPVDIRA" : "BPVDIRA",
"IPS_Phi" : "MIPCHI2DV(PRIMARY)",
"VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)",
"VFASPF_CHI2" : "VFASPF(VCHI2)",
"BPVIPCHI2" : "BPVIPCHI2()",
"ADOCA" : "DOCA(1,2)",
"ADOCACHI2" : "DOCACHI2(1,2)",
"DTF_CHI2_PV" : "DTF_CHI2( True, 'phi(1020)' )",
"DTF_NDOF_PV" : "DTF_NDOF( True, 'phi(1020)' )",
"DTF_M_PV" : "DTF_FUN ( M, True, 'phi(1020)' )",
"DTF_M_Ks1_PV" : "DTF_FUN ( CHILD(M,1), True, 'phi(1020)' )",
"DTF_M_Ks2_PV" : "DTF_FUN ( CHILD(M,2), True, 'phi(1020)' )",
# "DTF_CTAU_Ks1" : "DTF_CTAU(1, False, 'phi(1020)' )",
# "DTF_CTAU_Ks2" : "DTF_CTAU(2, False, 'phi(1020)' )",
}
def mySharedConf_Ks(branch):
atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_Ks')
atool.Variables = {
"BPVDIRA" : "BPVDIRA",
"VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)",
"VFASPF_CHI2" : "VFASPF(VCHI2)",
"BPVIPCHI2" : "BPVIPCHI2()",
"BPVVD" : "BPVVD",
"BPVVDCHI2" : "BPVVDCHI2",
"ADOCA" : "DOCA(1,2)",
"ADOCACHI2" : "DOCACHI2(1,2)",
'BPVLTIME' : 'BPVLTIME()',
}
PropertimeTool = branch.addTupleTool("TupleToolPropertime/Propertime_Ks")
mySharedConf_Ks(tuple.Ks1)
mySharedConf_Ks(tuple.Ks2)
def mySharedConf_pi(branch):
atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_pi')
atool.Variables = {
'TRCHI2DOF' : 'TRCHI2DOF',
'TRGHOSTPROB' : 'TRGHOSTPROB',
}
mySharedConf_pi(tuple.pi1)
mySharedConf_pi(tuple.pi2)
mySharedConf_pi(tuple.pi3)
mySharedConf_pi(tuple.pi4)
# Triggers:
tuple.phi.addTupleTool('TupleToolTISTOS/TISTOS')
tuple.phi.TISTOS.TriggerList = trigger_list
tuple.phi.TISTOS.VerboseL0 = True
tuple.phi.TISTOS.VerboseHlt1 = True
tuple.phi.TISTOS.VerboseHlt2 = True
if dataSample.isMC:
from Configurables import MCDecayTreeTuple, MCTupleToolKinematic, TupleToolMCTruth, MCTupleToolHierarchy, MCTupleToolReconstructed, MCTupleToolAngles, TupleToolMCBackgroundInfo
tuple.addTupleTool('TupleToolMCTruth/MCTruth')
tuple.MCTruth.ToolList = ['MCTupleToolKinematic',
'MCTupleToolHierarchy',
'MCTupleToolReconstructed',
'MCTupleToolAngles',
]
tuple.phi.addTupleTool( "TupleToolMCBackgroundInfo")
self.sequence.sequence().Members += [tuple]
Location='/Event/Bhadron/Phys/B02D0PiPiD2HHBeauty2CharmLine/Particles')
_bmassFilter = FilterDesktop(
'bmassFilter', Code='(M<6000.*MeV) & (BPVIPCHI2()<15) & (BPVDIRA>0.9999)')
BMassFilterSel = Selection(name='BMassFilterSel',
Algorithm=_bmassFilter,
OutputBranch=teslocation + 'Phys',
RequiredSelections=[BMassSel])
BMassSeq = SelectionSequence('SeqBMass', TopSelection=BMassFilterSel)
BMassseq = BMassSeq.sequence()
### Tuple part
tuple = DecayTreeTuple()
tuple.RootInTES = teslocation
tuple.Inputs = ['Phys/BMassFilterSel/Particles']
#tuple.Inputs = [ '/Event/Bhadron/Phys/B02D0KPiD2HHBeauty2CharmLine/Particles' ]
tuple.ToolList += [
"TupleToolGeometry", "TupleToolRecoStats", "TupleToolKinematic",
"TupleToolPrimaries", "TupleToolEventInfo", "TupleToolTrackInfo",
"TupleToolAngles", "TupleToolPid", "TupleToolPropertime",
"TupleToolTrigger", "TupleToolRICHPid", "TupleToolMuonPid",
"TupleToolProtoPData"
]
tuple.addTool(TupleToolGeometry, name="TupleToolGeometry")
tuple.TupleToolGeometry.Verbose = True
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'"]
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 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"
def execute_option_file(path):
# ================= BEGIN EDIT AREA =======================
tuplename = "Bu2LLK_meLine"
simulation_inputstring = "/Event/AllStreams/Phys/Bu2LLK_meLine/Particles"
data_inputstring = "/Event/Leptonic/Phys/Bu2LLK_meLine/Particles"
decaydescriptor = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC"
branches = { # Dictionary for the branches to write in the tuple
"B" : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC",
"Psi" : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC",
"muplus" : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC",
"eminus" : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC",
"Kplus" : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC"
}
toollist = [ "TupleToolBremInfo" #Bremsstrahlung information
#, "TupleToolGeometry" #geometry of vertex locations (ENDVERTEX, OWNPV, IP_OWNPV, FD_OWNPV, DIRA_OWNPV)
, "TupleToolKinematic" #kinematic variables (inv. mass MM, kin. mass M/sqrt(E^2-p^2), P, PX/Y/Z/E, PT)
#, "TupleToolEventInfo" #Event information such as run number, polarity, GPS time etc.
#, "TupleToolPropertime" #proper lifetime of reconstructed particles
#, "TupleToolAngles" #decay angles of charged tracks
#, "TupleToolTrigger"
#, "TupleToolTrackInfo" #GhostProb of track and track type (TYPE) - 0 = unknown, 1 = velo track...
#, "TupleToolPrimaries" #Number and coordinates of all primary vertices
#, "TupleToolDira"
#, "TupleToolTrackPosition" #Plot the X/Y position at a given Z (default: 2500 = TTstation)
#, "TupleToolRecoStats"
#, "TupleToolIsolationTwoBody" #degree of isolation of two particles with common mother from Bsmumu
#, "TupleToolANNPID" #V2,V3,... ProbNN variables
#, "TupleToolCaloHypo"
#, "TupleToolL0Calo"
]
# ================= END EDIT AREA =======================
# ================= BEGIN DO NOT EDIT HERE =======================
from Configurables import GaudiSequencer
MySequencer = GaudiSequencer('Sequence')
#Check whether it is a DST or MDST file
import os.path
extension = os.path.splitext(path)[1]
print extension
if extension.lower() == ".dst":
DaVinci().InputType = 'DST'
elif extension.lower() == ".mdst":
DaVinci().InputType = 'MDST'
else:
raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path))
#Kill some nodes if micro dst-file
if DaVinci().InputType == 'MDST':
from Configurables import EventNodeKiller
eventNodeKiller = EventNodeKiller('DAQkiller')
eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec']
MySequencer.Members+=[eventNodeKiller]
#DecayTreeTuple -> Fills information about particles, vertices and daughters
ntuple = DecayTreeTuple(tuplename)
if DaVinci().Simulation is True: # for MC
ntuple.Inputs = [simulation_inputstring]
elif DaVinci().Simulation is False: # for Tuple
ntuple.Inputs = [data_inputstring]
else:
raise Exception(" `DaVinci().Simulation` not set.")
ntuple.Decay = decaydescriptor
ntuple.addBranches(branches)
ntuple.TupleName = "DecayTree"
#Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used
ntuple.ToolList = toollist
MySequencer.Members.append(ntuple)
# ================= END DO NOT EDIT HERE =======================
if DaVinci().Simulation is True:
from Configurables import BackgroundCategory
backgroundinfo = ntuple.addTupleTool("TupleToolMCBackgroundInfo") #Fills the background category
backgroundinfo.addTool(BackgroundCategory('BackgroundCategory'))
backgroundinfo.BackgroundCategory.SoftPhotonCut = 100000000000. #Ignores all photons
MCTruth=ntuple.addTupleTool("TupleToolMCTruth") #Saves information of MC particle associated to the current particle (you can add tools to it itself!)
MCTruth.addTupleTool("MCTupleToolHierarchy") #True IDs of mother and grandmother particles
# ================= BEGIN EDIT TUPLETOOLS WITH OPTIONS ==================
# LOKI TupleTool
LoKi = ntuple.addTupleTool("LoKi::Hybrid::TupleTool")
LoKi.Variables = {
"ETA" : "ETA",
"PHI" : "PHI" #Azimuthal angle
}
#Track isolation
if(False):
if DaVinci().InputType != 'MDST':
ntuple.ToolList += ["TupleToolTrackIsolation"]
# PID TupleTool
if(True):
pid = ntuple.addTupleTool("TupleToolPid") #PID information for charged particles
pid.Verbose = True #More information like isMuonLoose etc.
#TISTOS TupleTool
if(False):
from Configurables import TupleToolTISTOS
L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ]
## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi']
Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"]
Hlt2Triggers = [
## muon lines
"Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision",
"Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision",
"Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision",
"Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision",
## hadron/Topo lines
"Hlt2B2HHDecision",
"Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision",
"Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision",
"Hlt2TopoE2BodyBBDTDecision", "Hlt2TopoE3BodyBBDTDecision", "Hlt2TopoE4BodyBBDTDecision",
"Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision",
##others
"Hlt2PassThroughDecision",
"Hlt2TransparentDecision",
## inclusive decisions
"Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision"
]
triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers
ntuple.addTupleTool("TupleToolTISTOS")
ntuple.TupleToolTISTOS.VerboseL0 = True
ntuple.TupleToolTISTOS.VerboseHlt1 = True
ntuple.TupleToolTISTOS.VerboseHlt2 = True
ntuple.TupleToolTISTOS.FillL0 = True
ntuple.TupleToolTISTOS.FillHlt1 = True
ntuple.TupleToolTISTOS.FillHlt2 = True
ntuple.TupleToolTISTOS.OutputLevel = INFO
ntuple.TupleToolTISTOS.TriggerList = triggerList
#DecayTreeFitter
if(False):
fitter = ntuple.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI")
fitter.constrainToOriginVertex = False
fitter.daughtersToConstrain = [ "J/psi(1S)" ]
fitter.Verbose = True
#Isolation tool from Alex
weightsfolder = "./"
if(False):
from Configurables import TupleToolApplyIsolation
ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard")
ntuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard"
ntuple.B.TupleToolApplyIsolationHard.WeightsFile= weightsfolder+"weightsHard.xml"
ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft")
ntuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft"
ntuple.B.TupleToolApplyIsolationSoft.WeightsFile= weightsfolder+"weightsSoft.xml"
ntuple.B.addTupleTool("TupleToolVtxIsoln")
#ntuple.B.TupleToolApplyIsolationHard.OutputLevel = 3
#ntuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3
#Tool from B2ee
if(False):
from Configurables import TupleToolMuonVariables
ntuple.addTupleTool("TupleToolMuonVariables")
if DaVinci().InputType == 'MDST':
ntuple.TupleToolMuonVariables.TrackContainer = "/Event/Leptonic/Rec/Track/Best" #Change in case of MDST!
ntuple.TupleToolMuonVariables.BDTSRootFile = weightsfolder+"HflatBDTS_7Dec.root"
ntuple.TupleToolMuonVariables.BDTSXMLFile = weightsfolder+"TMVA_7Dec.weights.xml"
#Settings for TupleToolTrackHits (some only are necessary for MDST-files because of other locations of the clusters)
if(True): #Change this value if you don't want to use this tool
from Configurables import TupleToolTrackHits, STOfflinePosition
trackhits = ntuple.addTupleTool("TupleToolTrackHits")
trackhits.Verbose = True
if DaVinci().InputType == 'MDST':
from Configurables import MeasurementProvider
ntuple.addTool(MeasurementProvider('MeasProvider'))
ntuple.MeasProvider.RootInTES = "/Event/Leptonic/" #Change Leptonic for your stream-name in case of MDST
trackhits.MeasurementProvider = ntuple.MeasProvider
itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels
itClusterPosition.DetType = 'IT'
#Settings for TupleToolAllPhotons (only works for fullDST files)
#Should be always added to only one branch
if(DaVinci().InputType == 'DST'):
if(True):
from Configurables import TupleToolAllPhotons, STOfflinePosition
allphotons = ntuple.eminus.addTupleTool("TupleToolAllPhotons")
allphotons.MCTruth = True
allphotons.PhotonsLocation = "/Event/Phys/StdVeryLooseAllPhotons/Particles"
itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels
itClusterPosition.DetType = 'IT'
#allphotons.PhotonsLocation = "/Event/Phys/StdLooseAllPhotons/Particles"
#Settings for TupleToolBremRemover
#Should be always added to specific branches
if(True):
from Configurables import TupleToolBremRemover
bremremover = ntuple.eminus.addTupleTool("TupleToolBremRemover")
if DaVinci().Simulation is True:
bremremover.TRUEP = True
#TupleToolTrackKink: Refits the track and outputs kink as point with highest Chi2 variation (should be run last because of the refit)
if(False):
ntuple.eminus.addTupleTool("TupleToolTrackKink")
# ================= END EDIT TUPLETOOLS WITH OPTIONS ==================
################################
### DaVinci configuration ####
################################
DaVinci().UserAlgorithms = [MySequencer]
DaVinci().MoniSequence += [ntuple]
DaVinci().EvtMax = -1
DaVinci().SkipEvents = 0
DaVinci().Lumi = True
}
LoKi_psi = LoKi__Hybrid__TupleTool("LoKi_psi")
LoKi_psi.Variables = {
"q_PV_constr_B_constr" : "DTF_FUN ( M , True , 'B+' )" ,
"q_PV_constr" : "DTF_FUN ( M , True )" ,
"q_B_constr" : "DTF_FUN ( M , False , 'B+' )" ,
"q_no_constr" : "DTF_FUN ( M , False )" ,
}
LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables = {
"NSHAREDMU" : "NSHAREDMU"
}
tuple_B2Kmumu = DecayTreeTuple("Tuple_B2Kmumu")
tuple_B2Kmumu.Inputs = [ location ]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC'
tuple_B2Kmumu.Branches = {
"B" : "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC",
"Kplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC",
"psi" : "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC",
"muplus" : "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC",
"muminus": "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC",
}
for particle in ["B", "Kplus", "psi", "muplus", "muminus"]:
tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)
# List of the reconstructed tuples
tuples = [ tuple_B2Kmumu
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()"
B2EtapKSel = Selection("B2EtapKSel", Algorithm = SubKToPi, RequiredSelections = [B2etap_piSub])
#B2EtapKSeq = SelectionSequence("B2EtapKSeq", TopSelection = B2EtapKSel)
#Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.) & (PT> 1500.*MeV)"
B2EtapKFil= FilterDesktop("B2EtapKFil", Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.)")# & (PT> 1500.*MeV)")
B2EtapKFil_Sel= Selection('B2EtapKFil_Sel', Algorithm=B2EtapKFil, RequiredSelections=[B2EtapKSel])
B2EtapKFil_Seq = SelectionSequence("B2etap_pi_FilSeq", TopSelection =B2EtapKFil_Sel)
# Fill Tuple
from Configurables import DecayTreeTuple
tuple = DecayTreeTuple("B2_ETAPK")
tuple.ToolList += [
"TupleToolGeometry",
"TupleToolPhotonInfo",
"TupleToolPid",
"TupleToolMCTruth",
"TupleToolRICHPid",
"TupleToolKinematic",
"TupleToolPrimaries",
"TupleToolEventInfo",
"TupleToolTrackInfo",
"TupleToolAngles",
"TupleToolPropertime",
"TupleToolVtxIsoln",
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'
seq = SeqFilterL.sequence()
#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci
# DaVinci().appendToMainSequence( [sc.sequence() ] ) # Append the stripping selection sequence to DaVinci
from Configurables import OfflineVertexFitter
from Configurables import DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTreeMC.py")
tuple = DecayTreeTuple( "L2ppiTree" )
tuple.Inputs = [ SeqFilterL.outputLocation() ]
# from PhysConf.Filters import LoKi_Filters #!
# fltrs = LoKi_Filters(STRIP_Code = "(HLT_PASS_RE('StrippingFullDSTDiMuonJpsi2MuMuDetachedLineDecision'))" ) #!
from Configurables import DaVinci #!
DaVinci().Simulation = True
DaVinci().EvtMax = -1 # Number of events
#DaVinci().EventPreFilters = fltrs.filters('Filter') #!
DaVinci().UserAlgorithms = [ seq, tuple ]
from Configurables import CondDB #!
DaVinci().DataType = "2012"
DaVinci().DDDBtag = "Sim08-20130503-1" #!
"LOKI_MASS_JpsiConstr": "DTF_FUN ( M , False , 'J/psi(1S)' )",
"LOKI_DTF_VCHI2NDOF": "DTF_FUN ( VFASPF(VCHI2/VDOF) , True )",
}
LoKi_psi = LoKi__Hybrid__TupleTool("LoKi_psi")
LoKi_psi.Variables = {
"q_PV_constr_B_constr": "DTF_FUN ( M , True , 'B+' )",
"q_PV_constr": "DTF_FUN ( M , True )",
"q_B_constr": "DTF_FUN ( M , False , 'B+' )",
"q_no_constr": "DTF_FUN ( M , False )",
}
LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables = {"NSHAREDMU": "NSHAREDMU"}
tuple_B2Kmumu = DecayTreeTuple("Tuple_B2Kmumu")
tuple_B2Kmumu.Inputs = [location]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC'
tuple_B2Kmumu.Branches = {
"B": "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC",
"Kplus": "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC",
"psi": "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC",
"muplus": "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC",
"muminus": "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC",
}
for particle in ["B", "Kplus", "psi", "muplus", "muminus"]:
tuple_B2Kmumu.addTool(TupleToolDecay, name=particle)
# List of the reconstructed tuples
tuples = [tuple_B2Kmumu]
def addTuple(name="", decay="", addendum="", head="/Event/Phys/", dtf=True, resonant=True, shortname="", verbose=[] ):
from Configurables import DecayTreeTuple, PrintDecayTree, FilterDesktop, GaudiSequencer, PrintHeader, TESCheck
if shortname == "": shortname = name
shortname = shortname+"_Tuple"+addendum
shortname = shortname.replace("MCMC","MC")
seq = GaudiSequencer("Seq"+shortname)
if ( not "/"==head[-1] ): head = head+'/'
location = head+name+"/Particles"
from Configurables import LoKi__HDRFilter
if ( "/Event/Phys/" == head ):
filter = TESCheck("Check"+shortname,Inputs = [ location ], 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" )
#filter.OutputLevel = 1
seq.Members += [ filter ] # PrintHeader(),
tuple = DecayTreeTuple(shortname)
isMDST = (addendum.upper()=="MDST")
if (isMDST):
RIT = head.replace("/Phys","")
print "RootInTES set to", RIT
tuple.RootInTES = RIT
tuple.Inputs = [ "Phys/"+name+"/Particles" ]
else :
tuple.Inputs = [ location ]
# tuple.OutputLevel = 1
tuple.ToolList = []
tuple.Decay = decay
tg = tuple.addTupleTool("TupleToolGeometry")
if not isMDST: tg.FillMultiPV = True
tlist = []
if ("e+" in decay):
tlist = electronLines()
elif ("mu+" in decay):
tlist = muonLines()
if ( False ):
tlist = allLines()
print tlist
if ( 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)
Psi = tuple.addTupleTool("TupleToolDecay/Psi")
Psi.addTool(tistos)
Psi.ToolList += [ "TupleToolTISTOS" ]
# if (not isMDST):
# vi = tuple.Psi.addTupleTool("TupleToolVtxIsoln")
# vi.InputParticles = [ "/Event/Phys/MyGoodPions" ]
if ( Jpsi2MuMu == decay ):
if (dtf):
pvfit = tuple.Psi.addTupleTool("TupleToolDecayTreeFitter/PVFit") # fit with all constraints I can think of
pvfit.Verbose = True
pvfit.constrainToOriginVertex = True
else:
B = tuple.addTupleTool("TupleToolDecay/B")
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 ('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 (('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
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" ]
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)
tuple.addTupleTool("TupleToolPrimaries")
ti = tuple.addTupleTool("TupleToolTrackInfo")
ti.Verbose = ("TrackInfo" in verbose) # gives many more chi2
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
pid = tuple.addTupleTool("TupleToolPid")
pid.Verbose = ("Pid" in verbose) # many more vars in RICH
if ("Pid" in verbose) :
tuple.addTupleTool("TupleToolANNPID")
tuple.addTupleTool("TupleToolL0Calo")
if ('e+' in decay):
brem = tuple.addTupleTool("TupleToolBremInfo")
#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 ( "/Event/Phys/" == head): # not reading stripping output
tts = tuple.addTupleTool("TupleToolStripping")
tuple.addTupleTool("TupleToolPhotonInfo")
tuple.addTupleTool("TupleToolPi0Info")
# tuple.OutputLevel = 1
if ( addendum == "MC" ): # it's MC!
tmc = tuple.addTupleTool("TupleToolMCTruth")
#tmc.addTupleTool("MCTupleToolKinematic")
tmc.addTupleTool("MCTupleToolHierarchy")
tuple.addTupleTool("TupleToolMCBackgroundInfo")
if (isMDST):
seq.Members += [ #PrintDecayTree( Inputs = [ location]),
EventNodeKiller(Nodes=["DAQ"] ) ]
if ( addendum == "MC" ): # it's not MC!
from Configurables import TrackSmearState as SMEAR
smear = SMEAR()
# seq.Members += [ smear ]
elif (not isMDST): # it's not mdst
from Configurables import TrackScaleState as SCALER
scaler = SCALER('StateScale')
# seq.Members += [ scaler ]
seq.Members += [ # PrintDecayTree( Inputs = [ location]),
tuple ]
return [ seq ]
from GaudiConf import IOHelper
from Configurables import (
DaVinci,
DecayTreeTuple,
)
from DecayTreeTuple.Configuration import *
# 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'
# add a kinematic fitter
dtt.addBranches({
'Dstar': '[D*(2010)+ -> (D0 -> K- K+) pi+]CC',
})
dtt.Dstar.addTupleTool('TupleToolDecayTreeFitter/ConsD')
dtt.Dstar.ConsD.constrainToOriginVertex = True
dtt.Dstar.ConsD.Verbose = True
dtt.Dstar.ConsD.daughtersToConstrain = ['D0']
# add another fitter, this time we will change a mass hypothesis
dtt.Dstar.addTupleTool('TupleToolDecayTreeFitter/ConsDKpi')
dtt.Dstar.ConsDKpi.constrainToOriginVertex = True
dtt.Dstar.ConsDKpi.Verbose = True
dtt.Dstar.ConsDKpi.daughtersToConstrain = ['D0']
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"
from Configurables import TupleToolPropertime, DecayTreeTuple, TupleToolTISTOS, TupleToolDecayTreeFitter
tupleNames = 'Dst2010ToD0ToKpipipipiTuple', 'Dst2010ToD0ToKKKpipiTuple', \
'Dst2010ToD0TopipipipipiTuple', 'Dst2010ToD0ToKKpipipiTuple'
for tupleName in tupleNames :
TupleToolPropertime(tupleName + '.TupleToolPropertime').FitToPV = True
dtt = DecayTreeTuple(tupleName)
#dtt.lab0.setName('Dstar')
#dtt.Branches['Dstar'] = dtt.Branches['lab0']
#del dtt.Branches['lab0']
dtt.addBranches({'D0' : dtt.Decay.replace('^', '').replace('(D0', '^(D0')})
tt_tistos = filter(lambda tool : tool.__class__.__name__ == 'TupleToolTISTOS', dtt.lab0.getTools())[0]
dtt.D0.addTupleTool(TupleToolTISTOS('D0_TISTOS', TriggerList = tt_tistos.TriggerList,
Verbose = True, VerboseL0 = True, VerboseHlt1 = True,
VerboseHlt2 = True))
ttdtf = dtt.lab0.addTupleTool(TupleToolDecayTreeFitter('tt_dtf'))
ttdtf.Verbose = True
ttdtfvtx = dtt.lab0.addTupleTool(TupleToolDecayTreeFitter('tt_dtf_vtx'))
ttdtfvtx.Verbose = True
ttdtfvtx.constrainToOriginVertex = True
##############################################################################################
##### 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.
Ds_sequence = SelectionSequence('SeqDs2PhiPi',
TopSelection = Ds_Sel
)
#This filter is used just to speed up the process, nothing happens if there
# # is no stripped candidates at that location.
# from PhysConf.Filters import LoKi_Filters
# fltrs = LoKi_Filters(
# STRIP_Code = "HLT_PASS('StrippingPhiToKSKS_PhiToKsKsLineDecision')")
from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool
from Configurables import LoKi__LifetimeFitter
tuple = DecayTreeTuple("TuplePhi2KsKs")
#Give DecayTreeTuple the location of your stripped candidates
#If you apply a selection, this will be the output of a selection sequence object.
tuple.Inputs = [Ds_sequence.outputLocation()]
tuple.ToolList = ['TupleToolKinematic',
'TupleToolEventInfo',
'TupleToolTrackInfo',
'TupleToolPid',
'TupleToolGeometry',
'TupleToolAngles',
]
tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary'
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 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-)"})
########################################################################
#
# J/psi n-tuple
#
# @author Bilas Pal
# @date 2010-11-01
######
########################################################################
from Gaudi.Configuration import *
#
# DecayTreeTuple
#
from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolTagging, MCDecayTreeTuple
from Configurables import FitDecayTrees, TupleToolGeometry
tuple = DecayTreeTuple('Lb2JpsiLTree')
tuple.Inputs = [ 'Phys/Bs2Jpsif0' ]
tuple.TupleName = "mytree"
tuple.ToolList = [
"TupleToolGeometry",
"TupleToolKinematic",
"TupleToolEventInfo",
# "TupleToolTISTOS",
"TupleToolPid",
"TupleToolTrackInfo",
# "TupleToolTagging"
]
tistos = TupleToolTISTOS("tistos")
tistos.VerboseL0 = 1
tistos.VerboseHlt1 = 1
# 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",
TupleToolPropertime,
PropertimeFitter,
TupleToolKinematic,
TupleToolGeometry,
TupleToolEventInfo,
TupleToolPrimaries,
TupleToolPid,
TupleToolTrackInfo,
TupleToolRecoStats,
TupleToolMCTruth,
LoKi__Hybrid__TupleTool,
LoKi__Hybrid__EvtTupleTool,
)
tuple = DecayTreeTuple("TupleJPsi2KsKs")
# Give DecayTreeTuple the location of your stripped candidates
# If you apply a selection, this will be the output of a selection sequence object.
tuple.Inputs = [seq.outputLocation()]
tuple.ToolList = [
"TupleToolKinematic",
"TupleToolEventInfo",
"TupleToolTrackInfo",
"TupleToolPid",
"TupleToolGeometry",
"TupleToolAngles",
]
tuple.InputPrimaryVertices = "/Event/Charm/Rec/Vertex/Primary"
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
# 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)] #Phys/{0}/Particles'.format(line)] # for microDST
#dtt.Decay = '[D*(2010)+ -> (D0 -> K- K+) pi+]CC' # written like this means tuple tools only runs on the D*(2010)+, to select particles to store information on mark them with a ^, e.g.:
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^K+) ^pi+]CC' # but this not ideal as we may only want to run some tools on D and some on children, use Branches below
# CC means "and also equivalent C conjugated decay" ?
# Additional tuple tools:
track_tool = dtt.addTupleTool('TupleToolTrackInfo')
# Only need to store a tool in a variable if you want to configure it:
track_tool.Verbose = True # 'Verbose' - further information
dtt.addTupleTool('TupleToolPrimaries')
dtt.addBranches({'Dstar' :'[D*(2010)+ -> (D0 -> K- K+) pi+]CC',
'D0' :'[D*(2010)+ -> ^(D0 -> K- K+) pi+]CC',
'Kminus' :'[D*(2010)+ -> (D0 -> ^K- K+) pi+]CC',
'Kplus' :'[D*(2010)+ -> (D0 -> K- ^K+) pi+]CC',
'pisoft' :'[D*(2010)+ -> (D0 -> K- K+) ^pi+]CC'}) # and mark particles which we want to use in dtt.Decay (with ^ ?)!!
# Alternativley, use setDescriptorTemplate() to do all this in one line:
#dtt.setDescriptorTemplate('${Dstar}[D*(2010)+ -> ${D0}(D0 -> ${Kminus}K- ${Kplus}K+) ${pisoft}pi+]CC') # sets up both dtt.Decay and Branches
# Access branches with dtt.PARTICLENAME
dtt.D0.addTupleTool('TupleToolPropertime') # e.g. of adding tuple tools to specific particles
'''
All tuple tools start with DecayTreeTuple here: https://gitlab.cern.ch/lhcb/Analysis/tree/master/Phys
DecayTreeTuple for the more general tools;
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"))
sc.appendStream( sstream )
Strip_Location1 = stripline.outputLocation()
print Strip_Location1
StripSel1 = AutomaticData(Location = Strip_Location1)
print StripSel1
print "ALL OK"
rootintes = "/Event/AllStreams"
#---------------------------
# Run fixing XmumuLine
#---------------------------
from Configurables import NeutrinoBuildTupleTool, PromptNeutrinoTupleTool
tuple = DecayTreeTuple('PromptNeutrinoTupleTool')
tuple.OutputLevel = INFO
stream = 'AllStreams'
stripping_line = 'B2XMuMu_Line'
tuple.Inputs = [StripSel1.outputLocation()]
tuple.Decay = "[B+ -> ^( J/psi(1S) -> ^mu- ^mu+ ) ^pi+]CC"
tuple.addBranches({
"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",
})
'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'
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 = {
#to run DaVinci:
#lb-run DaVinci/v41r2 gaudirun.py myopt_davinci.py
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhCompleteEventPromptDst2D2RSLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi')
#dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)]
dtt.Inputs = [
'/Event/AllStreams/Phys/D2hhCompleteEventPromptDst2D2RSLine/Particles'
]
dtt.Decay = '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC'
from Configurables import DaVinci
# Configure DaVinci
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
#DaVinci().PrintFreq = 1000
DaVinci().PrintFreq = 100
DaVinci().DataType = '2012'
DaVinci().Simulation = True
# Only ask for luminosity information when not using simulated data
DaVinci().Lumi = not DaVinci().Simulation
#DaVinci().EvtMax = -1
DaVinci().EvtMax = 300
DaVinci().CondDBtag = 'sim-20130522-1-vc-md100'
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)",
_SubstituteB0 = SubstitutePID ( name = "_SubstituteB0",
Code = " DECTREE('B0 -> (phi(1020) -> K+ K-) (rho(770)0 -> pi+ pi-)') " ,
Substitutions = {'Beauty -> (phi(1020) -> K+ K-) ^(rho(770)0 -> X+ X-)' : 'phi(1020)',
'Beauty -> (phi(1020) -> K+ K-) (X0 -> ^pi+ X-)' : 'K+',
'Beauty -> (phi(1020) -> K+ K-) (X0 -> X+ ^pi-)' : 'K-',
'Beauty -> (phi(1020) -> K+ K-) (X0 -> X+ X-)' : 'B_s0'})
_ddChangeSel = Selection( "_ddChangeSel",
Algorithm = _SubstituteB0,
RequiredSelections = [_strippingOutput]) #[DataOnDemand(Location = "/Event/AllStreams/Phys/BsPhiRhoLine/Particles")])
selSeq = Selection("selSeq",
Algorithm = FilterDesktop("BsPhiRhoFilter", Code = newDecay),
RequiredSelections = [_ddChangeSel])
# selSeq = SelectionSequence("selseqname", TopSelection = _ddChangeSel)
tuple = DecayTreeTuple()
if not IsMC:
tuple.Inputs = [ "/Event/Bhadron/Phys/BsPhiRhoLine/Particles" ]
elif not myDecayType and IsMC:
tuple.Inputs = [ "/Event/AllStreams/Phys/BsPhiRhoLine/Particles" ]
elif myDecayType and IsMC:
tuple.Inputs = [ '/Event/Phys/selSeq/Particles' ]
# tuple.Inputs = [ selSeq.outputLocation() ]
tuple.ToolList += [
# "TupleToolMCTruth",
"TupleToolMCBackgroundInfo",
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPropertime"
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/Leptonic/Phys/Bu2LLK_eeLine/Particles"]
tuple.ToolList = [
"TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
, "TupleBuKmmFit"
]
tuple.addBranches ({
"Bplus" : "[B+ -> K+ ( J/psi(1S) -> e+ e-)]CC",
"Kplus" : "[B+ -> ^K+ ( J/psi(1S) -> e+ e-)]CC",
"Jpsi" : "[B+ -> K+ (^J/psi(1S) -> e+ e-)]CC",
"muplus" : "[B+ -> K+ ( J/psi(1S) -> ^e+ e-)]CC",
"muminus" : "[B+ -> K+ ( J/psi(1S) -> e+ ^e-)]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()"
line = 'D2hhCompleteEventPromptDst2D2RSLine'
# Create the actual Stripping configurable
filterBadEvents = ProcStatusCheck()
sc = StrippingConf(Streams=[custom_stream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=filterBadEvents)
# The output is placed directly into Phys, so we only need to
# define the stripping line here
line = 'D2hhCompleteEventPromptDst2D2RSLine'
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi')
dtt.Inputs = ['/Event/Phys/{0}/Particles'.format(line)]
dtt.Decay = '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC'
# Configure DaVinci
# Important: The selection sequence needs to be inserted into
# the Gaudi sequence for the stripping to run
DaVinci().appendToMainSequence([event_node_killer, sc.sequence()])
DaVinci().UserAlgorithms += [dtt]
DaVinci().InputType = 'DST'
DaVinci().TupleFile = 'DVntuple.root'
DaVinci().PrintFreq = 1000
DaVinci().DataType = '2012'
DaVinci().Simulation = True
# Only ask for luminosity information when not using simulated data
"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"
DecayDescriptor='[D*(2010)+ -> D0 pi+]cc',
DaughtersCuts=dstar_decay_products,
CombinationCut=dstar_comb,
MotherCut=dstar_mother
)
dstar_sel = Selection(
'Sel_Dstar',
Algorithm=dstar,
RequiredSelections=[d0_sel, Pions]
)
dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel)
# Create an ntuple
dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK')
dtt.Inputs = dstar_seq.outputLocations()
dtt.Decay = '[D*(2010)+ -> ^D0 ^pi+]CC'
DaVinci().UserAlgorithms += [dstar_seq.sequence(), dtt]
# DaVinci configuration
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 = 1000
"DIRA" : "BPVDIRA",
"DTF_CTAU" : "DTF_CTAU( 0, True )",
"DTF_CTAUS" : "DTF_CTAUSIGNIFICANCE( 0, True )",
"DTF_CHI2NDOF" : "DTF_CHI2NDOF( True )",
"DTF_CTAUERR" : "DTF_CTAUERR( 0, True )",
"DTF_MASS_constr1" : "DTF_FUN ( M , True , strings(['J/psi(1S)']) )" ,
"DTF_MASS_constr2" : "DTF_FUN ( M , True , strings(['psi(2S)']) )" ,
"DTF_VCHI2NDOF" : "DTF_FUN ( VFASPF(VCHI2/VDOF) , True )",
}
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 = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^pi0)]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" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ ^mu-) gamma) p+ K-]CC",
"proton" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) ^p+ K-]CC",
"kaon" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ ^K-]CC",
}
for particle in ["Lambda_b0", "chi_c", "Jpsi", "gamma", "muplus", "muminus", "proton", "kaon"]:
tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)
#
# Configure the dst writers for the output
#
enablePacking = True
from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass
from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter
from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid
from Configurables import TupleToolANNPID
from DecayTreeTuple.Configuration import *
tupleB = DecayTreeTuple("bae-"+tuplename+"-mc")
tupleB.Inputs = ["Phys/B2KLLXInclusive_InclKLLLine_NoHadronPID/Particles"]
#decay = ""
if LeptonType == "Muons" :
decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
tupleB.addBranches ({
"Kplus" : "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC",
"Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC",
"lplus" : "[B+ -> K+ (J/psi(1S) -> ^mu+ mu-)]CC",
"lminus" : "[B+ -> K+ (J/psi(1S) -> mu+ ^mu-)]CC",
"Bplus" : "[B+ -> K+ J/psi(1S)]CC",
})
### Gaudi sequence
SeqLb2JpsiS = SelectionSequence("SeqLb2JpsiS", TopSelection = Lb2JpsiS)
seq = SeqLb2JpsiS.sequence()
#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci
from Configurables import OfflineVertexFitter
from Configurables import DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTree.py")
tuple = DecayTreeTuple( "Lb2JpsiSTree" )
tuple.Inputs = [ SeqLb2JpsiS.outputLocation() ]
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(STRIP_Code = "(HLT_PASS_RE('StrippingFullDSTDiMuonJpsi2MuMuDetachedLineDecision'))" )
from Configurables import DaVinci
DaVinci().Simulation = False
DaVinci().EvtMax = -1 # Number of events
DaVinci().EventPreFilters = fltrs.filters('Filter')
DaVinci().UserAlgorithms = [ seq, tuple ]
from Configurables import CondDB
#CondDB(UseOracle = True)
#importOptions("$APPCONFIGOPTS/DisableLFC.py")
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",
"PX_proton_constr1" : "DTF_FUN ( CHILD(PX, 2) , True , strings(['J/psi(1S)']) )",
"PY_proton_constr1" : "DTF_FUN ( CHILD(PY, 2) , True , strings(['J/psi(1S)']) )",
"PZ_proton_constr1" : "DTF_FUN ( CHILD(PZ, 2) , True , strings(['J/psi(1S)']) )",
"PE_proton_constr1" : "DTF_FUN ( CHILD( E, 2) , True , strings(['J/psi(1S)']) )",
"PX_kaon_constr1" : "DTF_FUN ( CHILD(PX, 3) , True , strings(['J/psi(1S)']) )",
"PY_kaon_constr1" : "DTF_FUN ( CHILD(PY, 3) , True , strings(['J/psi(1S)']) )",
"PZ_kaon_constr1" : "DTF_FUN ( CHILD(PZ, 3) , True , strings(['J/psi(1S)']) )",
"PE_kaon_constr1" : "DTF_FUN ( CHILD( E, 3) , True , strings(['J/psi(1S)']) )",
}
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 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^p+ ^K-]CC'
tuple_B2Kmumu.Branches = {
"Lambda_b0" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) p+ K-]CC",
"Jpsi" : "[Lambda_b0 -> ^(J/psi(1S) -> mu+ mu-) p+ K-]CC",
"muplus" : "[Lambda_b0 -> (J/psi(1S) -> ^mu+ mu-) p+ K-]CC",
"muminus" : "[Lambda_b0 -> (J/psi(1S) -> mu+ ^mu-) p+ K-]CC",
"proton" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) ^p+ K-]CC",
"kaon" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) p+ ^K-]CC",
}
for particle in ["Lambda_b0", "Jpsi", "muplus", "muminus", "proton", "kaon"]:
tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)
# List of the reconstructed tuples
# Stripping 21r1:
# Phys/D2XMuMu_KOSLine/Particles
# Phys/D2XMuMu_KSSLine/Particles
# Source: http://lhcb-release-area.web.cern.ch/LHCb-release-area/DOC/stripping/config/stripping21/index.html#charm
rootInTes = "/Event/AllStreams"
#----------------------------------------
# 1) The code that makes the ntuple
#----------------------------------------
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"
def execute_option_file(path):
from Configurables import GaudiSequencer
MySequencer = GaudiSequencer('Sequence')
#Check whether it is a DST or MDST file
import os.path
extension = os.path.splitext(path)[1]
print extension
if extension.lower() == ".dst":
DaVinci().InputType = 'DST'
elif extension.lower() == ".mdst":
DaVinci().InputType = 'MDST'
else:
raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path))
#Kill some nodes if micro dst-file
if DaVinci().InputType == 'MDST':
from Configurables import EventNodeKiller
eventNodeKiller = EventNodeKiller('DAQkiller')
eventNodeKiller.Nodes = ['DAQ','pRec']
MySequencer.Members+=[eventNodeKiller]
#DecayTreeTuple
data = DecayTreeTuple('Bu2LLK_mmLine')
data.ToolList = [
"TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolPropertime"
, "TupleToolTrigger"
, "TupleToolTISTOS"
, "TupleToolPid"
, "TupleToolTrackInfo"
, "TupleToolPrimaries"
, "TupleToolDira"
, "TupleToolTrackPosition"
, "TupleToolRecoStats"
]
if DaVinci().InputType != 'MDST':
data.ToolList += ["TupleToolTrackIsolation"]
if DaVinci().Simulation is True:
data.ToolList +=[
"TupleToolMCBackgroundInfo"
, "TupleToolMCTruth"
]
L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ]
## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi']
Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"]
Hlt2Triggers = [
## muon lines
"Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision",
"Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision",
"Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision",
"Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision",
## hadron/Topo lines
"Hlt2B2HHDecision",
"Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision",
"Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision",
"Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision",
##others
"Hlt2PassThroughDecision",
"Hlt2TransparentDecision",
## inclusive decisions
"Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision"
]
triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers
data.addTool(TupleToolTISTOS)
data.TupleToolTISTOS.VerboseL0 = True
data.TupleToolTISTOS.VerboseHlt1 = True
data.TupleToolTISTOS.VerboseHlt2 = True
data.TupleToolTISTOS.FillL0 = True
data.TupleToolTISTOS.FillHlt1 = True
data.TupleToolTISTOS.FillHlt2 = True
data.TupleToolTISTOS.OutputLevel = INFO
data.TupleToolTISTOS.TriggerList = triggerList
if DaVinci().Simulation is True: # for MC
data.Inputs = ["/Event/AllStreams/Phys/Bu2LLK_mmLine/Particles"]
elif DaVinci().Simulation is False: # for Tuple
data.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_mmLine/Particles"]
else:
raise Exception(" `DaVinci().Simulation` not set.")
data.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
data.addBranches({
"B" : "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC",
"Psi" : "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC",
"muplus" : "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC",
"muminus" : "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC",
"Kplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC"
})
data.TupleName = "DecayTree"
#DecayTreeFitter
fitter = data.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI")
fitter.constrainToOriginVertex = False
fitter.daughtersToConstrain = [ "J/psi(1S)" ]
fitter.Verbose = True
#Isolation
data.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard")
data.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard"
data.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml"
data.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"]
data.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft")
data.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft"
data.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml"
data.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"]
vtxiso = data.B.addTupleTool("TupleToolVtxIsoln")
#data.B.TupleToolApplyIsolationHard.OutputLevel = 3
#data.B.TupleToolApplyIsolationSoft.OutputLevel = 3
MySequencer.Members.append(data)
#EventTuple for simulation
"""
if DaVinci().Simulation is True:
etuple = EventTuple()
etuple.ToolList=["TupleToolEventInfo"]
MySequencer.Members.append(etuple)
"""
#DDDB and CondDB-Tags for DATA (needs to be set for Simulation in runfile.py according to generation->see bookkeeping!)
#Always use the latest tags for the given datatype from (the newest are currently not in the database yet, therefore take the default ones!)
"""
if DaVinci().Simulation is False:
if DaVinci().DataType == '2012':
DaVinci().CondDBtag = "dddb-20150522-2"
DaVinci().DDDBtag = "cond-20150409-1"
elif DaVinci().DataType == '2011':
DaVinci().CondDBtag = "dddb-20150522-1"
DaVinci().DDDBtag = "cond-20150409"
"""
################################
### DaVinci configuration ####
################################
DaVinci().UserAlgorithms = [MySequencer]
DaVinci().MoniSequence += [data]
DaVinci().EvtMax = -1
DaVinci().Lumi = True
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 GaudiConf import IOHelper
from Configurables import DaVinci, DecayTreeTuple
from DecayTreeTuple.Configuration import *
# Stream and stripping line we want to use
stream = "AllStreams"
line = "D2hhCompleteEventPromptDst2D2RSLine"
# Create an ntuple to capture D*+ decays from the StrippingLine line
dtt = DecayTreeTuple("TupleDstToD0pi_D0ToKpi")
dtt.Inputs = ["/Event/{0}/Phys/{1}/Particles".format(stream, line)]
dtt.Decay = "[D*(2010)+ -> (D0 -> K- pi+) pi+]CC"
track_tool = dtt.addTupleTool("TupleToolTrackInfo")
track_tool.Verbose = True
dtt.addTupleTool("TupleToolPrimaries")
dtt.addBranches(
{
"Dstar": "[D*(2010)+ -> (D0 -> K- pi+) pi+]CC",
"D0": "[D*(2010)+ -> ^(D0 -> K- pi+) pi+]CC",
"Kminus": "[D*(2010)+ -> (D0 -> ^K- pi+) pi+]CC",
"piplus": "[D*(2010)+ -> (D0 -> K- ^pi+) pi+]CC",
"pisoft": "[D*(2010)+ -> (D0 -> K- pi+) ^pi+]CC",
}
)
dtt.D0.addTupleTool("TupleToolPropertime")
# Configure DaVinci
DaVinci().UserAlgorithms += [dtt]
DaVinci().InputType = "DST"
