tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
#tuple.TupleToolTISTOS.UseAutomaticTriggerList = True
#tuple.addTool(TupleToolTagging)
#tuple.TupleToolTagging.Verbose = True
#from FlavourTagging.Tunings import TuneTool
#TuneTool(tuple,'Xmass_2011')
###########################################################################################################################
tuple.Decay = '[Lambda_b0 -> (^J/psi(1S) -> ^mu+ ^mu-) (^sigma_0 -> (^Lambda0 -> ^p+ ^pi-) ^gamma)]cc'
tuple.Branches = {
"Bs" : "[Lambda_b0]cc : [Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (sigma_0 -> (Lambda0 -> p+ pi-) gamma)]cc",
"R1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (^sigma_0 -> (Lambda0 -> p+ pi-) gamma)]cc",
"R2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (sigma_0 -> (^Lambda0 -> p+ pi-) gamma)]cc",
"R3" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (sigma_0 -> (Lambda0 -> p+ pi-) ^gamma)]cc",
"H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (sigma_0 -> (Lambda0 -> ^p+ pi-) gamma)]cc",
"H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (sigma_0 -> (Lambda0 -> p+ ^pi-) gamma)]cc",
"J_psi_1S" : "[Lambda_b0 -> (^J/psi(1S) -> mu+ mu-) (sigma_0 -> (Lambda0 -> p+ pi-) gamma)]cc"
}
tuple.addTool(TupleToolDecay, name="Bs")
tuple.Bs.ToolList = [ "TupleToolPropertime" ]
tuple.addTool(TupleToolDecay, name="J_psi_1S")
tuple.addTool(TupleToolDecay, name="R1")
tuple.Bs.addTool(tistos)
tuple.Bs.ToolList+=["TupleToolTISTOS/tistos"]
tuple.J_psi_1S.addTool(tistos)
tuple.J_psi_1S.ToolList+=["TupleToolTISTOS/tistos"]
"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]
for tup in tuples:
tup.ReFitPVs = True
if MODE == "MC":
tup.addTool(TupleToolMCTruth, name="TruthTool")
tup.addTool(TupleToolMCBackgroundInfo, name="BackgroundInfo")
tup.ToolList += ["TupleToolMCTruth/TruthTool"]
]
tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
#tuple.TupleToolTISTOS.UseAutomaticTriggerList = True
#tuple.addTool(TupleToolTagging)
#tuple.TupleToolTagging.Verbose = True
#from FlavourTagging.Tunings import TuneTool
#TuneTool(tuple,'Xmass_2011')
###########################################################################################################################
tuple.Decay = '[Lambda_b0 -> (^J/psi(1S) -> ^mu+ ^mu-) (^Lambda0 -> ^pi+ ^pi-)]cc'
tuple.Branches = {
"Bs" : "[Lambda_b0]cc : [Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ pi-)]cc",
"R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (^Lambda0 -> pi+ pi-)]cc",
"H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> ^pi+ pi-)]cc",
"H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ ^pi-)]cc",
"J_psi_1S" : "[Lambda_b0 -> (^J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ pi-)]cc"
}
tuple.addTool(TupleToolDecay, name="Bs")
tuple.Bs.ToolList = [ "TupleToolPropertime" ]
tuple.addTool(TupleToolDecay, name="J_psi_1S")
tuple.Bs.addTool(tistos)
tuple.Bs.ToolList+=["TupleToolTISTOS/tistos"]
tuple.J_psi_1S.addTool(tistos)
tuple.J_psi_1S.ToolList+=["TupleToolTISTOS/tistos"]
tuple.ReFitPVs = True
LoKi_Bs=LoKi__Hybrid__TupleTool("LoKi_Bs")
# 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",
"TupleToolGeometry",
"TupleToolPrimaries",
"TupleToolTrackInfo",
"TupleToolEventInfo",
"TupleToolAngles",
"TupleToolANNPID",
"TupleToolMCBackgroundInfo",
"TupleToolMCTruth",
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"
# Other variables
tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All")
tuple.LoKi_All.Variables = {"Eta": "ETA", "Phi": "PHI"}
# Tell DecayTreeTuple the structure of your decay, you must put ^ in front
# of particles that you want to write out (apart from head). J/psi->mu+mu-
# is a CP eigenstate so we don't need []CC here.
tuple.Decay = "[J/psi(1S) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)]CC"
tuple.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",
}
tuple.addBranches(tuple.Branches)
tuple.JPsi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_JPsi")
tuple.JPsi.LoKi_JPsi.Variables = {
"DOCAMAX": "DOCAMAX",
"MassDiff_JPsi": "DMASS('J/psi(1S)')",
"BPVDIRA": "BPVDIRA",
"IPS_JPsi": "MIPCHI2DV(PRIMARY)",
"VFASPF_CHI2DOF": "VFASPF(VCHI2/VDOF)",
'Hlt2DiMuonUnbiasedJPsiDecision'
]
tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
#tuple.TupleToolTISTOS.UseAutomaticTriggerList = True
#tuple.addTool(TupleToolTagging)
#tuple.TupleToolTagging.Verbose = True
#from FlavourTagging.Tunings import TuneTool
#TuneTool(tuple,'Xmass_2011')
###########################################################################################################################
tuple.Decay = '[Lambda0 -> ^p+ ^pi-]CC'
tuple.Branches = {
"R" : "^[Lambda0 -> p+ pi-]CC",
"H1" : "[Lambda0 -> ^p+ pi-]CC",
"H2" : "[Lambda0 -> p+ ^pi-]CC",
}
tuple.addTool(TupleToolDecay, name="J_psi_1S")
tuple.J_psi_1S.addTool(tistos)
tuple.J_psi_1S.ToolList+=["TupleToolTISTOS/tistos"]
tuple.ReFitPVs = True
tuple.addTool(TupleToolDecay, name="R")
LoKi_R=LoKi__Hybrid__TupleTool("LoKi_R")
LoKi_R.Variables = {
"WM" : "WM( 'pi+' , 'pi-')"
}
}
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)
# List of the reconstructed tuples
tuples = [ tuple_B2Kmumu
]
for tup in tuples:
tup.ReFitPVs = True
if MODE == "MC":
tup.addTool(TupleToolMCTruth, name = "TruthTool")
tuple_B2psiomega.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^pi0 )]CC'
tuple_B2psiomega.Branches = {
# 'B' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'Jpsi' : "[ B0 --> ^(J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'muplus' : "[ B0 --> (J/psi(1S) -> ^mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'muminus' : "[ B0 --> (J/psi(1S) -> mu+ ^mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'omega' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) ^(omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'piplus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> ^pi+ pi- (pi0 -> gamma gamma ) ) ]CC",
# 'piminus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ ^pi- (pi0 -> gamma gamma ) ) ]CC",
# 'pizero' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- ^(pi0 -> gamma gamma ) ) ]CC",
# 'gamma1' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> ^gamma gamma ) ) ]CC",
# 'gamma2' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma ^gamma ) ) ]CC",
#
'B' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- pi0 ) ]CC",
'Jpsi' : "[ B0 --> ^(J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- pi0 ) ]CC",
'muplus' : "[ B0 --> (J/psi(1S) -> ^mu+ mu- ...) (omega(782) -> pi+ pi- pi0 ) ]CC",
'muminus' : "[ B0 --> (J/psi(1S) -> mu+ ^mu- ...) (omega(782) -> pi+ pi- pi0 ) ]CC",
'omega' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) ^(omega(782) -> pi+ pi- pi0 ) ]CC",
'piplus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> ^pi+ pi- pi0 ) ]CC",
'piminus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ ^pi- pi0 ) ]CC",
'pizero' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- ^pi0 ) ]CC",
#
# "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 ["B0", "Jpsi", "muplus", "muminus", "omega", "piplus", "piminus", "pizero", "gamma1", "gamma2"]:
"LOKI_FDCHI2": "BPVVDCHI2",
"LOKI_FDS": "BPVDLS",
"LOKI_DIRA": "BPVDIRA",
###### DecayTreeFitVariables
"LOKI_DTF_CTAU": "DTF_CTAU( 0, True )",
"LOKI_DTF_CTAUS": "DTF_CTAUSIGNIFICANCE( 0, True )",
"LOKI_DTF_CHI2NDOF": "DTF_CHI2NDOF( True )",
"LOKI_DTF_CTAUERR": "DTF_CTAUERR( 0, True )",
"LOKI_MASS_JpsiConstr": "DTF_FUN ( M , True , 'J/psi(1S)' )",
"LOKI_DTF_VCHI2NDOF": "DTF_FUN ( VFASPF(VCHI2/VDOF) , True )",
#"LOKI_DTF_TAU" : "DTF_FUN ( BPVLTIME('PropertimeFitter/properTime:PUBLIC') , True)"
}
###########################################################
##################### BuTuple #############################
BuTuple.Branches = {"Bplus": "[B+]cc : [B+ -> (J/psi(1S) => mu+ mu-) K+]cc"}
BuTuple.addTool(TupleToolDecay, name="Bplus")
BuTuple.Bplus.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_SpecificToB"]
BuTuple.Bplus.addTool(LoKi_SpecificToB)
BuTuple.addTool(TupleToolGeometry)
BuTuple.Bplus.addTool(TupleToolTISTOS)
BuTuple.Bplus.TupleToolTISTOS.addTool(TriggerTisTos, "TriggerTisTos")
BuTuple.Bplus.TupleToolTISTOS.TriggerTisTos.TOSFracMuon = 0.
BuTuple.Bplus.ToolList += ["TupleToolTISTOS"]
###########################################################
###########################################################
TupleSeq.ModeOR = True
TupleSeq.ShortCircuit = False
"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
tuples = [tuple_B2Kmumu]
for tup in tuples:
tup.ReFitPVs = True
if MODE == "MC":
tup.addTool(TupleToolMCTruth, name="TruthTool")
tup.addTool(TupleToolMCBackgroundInfo, name="BackgroundInfo")
tup.ToolList += ["TupleToolMCTruth/TruthTool"]
DaVinci().appendToMainSequence( [ sc.sequence() ] )
#
################################################################################
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
my_tuple = DecayTreeTuple("BcDecayTreeTuple")
if simulation:
my_tuple.Inputs = ["/Phys/Bc2KstKBc2XK/Particles"]
else:
my_tuple.Inputs = ["/Event/Bhadron/Phys/Bc2KstKBc2XK/Particles"]
my_tuple.Decay="[B_c+ -> ^(K*(892)~0 -> ^K- ^pi+) ^K+]CC"
my_tuple.Branches={"B_c+":"[B_c+ -> (K*(892)~0 -> K- pi+) K+]CC" }
my_tuple.addTool( TupleToolDecay, name = "Bc" )
my_tuple.ToolList += [
"TupleToolGeometry",
"TupleToolDira",
"TupleToolAngles",
"TupleToolPid",
"TupleToolKinematic",
"TupleToolPropertime",
"TupleToolPrimaries",
"TupleToolEventInfo",
"TupleToolTrackInfo",
"TupleToolVtxIsoln",
"TupleToolPhotonInfo",
"TupleToolCaloHypo"
Inputs=[particlePath],
## Primary vertices from mDST
P2PVInputLocations=[p2PVLocation],
UseP2PVRelations=True,
WriteP2PVRelations=False,
)
dtt.Decay = "[D*(2010)+ -> (^D0 -> ^K- ^pi+) ^pi+]cc"
if mDST: dtt.RootInTES = locationRoot
from DecayTreeTuple.Configuration import *
## Add appropriate tools
from Configurables import TupleToolDecay
dtt.addTool(TupleToolDecay, name='D0')
dtt.Branches = {"D0": "[D*(2010)+ -> (^D0 -> K- pi+) pi+]cc"}
ttptime = dtt.D0.addTupleTool('TupleToolPropertime')
ttptime.FitToPV = True
ttsi = dtt.D0.addTupleTool('TupleToolSwimmingInfo/TriggerInfo')
ttsis = dtt.D0.addTupleTool('TupleToolSwimmingInfo/StrippingInfo')
ttsi.ReportsLocation = D0path + '/P2TPRelations'
ttsis.ReportsLocation = D0path + '/P2TPRelations'
ttsis.ReportStage = "Stripping"
ttsi.OutputLevel = 1
ttsis.OutputLevel = 1
tttt = dtt.D0.addTupleTool('TupleToolTISTOS')
tttt.TriggerList = [
'Hlt1TrackAllL0Decision', 'Hlt1TrackMuonDecision',
'Hlt1DiMuonHighMassDecision', 'Hlt2DiMuonDetachedJpsiDecision',
tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All')
tuple.LoKi_All.Variables = {
'Eta' : 'ETA',
'Phi' : 'PHI',
}
#Tell DecayTreeTuple the structure of your decay, you must put ^ in front
#of particles that you want to write out (apart from head). J/psi->mu+mu-
# is a CP eigenstate so we don't need []CC here.
tuple.Decay = '[D_s+ -> ^(phi(1020) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)) ^pi+]CC'
tuple.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',
}
tuple.addBranches(tuple.Branches)
tuple.Ds.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_Ds")
tuple.Ds.LoKi_Ds.Variables = {
'DOCAMAX' : 'DOCAMAX',
"MassDiff_Ds" : "DMASS('D_s+')",
"BPVDIRA" : "BPVDIRA",
"IPS_Ds" : "MIPCHI2DV(PRIMARY)",
"VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)",
# 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 = {
"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"
}
]
tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
#tuple.TupleToolTISTOS.UseAutomaticTriggerList = True
#tuple.addTool(TupleToolTagging)
#tuple.TupleToolTagging.Verbose = True
#from FlavourTagging.Tunings import TuneTool
#TuneTool(tuple,'Xmass_2011')
###########################################################################################################################
tuple.Decay = '[Lambda_b0 -> (^J/psi(1S) -> ^mu+ ^mu-) (^Lambda0 -> ^p+ ^pi-)]cc'
tuple.Branches = {
"Bs" : "[Lambda_b0]cc : [Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]cc",
"R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (^Lambda0 -> p+ pi-)]cc",
"H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> ^p+ pi-)]cc",
"H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ ^pi-)]cc",
"J_psi_1S" : "[Lambda_b0 -> (^J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]cc"
}
tuple.ToolList += [
"TupleToolMCTruth",
"TupleToolMCBackgroundInfo"
]
from Configurables import TupleToolMCTruth, MCTupleToolP2VV
tuple.addTool(TupleToolDecay, name="Bs")
tuple.Bs.ToolList = [ "TupleToolMCTruth", "TupleToolPropertime" ]
tuple.Bs.addTool(TupleToolMCTruth)
#tuple.Bs.TupleToolMCTruth.ToolList += ["MCTupleToolP2VV"]
# create a selection using the substitution algorithm
selSub = Selection(
'KpforPip_sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
selSeq = SelectionSequence('selSeq', TopSelection=selSub)
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
tuple=DecayTreeTuple("KpforPipTuple")
tuple.Decay="[B0 -> ^(K*(892)0 -> ^pi+ ^pi-) ^(eta_prime -> ^pi- ^pi+ ^gamma)]CC"
tuple.Branches={"B0":"[B0 -> (K*(892)0 -> pi+ pi-) (eta_prime -> pi- pi+ gamma)]CC"}
tuple.Inputs=[selSeq.outputLocation()]
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolDira"
, "TupleToolAngles"
, "TupleToolPid"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolEventInfo"
, "TupleToolTrackInfo"
, "TupleToolVtxIsoln"
, "TupleToolPhotonInfo"
#, "TupleToolMCTruth"
"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
tuples = [ tuple_B2Kmumu
]
for tup in tuples:
tup.ReFitPVs = True
if MODE == "MC":
tup.addTool(TupleToolMCTruth, name = "TruthTool")
tup.addTool(TupleToolMCBackgroundInfo, name = "BackgroundInfo")
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'"
]
]
tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
#tuple.TupleToolTISTOS.UseAutomaticTriggerList = True
#tuple.addTool(TupleToolTagging)
#tuple.TupleToolTagging.Verbose = True
#from FlavourTagging.Tunings import TuneTool
#TuneTool(tuple,'Xmass_2011')
###########################################################################################################################
tuple.Decay = '[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)]CC'
tuple.Branches = {
"Bs" : "^[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]CC",
"R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) ^(Lambda0 -> p+ pi-)]CC",
"H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> ^p+ pi-)]CC",
"H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ ^pi-)]CC",
"J_psi_1S" : "[Lambda_b0 -> ^(J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]CC"
}
tuple.ToolList += [
"TupleToolMCTruth",
"TupleToolMCBackgroundInfo"
]
from Configurables import TupleToolMCTruth, MCTupleToolP2VV
tuple.addTool(TupleToolDecay, name="Bs")
tuple.Bs.ToolList = [ "TupleToolMCTruth", "TupleToolPropertime" ]
tuple.Bs.addTool(TupleToolMCTruth)
#tuple.Bs.TupleToolMCTruth.ToolList += ["MCTupleToolP2VV"]
from Gaudi.Configuration import *
from Configurables import GaudiSequencer
from Configurables import DaVinci
simulation=False
from Configurables import EventNodeKiller
eventNodeKiller = EventNodeKiller('DAQkiller')
eventNodeKiller.Nodes = ['DAQ','pRec']
#MySequencer.Members+=[eventNodeKiller]
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
tuple=DecayTreeTuple()
tuple.Decay="[B0 -> ^(K*(892)0 -> ^K+ ^pi-) ^(eta_prime -> ^pi- ^pi+ ^(eta -> ^gamma ^gamma))]CC"
tuple.Branches={"B0":"[B0 -> (K*(892)0 -> K+ pi-) (eta_prime -> pi- pi+ (eta -> gamma gamma))]CC"}
tuple.Inputs=["/Event/Bhadron/Phys/B2XEtaB2etapKstarLine/Particles"]
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolDira"
, "TupleToolAngles"
, "TupleToolPid"
, "TupleToolKinematic"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolEventInfo"
, "TupleToolTrackInfo"
, "TupleToolVtxIsoln"
, "TupleToolPhotonInfo"
#, "TupleToolMCTruth"
"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
]
for tup in tuples:
tup.ReFitPVs = True
if MODE == "MC":
tup.addTool(TupleToolMCTruth, name = "TruthTool")
tup.addTool(TupleToolMCBackgroundInfo, name = "BackgroundInfo")
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'"]
"TupleToolEventInfo",
"TupleToolTrackInfo",
"TupleToolAngles",
"TupleToolPropertime",
"TupleToolVtxIsoln",
"TupleToolMCBackgroundInfo"
]
decay="[B+ -> ^(eta_prime -> ^(rho(770)0 -> ^pi+ ^pi-) ^gamma ) ^K+]CC"
tuple.Decay =decay
#DecayTreeFitter Tool
tuple.Branches = { 'B' : "^("+decay.replace("^","")+")" }
from Configurables import TupleToolDecay
tuple.addTool(TupleToolDecay, name = 'B')
tuple.B.ToolList+=["TupleToolTISTOS"]
tuple.B.addTool( TupleToolTISTOS , name="TupleToolTISTOS")
tuple.B.TupleToolTISTOS.VerboseHlt1 = True
tuple.B.TupleToolTISTOS.VerboseHlt2 = True
tuple.B.TupleToolTISTOS.VerboseL0 = True
tuple.B.TupleToolTISTOS.TriggerList = myTriggerList
from Configurables import TupleToolDecayTreeFitter
tuple.B.ToolList += ["TupleToolDecayTreeFitter/MassFit",
] # fit with eta_prime mass onstraint
tuple.B.addTool(TupleToolDecayTreeFitter,name="MassFit")
tuple.B.MassFit.constrainToOriginVertex = 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 = 'B2XEtaLb2pKetapLine'
tuple=DecayTreeTuple()
tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta_prime -> ^pi- ^pi+ ^gamma)]CC"
tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta_prime -> pi- pi+ 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"
, "TupleToolPropertime"
, "TupleToolPrimaries"
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":
"[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)
# List of the reconstructed tuples
'Hlt2TopoMu3BodyBBDTDecision',
'Hlt2TopoMu4BodyBBDTDecision',
'Hlt2TransparentDecision',
'Hlt2DiMuonUnbiasedJPsiDecision'
]
tuple.addTool(TupleToolGeometry)
tuple.TupleToolGeometry.Verbose = True
###########################################################################################################################
tuple.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC'
tuple.Branches = {
"B0" : "^[B0 -> (J/psi(1S) -> mu+ mu-) (K*(892)0 -> K+ pi-)]CC",
"R" : "[B0 -> (J/psi(1S) -> mu+ mu-) ^(K*(892)0 -> K+ pi-)]CC",
"H1" : "[B0 -> (J/psi(1S) -> mu+ mu-) (K*(892)0 -> ^K+ pi-)]CC",
"H2" : "[B0 -> (J/psi(1S) -> mu+ mu-) (K*(892)0 -> K+ ^pi-)]CC",
"J_psi_1S" : "[B0 -> ^(J/psi(1S) -> mu+ mu-) (K*(892)0 -> K+ pi-)]CC"
}
tuple.ToolList += [
"TupleToolMCTruth",
"TupleToolMCBackgroundInfo"
]
from Configurables import TupleToolMCTruth, MCTupleToolP2VV
tuple.addTool(TupleToolDecay, name="B0")
tuple.B0.ToolList = [ "TupleToolMCTruth", "TupleToolPropertime" ]
tuple.B0.addTool(TupleToolMCTruth)
tuple.addTool(TupleToolDecay, name="J_psi_1S")
