def main(name1,name2):
my_path= basf2.create_path()
fileList = name1
inputMdstList('default', fileList, path=my_path)
output_file= '/home/belle2/sanjeeda/D0_Ks_Ks/reconstructed/reco'+name2
#load the lists for pion and kaon
stdc.stdPi(listtype='all', path=my_path)
stdc.stdK(listtype='all', path=my_path)
#list of soft pion with cuts
soft = '[thetaInCDCAcceptance] and [dr<0.5] and [abs(dz)<2] and [nCDCHits>0]'
fillParticleList('pi+:soft', soft, path=my_path)
#create merged K_S0 list
stdKshorts(prioritiseV0=True,fitter='TreeFit',path=my_path)
reconstructDecay('K_S0:merged -> pi-:all pi+:all', cut='0.3 < M < 0.7', path=my_path)
variablesToExtraInfo(particleList= 'K_S0:merged', variables={'M': 'M_preFit'}, path=my_path)
reconstructDecay('D0:sig -> K_S0:merged K_S0:merged', cut='1.7 < M < 2.1', path=my_path)
reconstructDecay('D*+ -> D0:sig pi+:soft', cut='useCMSFrame(p)> 2 and massDifference(0) < 0.16', path=my_path)
matchMCTruth(list_name='D*+',path=my_path)
vx.treeFit(list_name='D*+', conf_level=0.001, ipConstraint=True, updateAllDaughters=True, massConstraint=[310],path=my_path)
vertex_variables = vc.flight_info + ['M','x','y','z','mcX','mcY','mcZ',
'mcProdVertexX','mcProdVertexY','mcProdVertexZ','mcFlightTime','mcFlightDistance']
d0_vars= vu.create_aliases_for_selected(
list_of_variables = vc.inv_mass + vc.mc_truth + vertex_variables + vc.kinematics +['isSignalAcceptMissingGamma'],
decay_string='D*+ -> [^D0:sig -> [K_S0:merged -> pi+:all pi-:all] [K_S0:merged -> pi+:all pi-:all]] pi+:soft', prefix='Dz')
kshort_vars = vu.create_aliases_for_selected(
list_of_variables = vc.inv_mass + vc.mc_truth + vertex_variables + vc.kinematics + ['extraInfo(M_preFit)'],
decay_string= 'D*+ -> [D0:sig -> [^K_S0:merged -> pi+:all pi-:all] [^K_S0:merged -> pi+:all pi-:all]] pi+:soft',prefix=['Ks1','Ks2'])
pi_vars = vu.create_aliases_for_selected(
list_of_variables = vc.kinematics + vc.track + vc.mc_truth + vc.pid,
decay_string='D*+ -> [D0:sig -> [K_S0:merged -> ^pi+:all ^pi-:all] [K_S0:merged -> ^pi+:all ^pi-:all]] ^pi+:soft',prefix=['pi1','pi2','pi3','pi4','pisoft'])
dstar_vars= vu.create_aliases_for_selected(
list_of_variables = vc.inv_mass + vc.mc_truth + vc.kinematics+['useCMSFrame(p)','massDifference(0)','isSignalAcceptMissingGamma','Q'] ,
decay_string='^D*+ -> [D0:sig -> [K_S0:merged -> pi+:all pi-:all] [K_S0:merged -> pi+:all pi-:all]] pi+:soft',prefix ='Dst')
variablesToNtuple('D*+', d0_vars + kshort_vars + pi_vars + dstar_vars,
filename=output_file, treename='D0KsKs', path=my_path)
process(my_path)
print(statistics)
def make_ntuple():
from variables import variables as va
from variables.utils import create_aliases_for_selected
va.addAlias('PIDppi', 'atcPIDBelle(4,2)')
va.addAlias('PIDpk', 'atcPIDBelle(4,3)')
va.addAlias('PIDkpi', 'atcPIDBelle(3,2)')
# Lambda vertex position relative to IP
va.addAlias('abs_dz', 'abs(dz)')
# va.addAlias('abs_dr', 'abs(dr)')
va.addAlias('cosaXY', 'cosAngleBetweenMomentumAndVertexVectorInXYPlane')
# Track parameters relative to IP
# d0 and z0 are relative to the origin!
va.addAlias('min_dr', 'min(abs(daughter(0, dr)), abs(daughter(1, dr)))')
va.addAlias('min_dz', 'min(abs(daughter(0, dz)), abs(daughter(1, dz)))')
"""Create a list of all the variables to be included in the final ntuple"""
ntuple = []
# May have more feature than needed.
features = [
'dr', 'dz', 'cosaXY', 'min_dr', 'min_dz', 'pt', 'pz', 'chiProb', 'p'
]
features += create_aliases_for_selected(['PIDppi', 'PIDpk', 'PIDkpi', 'p'],
'Lambda0 -> ^p+ ^pi-',
prefix=['proton', 'pi'])
spectator = ['isSignal', 'isPrimarySignal', 'mcPDG', 'genMotherPDG']
spectator += ['IPX', 'IPY', 'IPZ', 'M', 'p', 'goodBelleLambda', 'distance']
ntuple = features + spectator
return ntuple
path=mp)
# 100 MeV mass window for Sigma+ should be large enough
ma.applyCuts('Sigma+:std',
'cosaXY > 0 and daughter(1, p) > 0.1 and 1.16 < M < 1.22',
path=mp)
ma.matchMCTruth('Sigma+:std', path=mp)
ntuple = [
'M', 'p', 'chiProb', 'cosa', 'cosaXY', 'dr', 'dz', 'distance',
'isSignal', 'genMotherPDG'
]
ntuple += ['ppi0_angle', 'p_decayAngle', 'pi0_decayAngle']
ntuple += ['IPX', 'IPY', 'IPZ']
ntuple += create_aliases_for_selected(
['pid_ppi', 'pid_pk', 'pid_kpi', 'dr', 'dz', 'p', 'isSignal'],
'Sigma+ -> ^p+ pi0',
prefix=['p'])
ntuple += create_aliases_for_selected(
['mcP', 'p', 'M', 'distance', 'isSignal', 'genMotherPDG'],
'Sigma+ -> p+ ^pi0',
prefix=['pi0'])
ntuple += create_aliases_for_selected(
['E', 'theta', 'phi'],
'Sigma+ -> p+ [pi0 -> ^gamma ^gamma]',
prefix=['gamma1', 'gamma2'])
ma.variablesToNtuple('Sigma+:std',
ntuple,
treename='sigma_std',
filename=outfile,
path=mp)
treename='muon',
filename=output_file,
path=my_path)
ma.variablesToNtuple(decayString='gamma:all',
variables=gamma_variables,
treename='phot',
filename=output_file,
path=my_path)
# Note here, that since we want to get info about gammas from pi0,
# we convert names of te variables from the gamma list in the way that they will
# correspond to given gammas.
ma.variablesToNtuple(
decayString='pi0:looseFit',
variables=pi0_variables +
vu.create_aliases_for_selected(gamma_variables, 'pi0 -> ^gamma ^gamma'),
filename=output_file,
treename='pi0',
path=my_path)
# Here for pions from K0s we do the same thing, but here we add custom aliases
# (see ntuples to see the difference)
ma.variablesToNtuple(
decayString='K_S0:all',
variables=K0s_variables + vu.create_aliases_for_selected(
charged_particle_variables, 'K_S0 -> ^pi+ pi-', 'pip') +
vu.create_aliases_for_selected(charged_particle_variables,
'K_S0 -> pi+ ^pi-', 'pim'),
filename=output_file,
treename='kshort',
path=my_path)
ft_variables = makePretty(['qrOutput(FBDT)', 'qrOutput(FANN)', 'isRelatedRestOfEventB0Flavor', 'qOutput(FANN)', 'rBinBelle(FANN)', 'qOutput(FBDT)', 'rBinBelle(FBDT)', 'EW90', 'pMissCMS', 'cosThetaMissCMS'])
deltat_variables = ['DeltaT', 'DeltaTErr', 'MCDeltaT', 'TagVz', 'TagVzErr','mcTagVz', 'DeltaZ', 'MCTagBFlavor']
cs_variables = makePretty(['R2', 'cosTBTO', 'cosTBz','CleoConeCS(2)','KSFWVariables(hso02)', 'CleoConeCS(4)', 'CleoConeCS(9)','KSFWVariables(hso10)', 'KSFWVariables(hso12)', 'KSFWVariables(hso14)', 'thrustBm', 'thrustOm'])
roe_vars_clean = makePretty(['ROE_E(cleanMask)','ROE_P(cleanMask)', 'ROE_M(cleanMask)', 'ROE_deltae(cleanMask)', 'ROE_mbc(cleanMask)', 'nROE_Tracks(cleanMask)', 'nROE_NeutralECLClusters(cleanMask)', 'ROE_PTheta(cleanMask)', 'ROE_MC_MissFlags(cleanMask)'])
vtx_variables = ['z', 'z_uncertainty', 'pValue']
dalitz_vars = ['m12', 'm13', 'm23']
mix_variables = []#['mixFBDT', 'mixFANN', 'mixTrue']
cluster_variables = ['clusterReg','clusterTiming',
'clusterErrorTiming','clusterE1E9',
'clusterE9E21','clusterAbsZernikeMoment40',
'clusterAbsZernikeMoment51','minC2TDist',
'clusterTheta','clusterZernikeMVA',
'clusterSecondMoment','clusterNHits']
track_variables = vc.track + vc.track_hits + vc.pid
ma.variablesToNtuple('B0:signal',
vc.deltae_mbc+kin_variables+ft_variables+deltat_variables+cs_variables+vtx_variables+mix_variables+roe_vars_clean+dalitz_vars+
['CSMVA','isContinuumEvent','isNotContinuumEvent','pi0Likeness','etaLikeness']+
vu.create_aliases_for_selected(list_of_variables=kin_variables, decay_string= 'B0 -> ^pi+ ^pi- [ ^K_S0 -> ^pi+ ^pi- ] ^gamma')+
vu.create_aliases_for_selected(list_of_variables=track_variables, decay_string= 'B0 -> ^pi+ ^pi- [ K_S0 -> ^pi+ ^pi- ] gamma')+
vu.create_aliases_for_selected(list_of_variables=cluster_variables, decay_string= 'B0 -> pi+ pi- [ K_S0 -> pi+ pi- ] ^gamma'),
filename = outputFilename, path=main_path)
# Process the events
b2.process(main_path)
# print out the summary
print(b2.statistics)
# 3. reconstruct Upsilon(4S) -> Btag+ Bsig- -> Btag+ mu-
ma.reconstructDecay(decayString='Upsilon(4S) -> B-:tag mu+:loose',
cut="",
path=my_path)
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='Upsilon(4S)', path=my_path)
# 5. build rest of the event
ma.buildRestOfEvent(target_list_name='Upsilon(4S)', path=my_path)
# 6. Select variables that we want to store to ntuple
d_vars = vc.mc_truth + vc.kinematics + vc.inv_mass
b_vars = vc.mc_truth + \
vc.deltae_mbc + \
vu.create_aliases_for_selected(list_of_variables=d_vars,
decay_string='B- -> ^D0 pi-') + \
vu.create_aliases(list_of_variables=['decayModeID'],
wrapper='daughter(0,extraInfo(variable))',
prefix="D")
mu_vars = vc.mc_truth
u4s_vars = vc.mc_truth + \
vc.roe_multiplicities + \
vc.recoil_kinematics + \
vc.kinematics + \
vu.create_aliases_for_selected(list_of_variables=b_vars,
decay_string='Upsilon(4S) -> ^B- mu+') + \
vu.create_aliases_for_selected(list_of_variables=mu_vars,
decay_string='Upsilon(4S) -> B- ^mu+')
# 7. Saving variables to ntuple
MCassociation='breco',
confidenceLevel=0.001,
useFitAlgorithm='standard_PXD',
path=my_path)
# Select variables that we want to store to ntuple
fs_vars = vc.pid + vc.track + vc.mc_truth
jpsiandk0s_vars = vc.mc_truth
bvars = vc.reco_stats + \
vc.deltae_mbc + \
vc.mc_truth + \
vc.roe_multiplicities + \
vc.flavor_tagging + \
vc.tag_vertex + \
vc.mc_tag_vertex + \
vu.create_aliases_for_selected(list_of_variables=fs_vars,
decay_string='B0 -> [J/psi -> ^mu+ ^mu-] pi0') + \
vu.create_aliases_for_selected(list_of_variables=jpsiandk0s_vars,
decay_string='B0 -> [^J/psi -> mu+ mu-] ^pi0')
# Saving variables to ntuple
output_file = 'B2A801-FlavorTagger.root'
ma.variablesToNtuple(decayString='B0:jspipi0',
variables=bvars,
filename=output_file,
treename='B0tree',
path=my_path)
# Summary of created Lists
ma.summaryOfLists(particleLists=['J/psi:mumu', 'pi0:looseFit', 'B0:jspipi0'],
path=my_path)
]
track_vars = ['d0', 'z0', 'd0Err']
pid_vars = ['pid_ppi', 'pid_pk', 'pid_kpi']
event_vars = ['IPX', 'IPY', 'IPZ']
# Variables
# =============================================
# sigma+
sigma_vars = [
'p', 'pt', 'pz', 'E', 'M', 'charge', 'distance', 'significanceOfDistance',
'cosa', 'cosaXY', 'mcPDG', 'genMotherPDG', 'isSignal'
]
# proton
proton_vars = create_aliases_for_selected([
'p', 'dr', 'dz', 'pid_ppi', 'pid_pk', 'pid_kpi', 'isSignal', 'genMotherPDG'
],
'Sigma+ -> ^p+ pi0',
prefix=['p'])
# pi0
pi0_vars = create_aliases_for_selected([
'p', 'M', 'mcPDG', 'genMotherPDG', 'isSignal', 'distance',
'significanceOfDistance'
],
'Sigma+ -> p+ ^pi0',
prefix=['pi0'])
# gamma
gamma_vars = create_aliases_for_selected([
'phi', 'theta', 'E', 'goodBelleGamma', 'clusterReg', 'clusterE9E21',
'clusterTiming', 'clusterErrorTiming', 'genMotherPDG', 'isSignal'
],
# fit B vertex on the tag-side
vertex.TagV('B0', constraintType='tube', fitAlgorithm='Rave', path=main)
# perform best candidate selection
#b2.set_random_seed('USBelleIISummerSchool')
#ma.rankByHighest('B0', variable='random', numBest=1, path=main)
# create list of variables for output ntuple
standard_vars = vc.kinematics + vc.mc_kinematics + vc.mc_truth
fs_vars = vc.pid + vc.track + vc.track_hits + standard_vars
jpsi_ks_vars = vc.inv_mass + vc.vertex + vc.mc_vertex + standard_vars
b_vars = vc.deltae_mbc + vc.tag_vertex + vc.mc_tag_vertex + ft.flavor_tagging + standard_vars
#b_vars += vu.create_aliases_for_selected([*fs_vars, 'isBremsCorrected'], 'B0 -> [J/psi -> ^e+ ^e-] K_S0', prefix=['ep', 'em'])
b_vars += vu.create_aliases_for_selected(fs_vars,
'B0 -> J/psi [K_S0 -> ^pi+ ^pi-]',
prefix=['pip', 'pim'])
b_vars += vu.create_aliases_for_selected(jpsi_ks_vars, 'B0 -> ^J/psi ^K_S0')
cmskinematics = vu.create_aliases(vc.kinematics, 'useCMSFrame({variable})',
'CMS')
b_vars += vu.create_aliases_for_selected(
cmskinematics, '^B0 -> [^J/psi -> ^mu+ ^mu-] [^K_S0 -> ^pi+ ^pi-]')
#variables.addAlias('withBremsCorrection', 'passesCut(passesCut(ep_isBremsCorrected == 1) or passesCut(em_isBremsCorrected == 1))')
#b_vars += ['withBremsCorrection']
# save variables to an ntuple
ma.variablesToNtuple('B0',
variables=b_vars,
filename='Bd2JpsiKS.root',
#ma.printList(list_name='anti-nu_mu:gen', full=False, path=my_path)
#ma.printList(list_name='anti-nu_me:gen', full=False, path=my_path)
#ma.reconstructDecay('tau-:gen -> e-:gen anti-nu_e:gen nu_tau:gen', '', path=my_path)
var.addAlias('invMS1', 'invMassInLists(e-:gen, anti-nu_e:gen, nu_tau:gen)')
var.addAlias('invMS2', 'invMassInLists(e-:gen, nu_tau:gen)')
var.addAlias('invMS3', 'invMassInLists(anti-nu_e:gen, nu_tau:gen)')
mcVariables = [
'p', 'px', 'py', 'pz', 'E', 'PDG', 'pt', 'invMS1', 'invMS2', 'invMS3'
]
#tauVariables = vc.inv_mass
variableList = vu.create_aliases_for_selected(list_of_variables=mcVariables,
decay_string='^e-') #+ #\
#vu.create_aliases_for_selected(list_of_variables=tauVariables,
#decay_string='^tau- -> ^e- ^anti-nu_e ^nu_tau')
#output_file = 'mcparticles.root'
#ma.variablesToNtuple(decayString='e+:gen',
# variables=mcVariables,
# treename='electron',
# filename=output_file,
# path=my_path)
output_file = 'GeneratorLevel-MCparticles.root'
ma.variablesToNtuple(decayString='e-:gen',
variables=variableList,
treename='electron',
filename=output_file,
]
track_vars = ['d0', 'z0', 'd0Err']
pid_vars = ['pid_ppi', 'pid_pk', 'pid_kpi']
event_vars = ['IPX', 'IPY', 'IPZ']
# Variables
# =============================================
# sigma+
sigma_vars = [
'p', 'pt', 'pz', 'E', 'M', 'charge', 'distance', 'significanceOfDistance',
'cosa', 'cosaXY', 'mcPDG', 'genMotherPDG', 'isSignal'
]
# proton
proton_vars = create_aliases_for_selected([
'p', 'dr', 'dz', 'pid_ppi', 'pid_pk', 'pid_kpi', 'isSignal', 'genMotherPDG'
],
'Sigma+ -> ^p+ pi0',
prefix=['p'])
# pi0
pi0_vars = create_aliases_for_selected(
['p', 'M', 'mcPDG', 'genMotherPDG', 'isSignal'],
'Sigma+ -> p+ ^pi0',
prefix=['pi0'])
# gamma
gamma_vars = create_aliases_for_selected(
['theta', 'E', 'genMotherPDG', 'isSignal'],
'Sigma+ -> p+ [pi0 -> ^gamma ^gamma]',
prefix=['gamma1', 'gamma2'])
ntuple_vars = sigma_vars + proton_vars + pi0_vars + gamma_vars + event_vars
# reconstruct B0 -> D0 pi0 decay
# keep only candidates with Mbc > 5.24 GeV
# and -1 < Delta E < 1 GeV
ma.reconstructDecay(decayString='B0:all -> D0:pi0pi0 pi0:looseFit',
cut='5.24 < Mbc < 5.29 and abs(deltaE) < 1.0',
path=my_path)
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='B0:all', path=my_path)
# Select variables that we want to store to ntuple
B0_vars = vc.inv_mass + \
vc.mc_truth + \
vu.create_aliases_for_selected(
list_of_variables=vc.inv_mass + vc.mc_truth,
decay_string='B0 -> ^D0 ^pi0') + \
vu.create_aliases_for_selected(
list_of_variables=vc.cluster,
decay_string='B0 -> D0 [pi0 -> ^gamma ^gamma]')
pi0_vars = vc.mc_truth + \
vc.kinematics + \
['extraInfo(BDT)', 'decayAngle(0)'] + \
vu.create_aliases_for_selected(
list_of_variables=vc.cluster + vc.kinematics,
decay_string='pi0 -> ^gamma ^gamma')
# Saving variables to ntuple
output_file = 'B2A302-B02D0Pi0-D02Pi0Pi0-Reconstruction.root'
ma.variablesToNtuple('B0:all',
ma.rankByHighest(particleList="D0",
variable="chiProb",
cut="first_D_rank == 1",
outputVariable="second_D_rank",
path=my_path)
va.variables.addAlias('second_D_rank', 'extraInfo(second_D_rank)')
# add rank variable aliases for easier use
va.variables.addAlias('dM_rank', 'extraInfo(abs_dM_rank)')
va.variables.addAlias('chiProb_rank', 'extraInfo(chiProb_rank)')
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='D0', path=my_path)
# Select variables that we want to store to ntuple
fs_hadron_vars = vu.create_aliases_for_selected(list_of_variables=vc.mc_truth,
decay_string='D0 -> ^K- ^pi+')
d0_vars = vc.vertex + \
vc.mc_vertex + \
vc.mc_truth + \
fs_hadron_vars + \
['dM', 'chiProb', 'dM_rank', 'chiProb_rank', 'D1_pi_p_rank', 'first_D_rank', 'second_D_rank']
# Saving variables to ntuple
output_file = 'B2A602-BestCandidateSelection.root'
ma.variablesToNtuple(decayString='D0',
variables=d0_vars,
filename=output_file,
treename='D0',
path=my_path)
# fit B vertex on the tag-side
vertex.TagV('B0', constraintType='tube', fitAlgorithm='Rave', path=main)
# perform best candidate selection
#b2.set_random_seed('USBelleIISummerSchool')
#ma.rankByHighest('B0', variable='random', numBest=1, path=main)
# create list of variables for output ntuple
standard_vars = vc.kinematics + vc.mc_kinematics + vc.mc_truth
fs_vars = vc.pid + vc.track + vc.track_hits + standard_vars
jpsi_ks_vars = vc.inv_mass + vc.vertex + vc.mc_vertex + standard_vars
b_vars = vc.deltae_mbc + vc.tag_vertex + vc.mc_tag_vertex + ft.flavor_tagging + standard_vars
b_vars += vu.create_aliases_for_selected([*fs_vars, 'isBremsCorrected'],
'B0 -> [J/psi -> ^e+ ^e-] K_S0',
prefix=['ep', 'em'])
b_vars += vu.create_aliases_for_selected(fs_vars,
'B0 -> J/psi [K_S0 -> ^pi+ ^pi-]',
prefix=['pip', 'pim'])
b_vars += vu.create_aliases_for_selected(jpsi_ks_vars, 'B0 -> ^J/psi ^K_S0')
cmskinematics = vu.create_aliases(vc.kinematics, 'useCMSFrame({variable})',
'CMS')
b_vars += vu.create_aliases_for_selected(
cmskinematics, '^B0 -> [^J/psi -> ^e+ ^e-] [^K_S0 -> ^pi+ ^pi-]')
variables.addAlias(
'withBremsCorrection',
'passesCut(passesCut(ep_isBremsCorrected == 1) or passesCut(em_isBremsCorrected == 1))'
)
# reconstruct D*+ -> D0 pi+ decay
# keep only candidates with Q = M(D0pi) - M(D0) - M(pi) < 20 MeV
# and D* CMS momentum > 2.5 GeV
ma.reconstructDecay(decayString='D*+ -> D0:kpi pi+:all',
cut='0.0 < Q < 0.2',
path=my_path)
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='D*+', path=my_path)
# Select variables that we want to store to ntuple
dstar_vars = vc.inv_mass + vc.mc_truth
fs_hadron_vars = vu.create_aliases_for_selected(
list_of_variables=vc.pid + vc.track + vc.mc_truth,
decay_string='D*+ -> [D0 -> ^K- ^pi+] ^pi+')
d0_vars = vu.create_aliases_for_selected(list_of_variables=vc.inv_mass +
vc.mc_truth,
decay_string='D*+ -> ^D0 pi+',
prefix='D0')
# Saving variables to ntuple
output_file = 'B2A301-Dstar2D0Pi-Reconstruction.root'
ma.variablesToNtuple('D*+',
dstar_vars + d0_vars + fs_hadron_vars,
filename=output_file,
treename='dsttree',
path=my_path)
outfile = sys.argv[2]
print(f"Input = {infile}")
print(f"Output = {outfile}")
ma.inputMdstList('default', [infile], path = mp)
eff = 60
stdSigmas(f'pi0eff{eff}', path = mp)
ma.matchMCTruth('Sigma+:std', path = mp)
va.addAlias('cosa', 'cosAngleBetweenMomentumAndVertexVector')
va.addAlias('cosaXY', 'cosAngleBetweenMomentumAndVertexVectorInXYPlane')
va.addAlias('abs_dM', 'abs(dM)')
va.addAlias('M_noupdate', 'extraInfo(M_noupdate)')
va.addAlias('p_noupdate', 'extraInfo(p_noupdate)')
ntuple = ['M', 'p', 'chiProb', 'cosa', 'cosaXY', 'dr', 'dz', 'distance', 'isSignal', 'genMotherPDG']
ntuple += ['IPX', 'IPY', 'IPZ']
ntuple += create_aliases_for_selected(['protonID', 'pionID', 'dr', 'dz', 'p', 'isSignal'],
'Sigma+ -> ^p+ pi0', prefix = ['p'])
ntuple += create_aliases_for_selected(['mcP', 'p', 'M', 'distance', 'isSignal', 'genMotherPDG', 'M_noupdate', 'p_noupdate'],
'Sigma+ -> p+ ^pi0', prefix = ['pi0'])
ma.variablesToNtuple('Sigma+:std', ntuple, treename = f'sigma_eff{eff}', filename = outfile, path = mp)
ma.fillParticleListFromMC('Sigma+:gen', '', path = mp)
ma.variablesToNtuple('Sigma+:gen', ['cosa', 'cosaXY', 'p', 'M'], treename = 'sigma_gen', filename = outfile, path = mp)
b2.process(path = mp)
print(b2.statistics)
ma.reconstructDecay(decayString='B0 -> rho0 gamma:tight',
cut='5.2 < Mbc < 5.29 and abs(deltaE) < 2.0',
path=my_path)
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='B0', path=my_path)
# Select variables that we want to store to ntuple
gamma_vars = vc.cluster + vc.mc_truth + vc.kinematics
rho_vars = vc.cluster + vc.mc_truth + vc.kinematics + vc.inv_mass
pi_vars = vc.pid + vc.track
b_vars = vc.kinematics + \
vc.deltae_mbc + \
vc.mc_truth + \
vu.create_aliases_for_selected(list_of_variables=gamma_vars,
decay_string='B0 -> rho0 ^gamma') + \
vu.create_aliases_for_selected(list_of_variables=rho_vars,
decay_string='B0 -> ^rho0 gamma') + \
vu.create_aliases_for_selected(list_of_variables=rho_vars,
decay_string='B0 -> [rho0 -> ^pi+ ^pi-] gamma')
# Saving variables to ntuple
rootOutputFile = 'B2A304-B02RhoGamma-Reconstruction.root'
ma.variablesToNtuple(decayString='B0',
variables=b_vars,
filename=rootOutputFile,
treename='b0',
path=my_path)
# Process the events
b2.process(my_path)
kinematic_vars = ['M', 'p', 'pt', 'pz', 'phi', 'theta', 'charge', 'xp']
vertex_vars = [
'cosa', 'cosaXY', 'chiProb', 'x', 'y', 'z', 'distance',
'significanceOfDistance'
]
track_vars = ['d0', 'z0', 'd0Err']
pid_vars = ['pid_ppi', 'pid_pk', 'pid_kpi']
event_vars = ['IPX', 'IPY', 'IPZ']
# Variables
# =============================================
# sigma+
sigma_vars = kinematic_vars + vertex_vars + mc_vars + track_vars
# proton
proton_vars = create_aliases_for_selected(kinematic_vars + track_vars +
pid_vars + mc_vars,
'Sigma+ -> ^p+ pi0',
prefix=['p'])
variables.addAlias('p_abs_d0', 'abs(p_d0)')
variables.addAlias('p_abs_z0', 'abs(p_z0)')
proton_vars += ['p_abs_d0', 'p_abs_z0']
# pi0
pi0_vars = create_aliases_for_selected(kinematic_vars + vertex_vars + mc_vars,
'Sigma+ -> p+ ^pi0',
prefix=['pi0'])
# gamma
gamma_vars = []
create_aliases_for_selected(['phi', 'theta', 'E', 'goodBelleGamma'],
'Sigma+ -> p+ [pi0 -> ^gamma ^gamma]',
prefix=['gamma1', 'gamma2'])
variables.addAlias('gamma_min_E', 'min(gamma1_E, gamma2_E)')
]
list_basics = ['M', 'p', 'pt', 'pz']
list_lambda = [
'distance', 'abs_dr', 'abs_dz', 'chiProb', 'cosa', 'cosaXY', 'min_daug_d0',
'min_daug_z0', 'goodBelleLambda', 'goodLambda'
]
list_pid = ['pid_ppi', 'pid_pk', 'pid_kpi']
list_event = ['IPX', 'IPY', 'IPZ']
# Variables
# =============================================
# Lambda0
list_ntuple = list_basics + list_lambda + list_event + list_mc
# proton and pion
list_ntuple += create_aliases_for_selected(list_basics + list_pid + list_mc,
'Lambda0 -> ^p+ ^pi-',
prefix=['p', 'pi'])
# Reconstruction
# ==============================================
# No reconstruction. Just MC match the Lambda0:mdst list
ma.vertexTree('Lambda0:mdst', 0, path=mp)
ma.matchMCTruth('Lambda0:mdst', path=mp)
ma.applyCuts('Lambda0:mdst', 'isSignal == 0', path=mp)
# Output
# =============================================
mp.add_module('VariablesToNtuple',
particleList='Lambda0:mdst',
variables=list_ntuple,
treeName='lambda',
eventVariables = ['thrust', 'M', 'tauPlusMCMode', 'tauMinusMCMode']
# -- tau candidate variables
# added vc.kinematics for taus
tauVariables = vc.inv_mass + vc.kinematics + vc.deltae_mbc
tauVariables += ['mcErrors', 'genMotherPDG', 'mcPDG', 'isSignal']
# -- track level variables
trackVariables = vc.kinematics + vc.pid + vc.track + vc.track_hits + vc.vertex
trackVariables += [
'theta', 'cosTheta', 'phi', 'charge', 'clusterE', 'EoverP', 'mcPDG'
]
variableList = vu.create_aliases_for_selected(list_of_variables=eventVariables,
decay_string='^vpho') + \
vu.create_aliases_for_selected(list_of_variables=tauVariables + ['charge'],
decay_string='vpho -> ^tau+ ^tau-') + \
vu.create_aliases_for_selected(list_of_variables=trackVariables,
decay_string= decay_chain)
if tauMinus == '1':
Outputfile = "tautau_mctruthsel_21_test.root"
if tauMinus == '3':
Outputfile = "tautau_mctruthsel_23_test.root"
ma.variablesToNtuple('vpho:photon_B2SS',
variables=variableList,
treename='tree',
filename=Outputfile,
ma.reconstructDecay(decayString='B+:D0pi -> anti-D0:all pi+',
cut='5.24 < Mbc < 5.29 and abs(deltaE) < 1.0',
dmID=1,
path=my_path)
# perform MC matching (MC truth asociation)
ma.matchMCTruth(list_name='B+:D0pi',
path=my_path)
# Select variables that we want to store to ntuple
d_vars = vc.inv_mass + vc.kinematics
pi_vars = vc.kinematics
b_vars = vc.deltae_mbc + \
vc.mc_truth + \
vu.create_aliases_for_selected(list_of_variables=d_vars,
decay_string='B+ -> ^anti-D0 pi+',
prefix='D0') + \
vu.create_aliases_for_selected(list_of_variables=pi_vars,
decay_string='B+ -> anti-D0 ^pi+',
prefix='pi') + \
vu.create_aliases(list_of_variables=['decayModeID'],
wrapper='daughter(0,extraInfo(variable))',
prefix="")
# Saving variables to ntuple
output_file = 'B2A303-MultipleDecays-Reconstruction.root'
ma.variablesToNtuple(decayString='B+:D0pi',
variables=b_vars,
filename=output_file,
treename='bp',
path=my_path)
