def create_path(self):
path = basf2.create_path()
modularAnalysis.inputMdstList(
'default',
self.get_input_file_names("reconstructed_output.root"),
path=path)
modularAnalysis.fillParticleLists([('K+', 'kaonID > 0.1'),
('pi+', 'pionID > 0.1')],
path=path)
modularAnalysis.reconstructDecay('D0 -> K- pi+',
'1.7 < M < 1.9',
path=path)
modularAnalysis.matchMCTruth('D0', path=path)
modularAnalysis.reconstructDecay('B- -> D0 pi-',
'5.2 < Mbc < 5.3',
path=path)
try: # treeFit is the new function name in light releases after release 4 (e.g. light-2002-janus)
vertex.treeFit('B+', 0.1, update_all_daughters=True, path=path)
except AttributeError: # vertexTree is the function name in release 4
vertex.vertexTree('B+', 0.1, update_all_daughters=True, path=path)
modularAnalysis.matchMCTruth('B-', path=path)
modularAnalysis.variablesToNtuple(
'D0', [
'M', 'p', 'E', 'useCMSFrame(p)', 'useCMSFrame(E)',
'daughter(0, kaonID)', 'daughter(1, pionID)', 'isSignal',
'mcErrors'
],
filename=self.get_output_file_name("D_n_tuple.root"),
path=path)
modularAnalysis.variablesToNtuple(
'B-', ['Mbc', 'deltaE', 'isSignal', 'mcErrors', 'M'],
filename=self.get_output_file_name("B_n_tuple.root"),
path=path)
return path
def create_path(self):
path = basf2.create_path()
modularAnalysis.inputMdstList(
'default',
self.get_input_file_names("reconstructed_output.root"),
path=path)
modularAnalysis.fillParticleLists([('K+', 'kaonID > 0.1'),
('pi+', 'pionID > 0.1')],
path=path)
modularAnalysis.reconstructDecay('D0 -> K- pi+',
'1.7 < M < 1.9',
path=path)
modularAnalysis.fitVertex('D0', 0.1, path=path)
modularAnalysis.matchMCTruth('D0', path=path)
modularAnalysis.reconstructDecay('B- -> D0 pi-',
'5.2 < Mbc < 5.3',
path=path)
modularAnalysis.fitVertex('B+', 0.1, path=path)
modularAnalysis.matchMCTruth('B-', path=path)
modularAnalysis.variablesToNtuple(
'D0', [
'M', 'p', 'E', 'useCMSFrame(p)', 'useCMSFrame(E)',
'daughter(0, kaonID)', 'daughter(1, pionID)', 'isSignal',
'mcErrors'
],
filename=self.get_output_file_name("D_n_tuple.root"),
path=path)
modularAnalysis.variablesToNtuple(
'B-', ['Mbc', 'deltaE', 'isSignal', 'mcErrors', 'M'],
filename=self.get_output_file_name("B_n_tuple.root"),
path=path)
return path
def create_analysis_path(
b_ntuple_filename="B_ntuple.root",
d_ntuple_filename="D_ntuple.root",
mbc_range=(5.2, 5.3),
):
"""
Example of a minimal reconstruction with a cut as a changeable function
parameter, adapted from code in the ``B2T_Basics_3_FirstAnalysis.ipynb``
notebook from b2 starter kit.
"""
path = basf2.create_path()
# this local inputMdstList will only be used when this steerig file is run locally, gbasf2 overrides it
local_input_files = [
"/group/belle2/dataprod/MC/MC13a/prod00009434/s00/e1003/4S/r00000/mixed/mdst/sub00/mdst_000001_prod00009434_task10020000001.root"
]
mA.inputMdstList(
environmentType="default",
filelist=local_input_files,
path=path,
)
stdK("higheff", path=path)
stdPi("higheff", path=path)
mA.reconstructDecay('D0:Kpi -> K-:higheff pi+:higheff',
'1.7 < M < 1.9',
path=path)
# use try except to have this code work for both the old and new function names for the tree fit
mA.matchMCTruth('D0:Kpi', path=path)
mA.reconstructDecay('B- -> D0:Kpi pi-:higheff',
f"{mbc_range[0]} < Mbc < {mbc_range[1]}",
path=path)
try:
vx.treeFit('B+', 0.1, path=path)
except AttributeError:
vx.vertexTree('B+', 0.1, path=path)
mA.setAnalysisConfigParams({"mcMatchingVersion": "BelleII"}, path)
mA.matchMCTruth('B-', path=path)
vm.addAlias("p_cms",
"useCMSFrame(p)") # include aliases to test if they work
vm.addAlias("E_cms", "useCMSFrame(E)")
mA.variablesToNtuple('D0:Kpi', [
'M', 'p', 'E', 'E_cms', 'p_cms', 'daughter(0, kaonID)',
'daughter(1, pionID)', 'isSignal', 'mcErrors'
],
filename=d_ntuple_filename,
treename="D",
path=path)
mA.variablesToNtuple('B-', ['Mbc', 'deltaE', 'isSignal', 'mcErrors', 'M'],
filename=b_ntuple_filename,
treename="B",
path=path)
return path
# 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)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
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
if __name__ == '__main__':
infile, outfile = sys.argv[1], sys.argv[2]
mypath = b2.create_path()
b2c.convertBelleMdstToBelleIIMdst(infile, path=mypath)
reconstructLambda('Lambda0:belle',
match=True,
only='background',
path=mypath)
ntuple = make_ntuple()
ma.variablesToNtuple('Lambda0:belle',
ntuple,
'Lambda',
outfile,
path=mypath)
b2.process(path=mypath)
ma.buildEventShape(inputListNames=['pi+:all', 'gamma:all'],
allMoments=True,
foxWolfram=True,
harmonicMoments=True,
cleoCones=True,
thrust=True,
collisionAxis=True,
jets=True,
sphericity=True,
checkForDuplicates=False,
path=my_path)
# Here we use the pre-defined collection 'event_shape', that contains
# thrust, sphericity, aplanarity, FW ratios up to 4, harmonic moments w/respect to
# the thrust axis up to 4 and all the cleo cones w/respect to the thrust axis.
# In addition, we will save also the forward and backward hemisphere (or "jet") energies,
# and the 2nd order harmonic moment calculate respect to the collision axis (i.e. the z axis)
ma.variablesToNtuple('',
variables=['event_shape',
'backwardHemisphereEnergy',
'forwardHemisphereEnergy',
'harmonicMoment(2, collision)'],
filename='B2A704-EventShape.root',
path=my_path)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
v0_vars = vc.kinematics + \
vc.inv_mass + \
vc.vertex +\
vc.mc_truth + \
['chiProb'] +\
vu.create_daughter_aliases(pi0_vars, 0) +\
vu.create_daughter_aliases(pi0_vars, 1)
# saving variables to ntuple
rootOutputFile = 'load_v0.root'
# K_S0 from V0s
ma.variablesToNtuple(treename='kshort_v0',
decayString='K_S0:V0',
variables=v0_vars,
filename=rootOutputFile,
path=my_path)
# K_S0 from reconstructDecay
ma.variablesToNtuple(treename='kshort_rd',
decayString='K_S0:RD',
variables=v0_vars,
filename=rootOutputFile,
path=my_path)
# K_S0 from standard list (=V0s, see stdV0s.py)
ma.variablesToNtuple(treename='kshort_std',
decayString='K_S0:all',
variables=v0_vars,
filename=rootOutputFile,
'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))'
)
b_vars += ['withBremsCorrection']
# save variables to an ntuple
ma.variablesToNtuple('B0',
variables=b_vars,
filename='Bd2JpsiKS_ee.root',
treename='tree',
path=main)
# process the events
b2.process(main)
# print out the summary
print(b2.statistics)
]
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)
ma.fillParticleListFromMC('Sigma+:gen', '', path=mp)
ma.variablesToNtuple('Sigma+:gen', ['distance', 'p', 'M'],
treename='sigma_gen',
filename=outfile,
path=mp)
b2.process(path=mp)
print(b2.statistics)
def reconstruction(input_file, output_file):
my_path = b2.create_path()
ma.inputMdst("default", input_file, my_path)
# Find decay name from the input file name
decay_name = "_".join(input_file.split("/")[-1].split("_")[0:2])
# Load configuration file
config = yaml.safe_load(open("config/reco_config.yaml"))
options = config[decay_name]
# Parse list of subdecays in decay chain
decays = options["sub_decays"]
decays = DecayList(decays)
# Create particle lists for final state particles
fsps = decays.get_fsps()
for particle in fsps:
ma.fillParticleList(particle, "", path=my_path)
# Reconstruct requested decay chains
for decay in decays:
ma.reconstructDecay(str(decay), "", path=my_path)
# Perform truth matching for requested particles
truth_match_particles = decays.mothers
for truth_match_particle in truth_match_particles:
ma.looseMCTruth(truth_match_particle, path=my_path)
# Perform vertex fitting
head = decays.get_head()
vtx_decay_string = decays.get_chain()
print(vtx_decay_string)
vx.vertexRave(head, 0, vtx_decay_string, constraint="iptube", path=my_path)
# ma.rankByLowest("B0", 'chiProb', numBest=3, outputVariable='B_vtx_rank', path=my_path)
# ma.variables.addAlias('B_vtx_rank', 'extraInfo(B_vtx_rank)')
ma.buildRestOfEvent(head, path=my_path)
# Tag-side
vx.TagV(head, "breco", 0.001, path=my_path)
ma.buildEventKinematics(path=my_path)
ma.buildEventShape(path=my_path)
# Create centre-of-mass frame variables
cms_kinematics = vu.create_aliases(
vc.kinematics, "useCMSFrame({variable})", prefix="CMS"
)
variables = [
item
for sublist in [
vc.kinematics,
cms_kinematics,
vc.deltae_mbc,
vc.inv_mass,
vc.event_shape,
vc.vertex,
vc.mc_truth,
vc.mc_kinematics,
vc.mc_vertex,
vc.mc_tag_vertex,
]
for item in sublist
]
trees = yaml.safe_load(open("config/tree_names.yaml"))
for particle in decays.all_particles:
ma.variablesToNtuple(
particle,
variables,
filename=output_file,
treename=trees[particle],
path=my_path,
)
b2.process(my_path)
print(b2.statistics)
def reconstruct(infile='default.root', outfile='output_beta.root', path=None):
"""
Args:
infile: Input file name (use overwrite from basf2)
outfile: output file name (use overwrite from basf2)
path: (optional) basf2 path
Returns:
path
"""
setup()
# EXAMPE RECONSTRUCTION CODE
# DELETE OR MODIFY FROM HERE
just_an_example = True
if just_an_example:
with open(outfile, 'w') as f:
f.write("Proccessed example input " + infile)
else:
path = b2.create_path() if path is None else path
# Input file
ma.inputMdstList("default", infile, path=path)
# Event level cuts examples
ma.applyEventCuts('R2EventLevel<0.6 and nTracks>=3', path=path)
#
# Load Primary particles
#
from stdPhotons import stdPhotons
stdPhotons('cdc', path)
ma.cutAndCopyList('gamma:sig', 'gamma:cdc',
'clusterNHits > 1.5 and E > 1.5', True, path)
from stdPi0s import stdPi0s
stdPi0s('eff20', path)
# Loading charged tracks
good_track = 'thetaInCDCAcceptance and nCDCHits>20 and dr < 0.5 and abs(dz) < 2'
ma.fillParticleList("pi+:sig",
good_track + " and pionID > 0.0",
path=path)
ma.fillParticleList("K+:sig",
good_track + " and kaonID > 0.0",
path=path)
#
# Combine particles
#
ma.reconstructDecay('K*0:sig -> K+:sig pi-:sig',
'0.6 < M < 1.6',
path=path)
ma.reconstructDecay('B0:sig -> K*0:sig gamma:sig',
'5.22 < Mbc < 5.3 and abs(deltaE)< 1',
path=path)
# Final Calculateions
ma.rankByHighest("B0:ch1",
"formula(-1*abs(deltaE))",
outputVariable='Rank_deltaE',
path=path)
ma.buildEventShape(allMoments=True, path=path)
ma.matchMCTruth("B0:sig", path=path)
#
# Write out Ntuples
#
all_vars = get_variables()
ma.variablesToNtuple('B0:ch1',
all_vars,
filename=outfile,
treename="B0",
path=path)
# TO HERE
#ma.printMCParticles(path=path)
return path
# variables to ntuple
vars = ['combinationID',
'deltaPhi',
'deltaPhiCMS',
'deltaTheta',
'charge_0',
'charge_1',
'clusterE_0',
'clusterE_1',
'clusterTheta_0',
'clusterTheta_1',
'clusterPhi_0',
'clusterPhi_1',
'clusterECMS_0',
'clusterECMS_1',
'clusterPhiCMS_0',
'clusterPhiCMS_1',
'clusterThetaCMS_0',
'clusterThetaCMS_1'
]
# store variables
variablesToNtuple('vpho:bhabha', vars, filename='bhabha.root', path=mypath)
# Process the events
b2.process(mypath)
# print out the summary
print(b2.statistics)
readonly=True)
# We know what weight info will be added (see B2A904),
# so we add aliases and add it ot tools
va.variables.addAlias('Weight', 'extraInfo(' + weight_table_id + '_Weight)')
va.variables.addAlias('StatErr', 'extraInfo(' + weight_table_id + '_StatErr)')
va.variables.addAlias('SystErr', 'extraInfo(' + weight_table_id + '_SystErr)')
va.variables.addAlias('binID', 'extraInfo(' + weight_table_id + '_binID)')
# We configure weighing module
reweighter = b2.register_module('ParticleWeighting')
reweighter.param('tableName', weight_table_id)
reweighter.param('particleList', 'pi+:gen')
my_path.add_module(reweighter)
pivars = ['p', 'pz', 'Weight', 'StatErr', 'SystErr', 'binID']
# Saving variables to ntuple
output_file = 'B2A905-ApplyWeightsToTracks.root'
ma.variablesToNtuple(decayString='pi+:gen',
variables=pivars,
treename='pion',
filename=output_file,
path=my_path)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
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,
path=my_path)
#ma.variablesToNtuple(decayString='mu-:gen', variables=variableList, treename='tree2', filename=output_file, path=my_path)
b2.process(my_path)
# print out the summary
print(b2.statistics)
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',
B0_vars,
filename=output_file,
treename='b0',
path=my_path)
ma.variablesToNtuple('pi0:looseFit',
pi0_vars,
filename=output_file,
treename='pi0',
path=my_path)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
#####################################################
# -- event based variables
##################################################
var.addAlias('nDaug', 'countDaughters(1>0)')
#var.addAlias('InvMass', '')
eventVariables = ['thrust', 'M', 'tauPlusMCMode', 'tauMinusMCMode', 'nDaug']
tauVariables = ['p', 'px', 'py', 'pz', 'E', 'PDG', 'pt', 'M', 'EoverP']
# -- 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)
ma.variablesToNtuple('vpho:photon_B2SS',
variables=variableList,
treename='tree',
filename='tau_Generator_analysis_4.root',
path=my_path)
b2.process(my_path, max_event=50000)
vc.inv_mass + \
vc.vertex + \
vc.mc_vertex + \
vc.pid + \
vc.mc_truth + \
['dr', 'dz', 'isSignal', 'chiProb']
pi0_variables = vc.mc_truth + \
vc.kinematics + \
['extraInfo(BDT)', 'decayAngle(0)']
# Saving variables to ntuple
output_file = 'load_recon.root'
ma.variablesToNtuple(decayString='pi+:all',
variables=charged_particle_variables,
treename='pion',
filename=output_file,
path=my_path)
ma.variablesToNtuple(decayString='K+:all',
variables=charged_particle_variables,
treename='kaon',
filename=output_file,
path=my_path)
ma.variablesToNtuple(decayString='e+:all',
variables=charged_particle_variables,
treename='elec',
filename=output_file,
path=my_path)
ma.variablesToNtuple(decayString='mu+:all',
variables=charged_particle_variables,
treename='muon',
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)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
# need to be flattened before training to 0 or 1
NNApplyModule_m = NNApplyModule(
model_file=args.model,
model_type='combined-wideCNN',
threshold=0.,
# threshold=args.threshold,
extra_info_var='smartBKG')
# dead_path = b2.create_path()
# NNApplyModule_m.if_false(dead_path)
path.add_module(NNApplyModule_m)
# We'll keep just one Btag per event and train on that
ma.rankByHighest(particle_list,
'extraInfo(SignalProbability)',
outputVariable='FEIProbabilityRank',
numBest=1,
path=path)
# Write output
# ma.variablesToNTuple(
ma.variablesToNtuple(
decayString=particle_list,
variables=B_vars,
filename=args.out_file,
path=path,
)
b2.process(path)
print(b2.statistics)
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)
# print out the summary
print(b2.statistics)
print(event_vars)
# Apply the smartBKG NN model
# Will use extraInfo saved as training labels later,
# need to be flattened before training to 0 or 1
NNApplyModule_m = NNApplyModule(
model_file=args.model,
model_type='combined-wideCNN',
threshold=0.,
# threshold=args.threshold,
extra_info_var='smartBKG'
)
# dead_path = b2.create_path()
# NNApplyModule_m.if_false(dead_path)
path.add_module(NNApplyModule_m)
# Write output
# ma.variablesToNTuple(
ma.variablesToNtuple(
decayString='',
variables=event_vars,
filename=args.out_file,
path=path,
)
b2.process(path)
print(b2.statistics)
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+:loose',
ntuple,
treename='sigma',
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)
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)
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
rootOutputFile = 'B2A305-Btag+SingleMuon-Reconstruction.root'
ma.variablesToNtuple(decayString='B-:tag',
variables=b_vars,
filename=rootOutputFile,
treename='btag',
path=my_path)
ma.variablesToNtuple(decayString='Upsilon(4S)',
variables=u4s_vars,
filename=rootOutputFile,
treename='btagbsig',
path=my_path)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
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)
# Load the input skim file
path = ma.create_path()
ma.inputMdstList('MC9', filelist=[], path=path)
# Build some event specific ROE and continuum vars
ma.buildRestOfEvent(particle_list, path=path)
ROEMask = ('ROE', IPtrack_cut, gamma_cut)
ma.appendROEMasks(particle_list, [ROEMask], path=path)
ma.buildContinuumSuppression(particle_list, roe_mask='ROE', path=path)
B_vars += ROE_vars
print(B_vars)
# Then choose one candidate per event
# Dont' need to, want to view changes to candidates overall
# But let's try for fun
ma.rankByHighest(particle_list, 'extraInfo(SignalProbability)',
outputVariable='FEIProbabilityRank', path=path)
ma.applyCuts(particle_list, 'extraInfo(FEIProbabilityRank) == 1', path=path)
# Write output
ma.variablesToNtuple(
particle_list,
B_vars,
filename=args.out_file,
path=path,
)
b2.process(path)
print(b2.statistics)
'KSFWVariables(hso22)',
'KSFWVariables(hso24)',
'KSFWVariables(hoo0)',
'KSFWVariables(hoo1)',
'KSFWVariables(hoo2)',
'KSFWVariables(hoo3)',
'KSFWVariables(hoo4)',
'cleoConeThrust0',
'cleoConeThrust1',
'cleoConeThrust2',
'cleoConeThrust3',
'cleoConeThrust4',
'cleoConeThrust5',
'cleoConeThrust6',
'cleoConeThrust7',
'cleoConeThrust8',
]
# Save target variable necessary for training.
targetVar = ['isNotContinuumEvent']
# Create output file.
ma.variablesToNtuple(decayString='B0',
variables=trainVars + targetVar,
treename='tree',
filename=outfile,
path=my_path)
b2.process(my_path)
print(b2.statistics)
vm.addAlias('dxDstar', 'dx')
vm.addAlias('dyDstar', 'dy')
vm.addAlias('dzDstar', 'dz')
vm.addAlias('pDstar', 'p')
vm.addAlias('eDstar', 'E')
vm.addAlias('eCmsDstar', 'useCMSFrame(E)')
vm.addAlias('mDstar', 'M')
vm.addAlias('mD', 'daughter(0,M)')
vm.addAlias('slowPiID', 'daughter(1,pionID)')
Vars = [ 'xDstar', 'yDstar', 'zDstar', 'xGenDstar', 'yGenDstar', 'zGenDstar', 'dxDstar', 'dyDstar', 'dzDstar', 'pDstar', 'eDstar', 'eCmsDstar', 'mDstar', 'mD', 'slowPiID']
Vars.append('isSignal')
Vars.append('IPX')
Vars.append('IPCov(0,0)')
# Match to the MC truth information
ma.matchMCTruth('D*+:my', path=path)
ma.variablesToNtuple('D*+:my', Vars,
filename='nTupleNo.root', treename="Dstar", path=path)
b2.process(path, max_event=100000)
print(b2.statistics)
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,
path=my_path)
b2.process(my_path, max_event=50000)
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)
# Process the events
b2.process(my_path)
# print out the summary
print(b2.statistics)
# If you want to calculate the efficiency of the FlavorTagger on your own
# File use the script analysis/examples/FlavorTaggerEfficiency.py giving
