def addMCTuple(name, decayDescriptor):
'''
Given name and decay descriptor, add MCTuple to the main DaVinci Sequence
'''
# MC
mcTuple = MCDecayTreeTuple('MCTuple'+name) # I can put as an argument a name if I use more than a MCDecayTreeTuple
mcTuple.Decay = decayDescriptor #'[phi(1020) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)]CC'
mcTuple.ToolList = ['MCTupleToolKinematic',
'TupleToolEventInfo',
'MCTupleToolHierarchy',
"TupleToolMCBackgroundInfo",
]
DaVinci().UserAlgorithms += [mcTuple]
) # I can put as an argument a name if I use more than a MCDecayTreeTuple
mcTuple.Decay = "[J/psi(1S) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)]CC"
mcTuple.Branches = {
"JPsi": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)]CC",
"Ks1": "[J/psi(1S) -> ^(KS0 -> pi+ pi-) (KS0 -> pi+ pi-)]CC",
"Ks2": "[J/psi(1S) -> (KS0 -> pi+ pi-) ^(KS0 -> pi+ pi-)]CC",
"pi1": "[J/psi(1S) -> (KS0 -> ^pi+ pi-) (KS0 -> pi+ pi-)]CC",
"pi2": "[J/psi(1S) -> (KS0 -> pi+ ^pi-) (KS0 -> pi+ pi-)]CC",
"pi3": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> ^pi+ pi-)]CC",
"pi4": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> pi+ ^pi-)]CC",
}
mcTuple.addBranches(mcTuple.Branches)
mcTuple.ToolList = [
"MCTupleToolKinematic",
"TupleToolEventInfo",
"MCTupleToolHierarchy",
"TupleToolMCBackgroundInfo",
]
from Configurables import DaVinci
# Name of tuple file you want to write out.
DaVinci().TupleFile = "JPsi2KsKs.root"
DaVinci().EvtMax = -1
DaVinci().DataType = "2012"
DaVinci().Simulation = isMC
# This is very useful to make sure you didn't accidently miss some data.
# Adds tuple in same file with lumi (units are pb-1).
DaVinci().Lumi = not isMC
mcTuple.Decay = '[D_s+ -> ^(phi(1020) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)) ^pi+]CC'
mcTuple.Branches = {'Ds' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC',
'phi' : '[D_s+ -> ^(phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC',
'Ks1' : '[D_s+ -> (phi(1020) -> ^(KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC',
'Ks2' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) ^(KS0 -> pi+ pi-)) pi+]CC',
'pi1' : '[D_s+ -> (phi(1020) -> (KS0 -> ^pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC',
'pi2' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ ^pi-) (KS0 -> pi+ pi-)) pi+]CC',
'pi3' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> ^pi+ pi-)) pi+]CC',
'pi4' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ ^pi-)) pi+]CC',
'pis' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) ^pi+]CC',
}
mcTuple.addBranches(mcTuple.Branches)
mcTuple.ToolList = ['MCTupleToolKinematic',
'TupleToolEventInfo',
'MCTupleToolHierarchy',
"TupleToolMCBackgroundInfo",
]
Ds_sequence.sequence().Members += [tuple]
from Configurables import DaVinci
#Name of tuple file you want to write out.
DaVinci().TupleFile = "Phi2KsKs.root"
DaVinci().EvtMax = 10000
DaVinci().DataType = '2012'
DaVinci().Simulation = isMC
'X' : '[ D+ => ( (phi(1020) => K+ K- ) ) ^pi+ ]CC'}
numbers_phi_X = [2,1]
else:
MC_DecayDescriptor = '[ Xc => ( ^(phi(1020) => ^K+ ^K- ) ) ^X+ ^X0]CC'
MC_branches = {'Head' : '[ Xc => ( (phi(1020) => K+ K- ) ) X+ X0]CC',
'Phi' : '[ Xc => ( ^(phi(1020) => K+ K- ) ) X+ X0]CC',
'KPlus' : '[ Xc => ( (phi(1020) => ^K+ K- ) ) X+ X0]CC',
'KMinus' : '[ Xc => ( (phi(1020) => K+ ^K- ) ) X+ X0]CC',
'X' : '[ Xc => ( (phi(1020) => K+ K- ) ) ^X+ X0]CC',
'X0' : '[ Xc => ( (phi(1020) => K+ K- ) ) X+ ^X0]CC'}
numbers_phi_X = [2,1]
mcTuple = MCDecayTreeTuple() # I can put as an argument a name if I use more than a MCDecayTreeTuple
mcTuple.Decay = MC_DecayDescriptor
mcTuple.ToolList = ['MCTupleToolKinematic',
'TupleToolEventInfo',
'MCTupleToolHierarchy',
]
mcTuple.addTupleTool("LoKi::Hybrid::MCTupleTool/LoKi_All")
mcTuple.LoKi_All.Variables = {
'TRUEID' : 'MCID'
}
mcTuple.addBranches(MC_branches)
mcTuple.Head.addTupleTool("LoKi::Hybrid::MCTupleTool/LoKi_Head")
mcTuple.Head.LoKi_Head.Preambulo = [
"from LoKiCore.math import sqrt",
"Phi_E = MCCHILD(MCE, {})".format(numbers_phi_X[0]),
"Phi_PX = MCCHILD(MCPX, {})".format(numbers_phi_X[0]),
"Phi_PY = MCCHILD(MCPY, {})".format(numbers_phi_X[0]),
elif 0 <= key.find ( 'Prev/' ) : bad.add ( key )
elif 0 <= key.find ( 'Next/' ) : bad.add ( key )
elif 0 <= key.find ( '/MC/' ) and 'GEN' == ext : bad.add ( key )
for b in bad :
del algs[b]
dod.AlgMap = algs
from Configurables import EventClockSvc, CondDB
EventClockSvc ( EventTimeDecoder = "FakeEventTime" )
CondDB ( IgnoreHeartBeat = True )
appendPostConfigAction( doIt)
mctl=[ 'MCTupleToolHierarchy', 'MCTupleToolKinematic', 'MCTupleToolPrimaries']
#mctl=[ 'MCTupleToolKinematic']
mct.ToolList=mctl
#mctB.ToolList=mctl
printMC = PrintMCTree()
printMC.ParticleNames = ["Lambda_c+","Lambda_c~-"]
printMC.ParticleNames = ["D0","D~0"]
printMC.ParticleNames = ["Xi_cc++","Xi_cc~--"]
printMC.ParticleNames = ["B0","B~0"]
printMC.ParticleNames = ["B+","B-"]
########################################################################
from Configurables import DaVinci
DaVinci().EvtMax = -1
# For a quick and dirty check, you don't need to edit anything below here.
##########################################################################
# Create an MC DTT containing any candidates matching the decay descriptor
mctuple = MCDecayTreeTuple("MCDecayTreeTuple")
mctuple.Decay = decay
mctuple.addBranches({
"KSO": "[KS0 ==> pi+ pi- e+ e-]CC",
"e+": "[KS0 ==> pi+ pi- ^e+ e-]CC",
"e-": "[KS0 ==> pi+ pi- e+ ^e-]CC",
"pi+": "[KS0 ==> ^pi+ pi- e+ e-]CC",
"pi-": "[KS0 ==> pi+ ^pi- e+ e-]CC"
})
mctuple.ToolList = [
"MCTupleToolHierarchy", "LoKi::Hybrid::MCTupleTool/LoKi_Photos"
]
# Add a 'number of photons' branch
mctuple.addTupleTool("MCTupleToolKinematic").Verbose = True
mctuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_Photos").Variables = {
"nPhotos": "MCNINTREE(('gamma' == MCABSID))"
}
mctuple.addTupleTool("LoKi::Hybrid::MCTupleTool/LoKi_All")
mctuple.LoKi_All.Variables = {
'TRUEID': 'MCID',
'M': 'MCMASS',
'THETA': 'MCTHETA',
'PT': 'MCPT',
'PX': 'MCPX',
'PY': 'MCPY',
## @file DVTrueKs.py
#
# See DecayTreeTuple documentation
#
# @author P. Koppenburg
# @date 2009-01-22
#
########################################################################
#
# The MC truth Tuple
#
from Configurables import MCDecayTreeTuple
mcTuple = MCDecayTreeTuple("MCTuple")
mcTuple.Decay = "[KS0 -> ^pi+ ^pi- {, gamma}{, gamma}]cc"
mcTuple.ToolList = [
"MCTupleToolKinematic", "TupleToolEventInfo", "MCTupleToolReconstructed",
"MCTupleToolAngles"
]
#mcTuple.OutputLevel = 1
########################################################################
#
# The reconstructed tuple
#
from Configurables import DecayTreeTuple
tuple = DecayTreeTuple("Tuple")
tuple.ToolList += [
"TupleToolMCTruth", "TupleToolMCBackgroundInfo", "TupleToolAngles",
"TupleToolPrimaries", "TupleToolGeometry", "TupleToolKinematic",
"TupleToolEventInfo", "TupleToolTrackInfo"
]
tuple.InputLocations = ["StdLooseKsLL", "StdLooseKsDD"]
tuple.Decay = "[KS0 -> ^pi+ ^pi-]cc"
from Configurables import ( DaVinci
# , EventSelector # Uncomment when running locally
, MCDecayTreeTuple
, LHCbApp
)
from DecayTreeTuple.Configuration import *
LHCbApp().XMLSummary='summary.xml'
# Create an MC DTT containing any candidates matching the decay descriptor
mctuple = MCDecayTreeTuple()
mctuple.Decay = "[B_s0 => ^(phi(1020) ==> ^K+ ^K-) ^(phi(1020) ==> ^K+ ^K-)]CC"
mctuple.addBranches({
"KK" : " [B_s0 => (phi(1020) ==> K+ K-) ^(phi(1020) ==> K+ K-)]CC "
})
mctuple.ToolList = []
mctuple.addTupleTool("MCTupleToolKinematic").Verbose = True
# Name of the .xgen file produced by Gauss
#ev = EventSelector()
#ev.Input = ["DATAFILE='Gauss-13104013-100000ev-20160407.xgen' TYP='POOL_ROOTTREE' Opt='READ'"]
# Configure DaVinci
dv = DaVinci( HistogramFile = "histo.root"
, TupleFile = "DVntuple.root"
, UserAlgorithms = [mctuple]
, Simulation = True
, Lumi = False
, DataType = "2012"
, EvtMax = -1
)
elif 0 <= key.find ( 'Prev/' ) : bad.add ( key )
elif 0 <= key.find ( 'Next/' ) : bad.add ( key )
elif 0 <= key.find ( '/MC/' ) and 'GEN' == ext : bad.add ( key )
for b in bad :
del algs[b]
dod.AlgMap = algs
from Configurables import EventClockSvc, CondDB
EventClockSvc ( EventTimeDecoder = "FakeEventTime" )
CondDB ( IgnoreHeartBeat = True )
appendPostConfigAction( doIt)
mctl=[ 'MCTupleToolHierarchy', 'MCTupleToolKinematic', 'MCTupleToolPrimaries']
mctl=[ 'MCTupleToolKinematic']
mct.ToolList=mctl
mctB.ToolList=mctl
printMC = PrintMCTree()
printMC.ParticleNames = ["Lambda_c+","Lambda_c~-"]
printMC.ParticleNames = ["D0","D~0"]
printMC.ParticleNames = ["Xi_cc++","Xi_cc~--"]
printMC.ParticleNames = ["B0","B~0"]
printMC.ParticleNames = ["B+","B-"]
########################################################################
from Configurables import DaVinci
DaVinci().EvtMax = -1
decay = "[B_s0 => ^(J/psi(1S) ==> ^mu+ ^mu-) ^(phi(1020) ==> ^K+ ^K-)]CC"
decay_heads = ["B_s0", "B_s~0"]
dir = "/Disk/speyside8/lhcb/gcowan1/generation/Bs2JpsiPhi/"
datafiles = glob.glob(dir + "/*1000ev*xgen")
# datafiles = [datafiles[-1]]
print datafiles
year = 2012
# For a quick and dirty check, you don't need to edit anything below here.
##########################################################################
# Create an MC DTT containing any candidates matching the decay descriptor
mctuple = MCDecayTreeTuple("MCDecayTreeTuple")
mctuple.Decay = decay
mctuple.ToolList = ["MCTupleToolHierarchy", "LoKi::Hybrid::MCTupleTool/LoKi_Photos"]
# Add a 'number of photons' branch
# mctuple.addTupleTool("MCTupleToolReconstructed").Associate = False
# mctuple.MCTupleToolReconstructed.FillPID = False
mctuple.addTupleTool("MCTupleToolKinematic").Verbose = True
mctuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_Photos").Variables = {"nPhotos": "MCNINTREE(('gamma' == MCABSID))"}
mctuple.addTupleTool("MCTupleToolP2VV").Calculator = "MCBs2JpsiPhiAngleCalculator"
# Print the decay tree for any particle in decay_heads
printMC = PrintMCTree()
printMC.ParticleNames = decay_heads
# Name of the .xgen file produced by Gauss
EventSelector().Input = ["DATAFILE='{0}' TYP='POOL_ROOTTREE' Opt='READ'".format(datafile) for datafile in datafiles]
# Configure DaVinci
