def simulation(input_file, output_file):
my_path = b2.create_path()
print(f"Number of processes: {b2.get_nprocesses()}")
# load input ROOT file
ma.inputMdst(environmentType="default", filename=input_file, path=my_path)
"""
Loads the specified ROOT (DST/mDST/muDST) files with the RootInput module.
The correct environment (e.g. magnetic field settings) are determined from the specified environment type.
The currently available environments are:
- 'MC5': for analysis of Belle II MC samples produced with releases prior to build-2016-05-01.
This environment sets the constant magnetic field (B = 1.5 T)
- 'MC6': for analysis of Belle II MC samples produced with build-2016-05-01 or newer but prior to release-00-08-00
- 'MC7': for analysis of Belle II MC samples produced with build-2016-05-01 or newer but prior to release-00-08-00
- 'MC8', for analysis of Belle II MC samples produced with release-00-08-00 or newer but prior to release-02-00-00
- 'MC9', for analysis of Belle II MC samples produced with release-00-08-00 or newer but prior to release-02-00-00
- 'MC10', for analysis of Belle II MC samples produced with release-00-08-00 or newer but prior to release-02-00-00
- 'default': for analysis of Belle II MC samples produced with releases with release-02-00-00 or newer.
This environment sets the default magnetic field (see geometry settings)
- 'Belle': for analysis of converted (or during of conversion of) Belle MC/DATA samples
- 'None': for analysis of generator level information or during simulation/my_reconstruction of
previously generated events
Note that there is no difference between MC6 and MC7. Both are given for sake of completion.
The same is true for MC8, MC9 and MC10
Parameters:
environmentType (str): type of the environment to be loaded
filename (str): the name of the file to be loaded
path (basf2.Path): modules are added to this path
skipNEvents (int): N events of the input files are skipped
entrySequences (list(str)): The number sequences (e.g. 23:42,101) defining
the entries which are processed for each inputFileName.
parentLevel (int): Number of generations of parent files (files used as input when creating a file) to be read
"""
# In case of conflict with geometry, you may use this line instead:
# analysis_main.add_module("RootInput", inputFileName='B2A101-Y4SEventGeneration-evtgen.root')
# simulation
si.add_simulation(path=my_path)
# my_reconstruction
re.add_reconstruction(path=my_path)
# dump in MDST format
mdst.add_mdst_output(path=my_path, mc=True, filename=output_file)
# Show progress of processing
progress = b2.register_module("ProgressBar")
my_path.add_module(progress)
# Process the events
b2.process(my_path)
print(b2.statistics)
# Contributors: Umberto Tamponi (October 2018) # [email protected] # #################################################################### import basf2 as b2 import modularAnalysis as ma import variables.collections # create path my_path = b2.create_path() # load input ROOT file ma.inputMdst(environmentType='default', filename=b2.find_file('B02D0pi0_D02pi0pi0.root', 'examples', False), path=my_path) # Creates a list of all the good tracks (using the pion mass hypothesys) # and good gammas with very minimal cuts ma.fillParticleList(decayString='pi+:all', cut='pt> 0.1', path=my_path) ma.fillParticleList(decayString='gamma:all', cut='E > 0.1', path=my_path) # Builds the event shape enabling explicitly ALL the variables. # Most of the are actually enabled by defoult, but here we prefer # to list explicitly all the flags
#
######################################################
from basf2 import *
from modularAnalysis import inputMdst
from modularAnalysis import printDataStore
from modularAnalysis import printList
from modularAnalysis import fillParticleListsFromMC
from modularAnalysis import printPrimaryMCParticles
from modularAnalysis import printVariableValues
from modularAnalysis import analysis_main
# load input ROOT file
# inputMdst('B0_etapr-eta-gg2pi_KS-pi+pi-_gsim-BKGx0.root')
inputMdst('../root_files/B0_etapr-eta-gg2pi_KS-pi0pi0_gsim-BKGx0.root')
# inputMdst('B0_etapr-eta-gg2pi_KL-_gsim-BKGx0.root')
# inputMdst('B0_etapr-eta-3pi2pi_KS-pi+pi-_gsim-BKGx0.root')
printPrimaryMCParticles()
# print contents of the DataStore before loading MCParticles
printDataStore()
# create and fill gamma/e/mu/pi/K/p ParticleLists
# second argument are the selection criteria: '' means no cut, take all
photons = ('gamma:gen', '')
electrons = ('e-:gen', '')
muons = ('mu-:gen', '')
pions = ('pi-:gen', '')
kaons = ('K-:gen', '')
kaonsneu = ('K_S0:gen', '')
# the MC files contain the desired processes/decays.
#
# Contributors: A. Zupanc (June 2014)
# I. Komarov (September 2018)
#
######################################################
import basf2 as b2
import modularAnalysis as ma
# create path
my_path = b2.create_path()
# load input ROOT file
ma.inputMdst(environmentType='default',
filename=b2.find_file('B2pi0D_D2hh_D2hhh_B2munu.root', 'examples',
False),
path=my_path)
# create charged kaon and pion particle lists with names "K-:gen" and "pi-:gen"
# all generated kaons(pions) will be added to the kaon(pion) list
ma.fillParticleListFromMC(decayString='K-:gen', cut='', path=my_path)
ma.fillParticleListFromMC(decayString='pi-:gen', cut='', path=my_path)
# print charge, energy and total momentum of generated kaons
# and x,y,z components of momenta for generated pions
#
# the list of all available variables can be obtained by executing
# basf2 analysis/scripts/variables/print_variables.py
ma.printVariableValues(list_name='K-:gen',
var_names=['charge', 'E', 'p'],
path=my_path)
# Contributors: A. Zupanc (June 2014)
#
######################################################
from basf2 import *
from modularAnalysis import inputMdst
from modularAnalysis import printDataStore
from modularAnalysis import printList
from modularAnalysis import fillParticleListsFromMC
from modularAnalysis import printPrimaryMCParticles
from modularAnalysis import printVariableValues
from modularAnalysis import analysis_main
# load input ROOT file
# inputMdst('B0_etapr-eta-gg2pi_KS-pi+pi-_gsim-BKGx0.root')
inputMdst('../root_files/B0_etapr-eta-gg2pi_KS-pi0pi0_gsim-BKGx0.root')
# inputMdst('B0_etapr-eta-gg2pi_KL-_gsim-BKGx0.root')
# inputMdst('B0_etapr-eta-3pi2pi_KS-pi+pi-_gsim-BKGx0.root')
printPrimaryMCParticles()
# print contents of the DataStore before loading MCParticles
printDataStore()
# create and fill gamma/e/mu/pi/K/p ParticleLists
# second argument are the selection criteria: '' means no cut, take all
photons = ('gamma:gen', '')
electrons = ('e-:gen', '')
muons = ('mu-:gen', '')
pions = ('pi-:gen', '')
kaons = ('K-:gen', '')
kaonsneu = ('K_S0:gen', '')
variables.addAlias('B0_hso02','KSFWVariables(hso02)')
#variables.addAlias('MCTagBFlavor','internalTagVMCFlavor')
variables.addAlias('CSMVA','extraInfo(CSMVA)')
variables.addAlias('XsdM','daughterInvM(0,1,2)')
variables.addAlias('pi0Likeness','extraInfo(Pi0_Prob)')
variables.addAlias('etaLikeness','extraInfo(Eta_Prob)')
variables.addAlias('cosThetaCMS','useCMSFrame(cosTheta)')
variables.addAlias('pCMS','useCMSFrame(p)')
variables.addAlias('ECMS','useCMSFrame(E)')
variables.addAlias('m12','daughterInvariantMass(0,1)')
variables.addAlias('m13','daughterInvariantMass(0,2)')
variables.addAlias('m23','daughterInvariantMass(1,2)')
main_path = b2.create_path() # Declaration of main path
bp.add_beamparameters(main_path,'Y4S')
ma.inputMdst('MC10', inputFilename, path=main_path)
sv.goodBelleKshort(path=main_path)
sg.stdPhotons('loose', path=main_path)
sc.stdPi('95eff', path=main_path)
ma.applyCuts('gamma:loose','1.4 < E < 4', path=main_path)
krescuts = " and daughterInvM(0,1,2) < 2 and daughterInvM(0,1) > 0.6 and daughterInvM(0,1) < 0.9"
#reconstructDecay(Kres+":all -> pi+:good pi-:good K_S0:all", krescuts)
ma.reconstructDecay("B0:signal -> pi+:95eff pi-:95eff K_S0:legacyGoodKS gamma:loose",
"Mbc > 5.2 and deltaE < 0.2 and deltaE > -0.2 and -0.65 < daughter(1, cosTheta) < 0.85"+krescuts, path=main_path)
ma.vertexRave('B0:signal',0.0001, 'B0 -> ^pi+ ^pi- ^K_S0 gamma', path=main_path)
#vertexTree('B0:signal',0.0001)
ma.rankByHighest('B0:signal',ratingVar, 1, outputVariable='myRating', path=main_path)
ma.buildRestOfEvent('B0:signal', path=main_path)
#
################################################################################
import basf2 as b2
import modularAnalysis as ma
import variables.collections as vc
import variables.utils as vu
from stdPhotons import stdPhotons
import stdCharged as stdc
# create path
my_path = b2.create_path()
# load input ROOT file
ma.inputMdst(environmentType='default',
filename=b2.find_file('B2rhogamma_rho2pipi.root', 'examples',
False),
path=my_path)
#
# creates "gamma:tight" ParticleList
stdPhotons(listtype='tight', path=my_path)
# creates "pi+:loose" ParticleList (and c.c.)
stdc.stdPi(listtype='loose', path=my_path)
# reconstruct rho -> pi+ pi- decay
# keep only candidates with 0.6 < M(pi+pi-) < 1.0 GeV
ma.reconstructDecay(decayString='rho0 -> pi+:loose pi-:loose',
cut='0.6 < M < 1.0',
path=my_path)
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)
import basf2 as b2
import modularAnalysis as ma
import variables.collections as vc
import variables.utils as vu
from variables import variables as var
import os
# create path
my_path = b2.create_path()
# load input ROOT file
ma.inputMdst(environmentType='default',
filename='kkmc_tautau_3.root',
path=my_path)
ma.printDataStore(path=my_path)
photons = ('gamma:gen', '')
electrons = ('e-:gen', 'charge == -1')
muons = ('mu-:gen', '')
taus = ('tau-:gen', '')
pions = ('pi-:gen', '')
nue = ('nu_e:gen', '')
numu = ('nu_mu:gen', '')
nutau = ('nu_tau:gen', '')
#anti_nu_mu = ('anti-nu_mu:gen','')
#anti_nu_e = ('anti-nu_me:gen','')
ma.fillParticleListsFromMC(
[photons, electrons, muons, taus, pions, nue, numu, nutau], path=my_path)
if step == 'signal':
input_file = [path + 'Bd_KsPi0_expert/*']
elif step == 'qqbar':
input_file = [path + '*bar_expert/*']
else:
sys.exit(
'Step does not match any of the available samples: `signal` or `qqbar`'
)
outfile = 'MVAExpert_fullNTuple_' + step + '.root'
# ---------------------------------------------------------------------------------------------
# Perform analysis.
main = b2.create_path()
ma.inputMdst(environmentType='default', filename=input_file, path=main)
ma.fillParticleList(decayString='gamma:all', cut='', path=main)
ma.fillParticleList(decayString='pi+:good',
cut='chiProb > 0.001 and pionID > 0.5',
path=main)
ma.fillParticleList(decayString='pi-:good',
cut='chiProb > 0.001 and pionID > 0.5',
path=main)
ma.reconstructDecay(decayString='K_S0 -> pi+:good pi-:good',
cut='0.480<=M<=0.516',
dmID=1,
path=main)
ma.reconstructDecay(decayString='pi0 -> gamma:all gamma:all',
cut='0.115<=M<=0.152',
inputFilename = sys.argv[1]
if len(sys.argv)==3:
inputFilename = sys.argv[1]
outputFilename = sys.argv[2]
add_beamparameters(analysis_main, 'Y4S')
# check if the required input file exists (from B2A101 example)
#if not os.path.isfile('B2A101-Y4SEventGeneration-evtgen.root'):
#if not os.path.isfile('evtgen.root'):
# sys.exit('Required input file (B2A101-Y4SEventGeneration-evtgen.root) does not exist. '
# 'Please run B2A101-Y4SEventGeneration.py tutorial script first.')
# load input ROOT file
#inputMdst('None', 'B2A101-Y4SEventGeneration-evtgen.root')
inputMdst('None', inputFilename)
# simulation
add_simulation(analysis_main, use_vxdtf2 = True)
# reconstruction
add_reconstruction(analysis_main, use_vxdtf2 = True)
# dump in MDST format
add_mdst_output(analysis_main, True, outputFilename)
# Show progress of processing
progress = register_module('ProgressBar')
analysis_main.add_module(progress)
# Process the events
import basf2 as b2
import modularAnalysis as ma
import flavorTagger as ft
import vertex as vx
import variables.collections as vc
import variables.utils as vu
import stdCharged as stdc
from stdPi0s import stdPi0s
# create path
my_path = b2.create_path()
# load input ROOT file
ma.inputMdst(environmentType='default',
filename=b2.find_file('B2JPsipi0_JPsi2mumu.root', 'examples',
False),
path=my_path)
# use standard final state particle lists
#
# creates "pi0:looseFit" ParticleList
# https://confluence.desy.de/display/BI/Physics+StandardParticles
stdPi0s(listtype='looseFit', path=my_path)
# creates "highPID" ParticleLists (and c.c.)
ma.fillParticleList(decayString='mu+:highPID',
cut='muonID > 0.2 and d0 < 2 and abs(z0) < 4',
path=my_path)
# reconstruct J/psi -> mu+ mu- decay
# keep only candidates with dM<0.11
ma.reconstructDecay(decayString='J/psi:mumu -> mu+:highPID mu-:highPID',
# I. Komarov (Demeber 2017)
# I. Komarov (September 2018)
#
################################################################################
import basf2 as b2
import modularAnalysis as ma
import variables.collections as vc
import variables.utils as vu
# create path
my_path = b2.create_path()
# load input ROOT file
ma.inputMdst(environmentType='default',
filename=b2.find_file('JPsi2ee_e2egamma.root', 'examples', False),
path=my_path)
# fill particleLists
ma.fillParticleList(decayString='e+:uncorrected',
cut='electronID > 0.2 and d0 < 2 and abs(z0) < 4',
path=my_path)
ma.fillParticleList(decayString='gamma:all',
cut='E < 1.0',
writeOut=False,
path=my_path)
# loose mc matching (recommended)
ma.looseMCTruth(list_name='e+:uncorrected', path=my_path)
ma.looseMCTruth(list_name='gamma:all', path=my_path)
from stdCharged import *
#from stdFSParticles import goodPi0
from stdFSParticles import stdPi0s
# check if the required input file exists (from B2A101 example)
import os.path
import sys
if not os.path.isfile('reco.root'):
sys.exit(
'Required input file (B2A101-Y4SEventGeneration-gsim-BKGx0.root) does not exist. '
'Please run B2A101-Y4SEventGeneration.py and B2A103-SimulateAndReconstruct-withoutBeamBkg.py '
'tutorial scripts first.')
# load input ROOT file
inputMdst('default', 'reco.root')
# print contents of the DataStore before loading Particles
printDataStore()
# create and fill gamma/e/mu/pi/K/p ParticleLists
# second argument are the selection criteria: '' means no cut, take all
# fillParticleList('gamma:all', '')
fillParticleList('e-:all', '')
fillParticleList('mu-:all', '')
fillParticleList('pi-:all', '')
fillParticleList('K-:all', '')
fillParticleList('anti-p-:all', '')
# alternatively, we can create and fill final state Particle lists only
# with candidates that pass certain PID requirements