from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process('target_pn')
from LDMX.Biasing import target
from LDMX.SimCore import generators
import LDMX.Ecal.EcalGeometry
p.sequence = [
target.photo_nuclear(
'ldmx-det-v12' ,
generators.single_4gev_e_upstream_tagger()
)
]
p.maxEvents = 1000
p.outputFiles = [ '/tmp/target_pn.root' ]
parser = argparse.ArgumentParser(description='')
parser.add_argument('--run_number',
type=int,
default=1,
help='ID number for this run.')
parser.add_argument('--batch_job',
type=int,
default=1,
help='Batch ID Number in the bsub system.')
args = parser.parse_args()
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process("sim")
p.run = args.run_number
p.maxEvents = 1000 * 1000 # 1M
from LDMX.SimCore import simulator
from LDMX.SimCore import generators
from LDMX.Biasing import target
from LDMX.Biasing import particle_filter
from LDMX.SimCore import bias_operators
from LDMX.Biasing import include as includeBiasing
from LDMX.Biasing import filters
from LDMX.Biasing import util
from LDMX.SimCore import examples
from LDMX.Ecal import EcalGeometry
import argparse
usage = "ldmx fire %s"%(sys.argv[0])
parser = argparse.ArgumentParser(usage,formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("run_number",help="Set the random seed for the simulation.",type=int)
arg = parser.parse_args()
# Internal "process ID" for separating run numbers of different samples
pid=2
# We need the ldmx configuration package to construct the processor objects
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process( 'eat' )
p.maxEvents = 1000000
p.run = int('%d%05d'%(pid,arg.run_number))
from LDMX.Biasing import eat
# Inputs:
# geometry, bias_factor, bias_threshold, min_nuclear_energy
bias_factor = 200.
bias_threshold = 1500. #MeV
min_nuc_energy = 2500. #MeV
bkgd_sim = eat.midshower_nuclear('ldmx-det-v12',bias_factor,bias_threshold,min_nuc_energy)
p.outputFiles = [ f'nuclear_Nevents_1M_MaxTries_1_BiasFactor_{bias_factor}_BiasThresh_{bias_threshold}_MinNucE_{min_nuc_energy}_run_{arg.run_number:05d}.root']
from LDMX.Ecal import digi, vetos
from LDMX.Ecal import EcalGeometry, ecal_hardcoded_conditions
from LDMX.Hcal import hcal
import os
# We need the ldmx configuration package to construct the processor objects
from LDMX.Framework import ldmxcfg
# Setup producers with default templates
from LDMX.EventProc.ecalDigis import ecalDigis
from LDMX.EventProc.ecalVeto import ecalVeto
from LDMX.EventProc.hcalDigis import hcalDigis
from LDMX.EventProc.hcalVeto import hcalVeto
from LDMX.EventProc.simpleTrigger import simpleTrigger
from LDMX.EventProc.trackerHitKiller import trackerHitKiller
# Define the process, which must have a name which identifies this
# processing pass ("pass name").
p = ldmxcfg.Process("recon")
# Currently, we need to explicitly identify plugin libraries which should be
# loaded. In future, we do not expect this be necessary
p.libraries.append("libEventProc.so")
# Create a processor to determine how many findable tracks are in an event.
findableTrack = ldmxcfg.Producer("findable", "ldmx::FindableTrackProcessor")
# Create a processor to veto events with that don't have a single track with
# momentum < 1.2 GeV.
trackerVeto = ldmxcfg.Producer("trackerVeto", "ldmx::TrackerVetoProcessor")
# Define the sequence of event processor to be run
p.sequence = [
ecalDigis, hcalDigis, ecalVeto, hcalVeto, simpleTrigger, trackerHitKiller,
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process("drop")
p.libraries.append("libEventProc.so")
p.libraries.append("libEcal.so")
from LDMX.EventProc.hcalDigis import hcalDigis
from LDMX.Ecal.ecalDigis import ecalDigis
from LDMX.Ecal.ecalRecon import ecalRecon
p.keep = [
"drop .*SimHits.*" #drop all sim hits
,
"keep EcalSimHits.*" #except the ones in the ECal
]
p.sequence = [hcalDigis, ecalDigis, ecalRecon]
p.inputFiles = ["input.root"] #CHANGE ME to your actual input file
p.maxEvents = 50
p.outputFiles = ["output.root"]
print p
#!/usr/bin/python
import sys
# we need the ldmx configuration package to construct the object
from LDMX.Framework import ldmxcfg
# first, we define the process, which must have a name which identifies this
# processing pass ("pass name").
p = ldmxcfg.Process("digi")
# Currently, we need to explicitly identify plugin libraries which should be
# loaded. In future, we do not expect this be necessary
p.libraries.append("libEventProc.so")
# load the template hcalDigis configuration from its python file
from LDMX.EventProc.hcalDigis import hcalDigis
# change the noise level (for testing)
hcalDigis.parameters["meanNoise"] = 1.5
# load the template ecalDigis configuration from its python file
from LDMX.EventProc.ecalDigis import ecalDigis
# load the template ecalDigis configuration from its python file
from LDMX.EventProc.simpleTrigger import simpleTrigger
# Define the sequence of event processors to be run
p.sequence = [ecalDigis, hcalDigis, simpleTrigger]
# Provide the list of input files to run on
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process('ecal_pn')
from LDMX.Biasing import ecal
from LDMX.SimCore import generators
p.sequence = [
ecal.photo_nuclear('ldmx-det-v12',
generators.single_4gev_e_upstream_tagger())
]
p.maxEvents = 1000
p.outputFiles = ['/tmp/ecal_pn.root']
#!/usr/bin/python
import sys
import os
# we need the ldmx configuration package to construct the object
from LDMX.Framework import ldmxcfg
# first, we define the process, which must have a name which identifies this
# processing pass ("pass name").
#p=ldmxcfg.Process("sim")
p = ldmxcfg.Process("overlay")
#import all processors
p.run = 2
#pull in input file
inputName = sys.argv[1]
p.inputFiles = [inputName]
#from LDMX.EventProc import overlay
from LDMX.EventProc.overlay import OverlayProducer
overlay = OverlayProducer(
"pileup_run1_1e_upstream_4GeV.root") #"pileup_1e_upstream_4GeV.root" ) #
#overlay = ldmxcfg.Producer("overlay", "ldmx::OverlayProducer", "EventProc")
overlay.passName = "v12"
overlay.overlayPassName = "pileup"
from LDMX.Framework import ldmxcfg
# Create a process with pass name "vetoana"
p = ldmxcfg.Process('ecalMultiElecAna')
# Append the library that contains the analyzer below to the list of libraries
# that the framework will load.
# change the next line to point to your own ldmx-sw install directory!
#p.libraries.append("/nfs/slac/g/ldmx/users/vdutta/ldmx-analysis-2.1/install/lib/libAnalysis.so")
# Should now be done automatically when declaring module below
# Create an instance of the ECal veto analyzer. This analyzer is used to create
# an ntuple out of ECal BDT variables. The analyzer requires that the
# veto collection name be set.
ecal_veto_ana = ldmxcfg.Producer("ecalMulti", "ldmx::ECalMultiElecAnalyzer",
"Analysis")
ecal_veto_ana.ecal_simhit_collection = "EcalSimHits"
from LDMX.DetDescr import EcalHexReadout
ecal_veto_ana.hexReadout = EcalHexReadout.EcalHexReadout()
# Define the order in which the analyzers will be executed.
p.sequence = [ecal_veto_ana]
p.keep = ["keep .*"]
# Specify the list of input files.
p.inputFiles = ["$inputEventFile"]
# Specify the output file. When creating ntuples or saving histograms, the
# output file name is specified by setting the attribute histogramFile.
from LDMX.Framework import ldmxcfg
# Create a process with pass name "recon"
p = ldmxcfg.Process('vetoana')
# Create an instance of the ECal veto analyzer. This analyzer is used to create
# an ntuple out of ECal BDT variables. The analyzer requires that the
# veto collection name be set.
from LDMX.Analysis import ecal
ecal_veto_ana = ecal.ECalVetoAnalyzer()
ecal_veto_ana.ecal_veto_collection = "EcalVetoGabriel"
# Create an instance of the HCal veto analyzer. This analyzer is used to create
# an ntuple with results from the HCal veto processor.
from LDMX.Analysis import hcal
hcal_veto_ana = hcal.HCalVetoAnalyzer("hcal")
# Define the order in which the analyzers will be executed.
p.sequence = [ecal_veto_ana, hcal_veto_ana]
# input the file as an argument on the command line
import sys
p.inputFiles = [sys.argv[1]]
# Specify the output file. When creating ntuples or saving histograms, the
# output file name is specified by setting the attribute histogramFile.
p.histogramFile = 'ntuple_test.root'
# Print out the details of the configured analyzers.
p.pause()
#!/bin/python3
import os
import sys
import json
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process("v12")
p.run = 1
from LDMX.SimCore import simulator
import LDMX.Ecal.EcalGeometry
sim = simulator.simulator("mySim")
sim.setDetector('ldmx-det-v12', True)
sim.description = "ECal photo-nuclear, xsec bias 450"
sim.randomSeeds = [2 * p.run, 2 * p.run + 1]
sim.beamSpotSmear = [20., 80., 0]
from LDMX.SimCore import generators
sim.generators = [generators.single_4gev_e_upstream_tagger()]
sim.biasingOn(True)
sim.biasingConfigure('photonNuclear', 'ecal', 2500., 450)
from LDMX.Biasing import filters
sim.actions = [
filters.TaggerVetoFilter(),
filters.TargetBremFilter(),
filters.EcalProcessFilter(),
filters.TrackProcessFilter.photo_nuclear()
]
from LDMX.TrigScint.trigScint import TrigScintDigiProducer
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
p = ldmxcfg.Process("plot")
testplot = ldmxcfg.Analyzer("testplot", "ldmx::DummyAnalyzer")
testplot.parameters["caloHitCollection"] = "hcalDigis"
p.sequence = [testplot]
p.inputFiles = ["ldmx_digi_events.root"]
p.maxEvents = 50
p.histogramFile = "histo.root"
p.printMe()
# We need the ldmx configuration package to construct the processor objects
from LDMX.Framework import ldmxcfg
style_name = ''
style_id = -1
if arg.eat :
style_name = 'eat'
style_id = 1
elif arg.old :
style_name = 'old'
style_id = 2
elif arg.new :
style_name = 'new'
style_id = 3
p = ldmxcfg.Process('signal')
p.maxTriesPerEvent = arg.maxTries
p.maxEvents = arg.numEvents
p.logFrequency = int(arg.numEvents/20)
p.termLogLevel = 1
if arg.verbose :
p.termLogLevel = 1
p.logFrequency = 100
# make sure outDir is actually there
if not os.path.isdir( arg.outDir ) :
os.makedirs( arg.outDir )
# Dark Brem Vertex Library
# TODO add this process to the model constructor
#!/usr/bin/python
import sys
import os
from LDMX.Framework import ldmxcfg
ecalSimHitSort = ldmxcfg.Producer("ecalSimHitSort",
"ldmx::SimHitSortProcessor")
ecalSimHitSort.parameters["simHitCollection"] = "EcalSimHits"
ecalSimHitSort.parameters["outputCollection"] = "SortedEcalSimHits"
hcalSimHitSort = ldmxcfg.Producer("hcalSimHitSort",
"ldmx::SimHitSortProcessor")
hcalSimHitSort.parameters["simHitCollection"] = "HcalSimHits"
hcalSimHitSort.parameters["outputCollection"] = "SortedHcalSimHits"
p = ldmxcfg.Process("sort")
p.libraries.append("ldmx-sw-install/lib/libEventProc.so")
p.sequence = [ecalSimHitSort, hcalSimHitSort]
p.inputFiles = [
"/nfs/slac/g/ldmx/data/mc/v2/4pt0_gev_electrons_ecal_photonuc_v2_fieldmap/4pt0_gev_electrons_ecal_photonuc_v2_fieldmap_10to6_04752.root"
]
p.outputFiles = ["recon_test.root"]
#!/usr/bin/python
import sys
import os
import json
# we need the ldmx configuration package to construct the object
from LDMX.Framework import ldmxcfg
# first, we define the process, which must have a name which identifies this
# processing pass ("pass name").
p=ldmxcfg.Process("anaTS")
p.inputFiles = [ sys.argv[1] ]
from LDMX.Analysis import ts2
ana=ts2.TSTrackAnalyzer2()
ana.passName="sim"
ana.rechit_collection="trigScintDigisTag" #RecHitsTagger_timeCut"
ana.truth_track_collection="TriggerPadTracks"
ana.truth_passName="truth"
p.sequence = [ ana ]
p.termLogLevel = 2
#p.fileLogLevel = 0
#p.logFileName = sys.argv[1].replace(".root", ".log")
# set the maximum number of events to process
p.maxEvents=10000
#!/usr/bin/python
import sys
import os
from LDMX.Framework import ldmxcfg
passName = "truth"
p = ldmxcfg.Process(passName)
simPassName = "sim" #<-- whatever is in the input, if those collections would be used for anything, instead of the pass created here
#maximum number of events to process
nEv = 10000
if len(sys.argv) >= 2:
inputName = sys.argv[1] #specify the input name
else:
#inputName=sys.argv[0]
print(
"An input file name has to be specified. Use (positional) argument 2 for it."
)
exit(1)
#inputName="NonRotarun1-eout.root"
print("Using input file name: " + inputName)
if len(sys.argv) >= 3:
outputName = sys.argv[
2] #specify the output name if default is not desired
else:
outputName = "clustered_truth_" + inputName
print("Using output file name: " + outputName)
#setup a log file
