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_path(self): path = basf2.create_path() modularAnalysis.setupEventInfo(self.n_events, path) if self.event_type == SimulationType.y4s: # in current main branch and release 5 the Y(4S)decay file is moved, so try old and new locations find_file_ignore_error = True dec_file = Belle2.FileSystem.findFile( 'analysis/examples/tutorials/B2A101-Y4SEventGeneration.dec', find_file_ignore_error) if not dec_file: dec_file = Belle2.FileSystem.findFile( 'analysis/examples/simulations/B2A101-Y4SEventGeneration.dec' ) elif self.event_type == SimulationType.continuum: dec_file = Belle2.FileSystem.findFile( 'analysis/examples/simulations/B2A102-ccbarEventGeneration.dec' ) else: raise ValueError( f"Event type {self.event_type} is not valid. It should be either 'Y(4S)' or 'Continuum'!" ) generators.add_evtgen_generator(path, 'signal', dec_file) modularAnalysis.loadGearbox(path) simulation.add_simulation(path) path.add_module('RootOutput', outputFileName=self.get_output_file_name( 'simulation_full_output.root')) 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.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 prepare(self): """ A function to prepare a path with the modules given in path. """ if self.path: # Append the needed ToFileLogger module created_path = basf2.create_path() file_logger_module = basf2.register_module("ToFileLogger") file_logger_module.param("fileName", self.log_file_name) created_path.add_module(file_logger_module) # Copy the modules from the path for module in self.path.modules(): created_path.add_module(module) # Add the progress python module created_path.add_module(python_modules.ProgressPython(self.progress_queue_remote)) # Add the print collections python module created_path.add_module(python_modules.PrintCollections(self.result_queue)) self.path = created_path else: self.is_valid = False
def prepare(self): """ A function to prepare a path with the modules given in path. """ if self.path: # Append the needed ToFileLogger module created_path = basf2.create_path() file_logger_module = basf2.register_module("ToFileLogger") file_logger_module.param("fileName", self.log_file_name) created_path.add_module(file_logger_module) # Copy the modules from the path for module in self.path.modules(): created_path.add_module(module) # Add the progress python module created_path.add_module( python_modules.ProgressPython(self.progress_queue_remote)) # Add the print collections python module created_path.add_module( python_modules.PrintCollections(self.result_queue)) self.path = created_path else: self.is_valid = False
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 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)
def create_path(self): path = basf2.create_path() path.add_module('RootInput', inputFileNames=self.get_input_file_names( "simulation_full_output.root")) modularAnalysis.loadGearbox(path) reconstruction.add_reconstruction(path) modularAnalysis.outputMdst( self.get_output_file_name("reconstructed_output.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
def submit_generation(n_events, dec_file, out_name, random_seed): # Command line args passed as strings, so ensure they're corrected to ints n_events = int(n_events) random_seed = int(random_seed) ge.set_random_seed(random_seed) my_path = b2.create_path() ma.setupEventInfo(noEvents=n_events, path=my_path) ge.add_evtgen_generator(path=my_path, finalstate="signal", signaldecfile=dec_file) ma.loadGearbox(path=my_path) my_path.add_module("RootOutput", outputFileName=out_name) b2.process(path=my_path) print(b2.statistics)
import glob import basf2 as b2 import modularAnalysis as ma from variables import variables as var import variables.collections as vc import variables.utils as vu import sys inputFile = glob.glob( '/home/belle2/atpathak/PhysicsAnalysis/work/skim_thrust_test/taupair/sub00/*.root' ) #inputFile = glob.glob('/home/belle2/atpathak/PhysicsAnalysis/work/tau_analysis/kkmc_tautau.root') my_path = b2.create_path() tauPlus = sys.argv[1] tauMinus = sys.argv[2] #b2.use_central_database("data_reprocessing_prompt_bucket6") ma.inputMdstList(environmentType='default', filelist=inputFile, path=my_path) b2.set_module_parameters(path=my_path, name='RootInput', cacheSize=100) ###################################################### # create and fill the ParticleLists ###################################################### ma.fillParticleList('e-:all', '', path=my_path) ma.fillParticleList('mu+:all', '', path=my_path) ma.fillParticleList('pi-:all', '', path=my_path)
def my_path(): return b2.create_path()
'BELLE2_EXTERNALS_DIR', 'BELLE2_EXTERNALS_SUBSIR', 'BELLE2_EXTERNALS_OPTION', 'BELLE2_EXTERNALS_VERSION', 'BELLE2_LOCAL_DIR', 'BELLE2_OPTION', 'BELLE_POSTGRES_SERVER', 'USE_GRAND_REPROCESS_DATA', 'PANTHER_TABLE_DIR', 'PGUSER' ] # Print env variables for check print("Environmental Variables".center(80, '=')) for v in env_list: print_env(v) # Show input and output file info print("Input: %s" % sys.argv[1]) print("Ouput: %s" % sys.argv[2]) mp = b2.create_path() b2c.convertBelleMdstToBelleIIMdst(sys.argv[1], applyHadronBJSkim=True, path=mp) # Aliases for the variables to make the root file easier to understand variables.addAlias('pid_ppi', 'atcPIDBelle(4,2)') variables.addAlias('pid_pk', 'atcPIDBelle(4,3)') variables.addAlias('pid_kpi', 'atcPIDBelle(3,2)') variables.addAlias('cosa', 'cosAngleBetweenMomentumAndVertexVector') variables.addAlias('cosaXY', 'cosAngleBetweenMomentumAndVertexVectorInXYPlane') mc_vars = [ 'isSignal', 'isPrimarySignal', 'mcPDG', 'genMotherPDG', 'nMCMatches', 'mcP', 'mcE', 'mcPT' ]
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
def makeFSPs(input_file, isdata): path = b2.create_path() inputMdstList(environmentType='default', filelist=input_file, path=path) printDataStore(path=path) # path.add_module('EventInfoPrinter') variables.addAlias('pi_k', 'pidPairProbabilityExpert(211, 321, ALL)') variables.addAlias('k_pi', 'pidPairProbabilityExpert(321, 211, ALL)') # electron impactcut = 'abs(d0)<0.5 and abs(z0)<2.0 ' # NOTE For BtoXll skim # event level cuts: R2 and require a minimum number of tracks fillParticleList(decayString='pi+:eventShapeForSkims', cut='pt > 0.1', path=path) fillParticleList(decayString='gamma:eventShapeForSkims', cut='E > 0.1', path=path) buildEventShape(inputListNames=['pi+:eventShapeForSkims', 'gamma:eventShapeForSkims'], allMoments=False, foxWolfram=True, harmonicMoments=False, cleoCones=False, thrust=False, collisionAxis=False, jets=False, sphericity=False, checkForDuplicates=False, path=path) fillParticleList(decayString='e+:all', cut=impactcut + ' and electronID > 0.5', path=path) # muon fillParticleList(decayString='mu+:all', cut=impactcut + ' and muonID > 0.5', path=path) # pion fillParticleList(decayString='pi+:all', cut=impactcut + ' and pi_k>0.1', path=path) # kaon fillParticleList(decayString='K+:all', cut=impactcut + ' and k_pi>0.1', path=path) # gamma fillParticleList(decayString='gamma:all', cut='', path=path) if isdata: print(yellow, 'Momentum correction for FSPs', end) trackingMomentum(inputListNames=['mu+:all', 'e+:all', 'K+:all', 'pi+:all'], scale=1.00056, path=path) # Bremrecovery correctBremsBelle('e-:corrected', 'e-:all', 'gamma:all', True, 0.05, 0.05, False, path=path) # Ks0 stdKshorts( path=path) cutAndCopyList('K_S0:my_ks', 'K_S0:merged', 'goodBelleKshort==1', writeOut=False, path=path) matchMCTruth(list_name='K_S0:my_ks', path=path) # pi0 stdPhotons('all', path=path) cutAndCopyList( 'gamma:eff30_Jan2020', 'gamma:all', '[clusterReg==1 and E>0.080] or [clusterReg==2 and E>0.030] or [clusterReg==3 and E>0.060]', path=path) reconstructDecay('pi0:all -> gamma:eff30_Jan2020 gamma:eff30_Jan2020', '0.1215 < M < 0.1415 and E > 0.4 and abs(cosHelicityAngleMomentum)<0.8', path=path) #vertex.KFit('pi0:all', conf_level=0.0, path=path) vertex.KFit('pi0:all', conf_level=0.0,fit_type='mass', path=path) # K*0->K+ pi- reconstructDecay(decayString='K*0:all -> K+:all pi-:all', cut='0.6 < M < 1.2', path=path) matchMCTruth(list_name='K*0:all', path=path) # K*+ -> K_s pi+ reconstructDecay(decayString='K*+:ks -> K_S0:my_ks pi+:all', cut='0.6 < M < 1.2', path=path) matchMCTruth(list_name='K*+:ks', path=path) # K*+ -> K+ pi0 reconstructDecay(decayString='K*+:pi0 -> K+:all pi0:all', cut='0.6 < M < 1.2', path=path) matchMCTruth(list_name='K*+:pi0', path=path) return path
import mdst as mdst import reconstruction as re import modularAnalysis as ma from ROOT import Belle2 # set the log level ma.set_log_level(ma.LogLevel.INFO) # set the correct GT, not needed for local runs taken with PocketDAQ ma.reset_database() ma.use_database_chain() ma.use_central_database('data_reprocessing_prompt_snapshot_01252019', ma.LogLevel.INFO) # create the main path and also an empty path main_path = b2.create_path() # add input and the progress bar inputFileName = glob.glob(inputPath + '*.sroot*') main_path.add_module('SeqRootInput', inputFileNames=inputFileName) main_path.add_module('Progress') main_path.add_module('ProgressBar') # set the geometry main_path.add_module('Gearbox') main_path.add_module('Geometry', useDB=True) # unpack bklm raw dawa main_path.add_module('BKLMUnpacker') # analyze bklm digits
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)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import basf2 as b2 # noqa import modularAnalysis as ma # noqa main = b2.create_path() main.add_module('RootInput', recovery=True) main.add_module('RootOutput') b2.process(main)
dest='threshold') args = parser.parse_args() assert (len(args.model) == len( args.model_type)), 'MODEL files must have exactly on TYPE each' # User output print("\nSettings:") if args.decay_file: print("Input file set to:\t" + args.decay_file) print("Trained model loaded:\t" + str(args.model)) print("Number of events to generate:\t" + str(args.num_events)) # Need to fetch output directory from basf2 -o flag and create it main = b2.create_path() # ma.setupEventInfo(args.num_events, path=main) # Need to input decay file with Y4S -> B0 B0 if I want mixed bkg? if args.decay_file: # add_evtgen_generator(main, 'signal', args.decay_file) # Deprecated ma.generateY4S(noEvents=args.num_events, decayTable=args.decay_file, path=main) else: # Annoying, need to add flag for this shit now # add_evtgen_generator(main, 'mixed') ma.generateY4S(noEvents=args.num_events, path=main) # Override event number -- use skip-events flag for basf2 instead -- easy in htcondor
variables.addAlias('B0_ThrustB','thrustBm') variables.addAlias('B0_cc4','CleoConeCS(4)') 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)
#!/usr/bin/env python3 import basf2 import modularAnalysis import pdg path = basf2.create_path() # Base definitions of stable particles and detector data particles = ['K+', 'pi+', 'e+', 'mu+', 'p+', 'deuteron'] detectors = ['svd', 'cdc', 'top', 'arich', 'ecl', 'klm', 'all', 'default'] # Default list of variables which should be exported to the root file root_vars = [ 'isSignal', 'mcErrors', 'mcPDG', 'mcDX', 'mcDY', 'mcDZ', 'isPrimarySignal' ] root_vars += [ 'p', 'pErr', 'phi', 'phiErr', 'pt', 'ptErr', 'cosTheta', 'cosThetaErr', 'Theta', 'ThetaErr', 'charge' ] root_vars += [ 'd0', 'd0Err', 'z0', 'z0Err', 'firstPXDLayer', 'firstSVDLayer', 'nCDCHits', 'nPXDHits', 'nSVDHits', 'nVXDHits', 'omega', 'omegaErr', 'pValue', 'phi0', 'phi0Err', 'tanlambda', 'tanlambdaErr' ] root_vars += [ 'kaonID', 'pionID', 'electronID', 'muonID', 'protonID', 'deuteronID' ] # Import mdst file and fill particle list without applying any cuts modularAnalysis.inputMdstList("default", ['sample.mdst.root'], path=path)
# # Contributors: A. Zupanc (June 2014) # K. Ota (Oct 2017) # I. Komarov (December 2017) # I. Komarov (September 2018) # ################################################################################ import basf2 as b2 import modularAnalysis as ma import variables.collections as vc import variables.utils as vu 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) ma.fillParticleList(decayString='gamma:highE', cut='E > 1.5', path=my_path) ma.fillParticleList(decayString='pi+:loose', cut='abs(d0) < 0.5 and abs(z0) < 0.5 and pionID > 0.002', 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',
else: self.return_value(0) # set the global log level ma.set_log_level(ma.LogLevel.INFO) # set the correct GT ma.reset_database() ma.use_database_chain() #ma.use_central_database("staging_data_reprocessing", ma.LogLevel.WARNING) #ma.use_central_database('data_reprocessing_prompt_bucket6', ma.LogLevel.INFO) ma.use_central_database('data_reprocessing_prompt_snapshot_02182019', ma.LogLevel.INFO) # create the main path and also an empty path main_path = b2.create_path() empty_path = b2.create_path() # add input and the progress bar if useSroot: inputFileName = glob.glob(inputPath + '*.*.*.*.*.sroot') main_path.add_module('SeqRootInput', inputFileNames=inputFileName) else: inputFileName = glob.glob(inputPath + '*.*.*.*.*.root') main_path.add_module('RootInput', inputFileNames=inputFileName) main_path.add_module('Progress') main_path.add_module('ProgressBar') # set geometry w/o the magnetic field main_path.add_module('Gearbox') main_path.add_module('Geometry',