#!/usr/bin/python
from LDMX.Framework import ldmxcfg
ecalDigis = ldmxcfg.Producer("ecalDigis", "ldmx::EcalDigiProducer")
# Set the noise (in electrons) when the capacitance is 0.
ecalDigis.parameters["noiseIntercept"] = 900.
# Set the capacitative noise slope (electrons/pF)
ecalDigis.parameters["noiseSlope"] = 22.
# Set the capacitance per cell pad (pF)
ecalDigis.parameters["padCapacitance"] = 27.56
# set the readout threshold in multiples of RMS noise
ecalDigis.parameters["readoutThreshold"] = 4.
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
trackFiltExample = ldmxcfg.Producer("trackFiltExample", "ldmx::Simulator")
trackFiltExample.parameters[
"description"] = "Example on how to run simulation with track filtering plugin"
trackFiltExample.parameters["postInitCommands"] = [
# basic upstream electron gun
"/gun/particle e-",
"/gun/energy 4 GeV",
"/gun/position -27.926 5 -700 mm",
"/gun/direction 0.3138 0 3.9877 GeV",
# Bias PN reactions really high so they actually happen so you can see the track filtering working
"/ldmx/plugins/load PhotonuclearXsecBiasingPlugin",
"/ldmx/plugins/PhotonuclearXsecBiasingPlugin/xsecFactor 1000.",
# enable track filtering
"/ldmx/plugins/load TrackFilterPlugin",
"/ldmx/plugins/TrackFilterPlugin/verbose 2",
# save neutrons above 5 MeV KE from PN interactions
"/ldmx/plugins/TrackFilterPlugin/threshold 5 MeV",
"/ldmx/plugins/TrackFilterPlugin/pdgid 2112",
"/ldmx/plugins/TrackFilterPlugin/process photonNuclear true",
"/ldmx/plugins/TrackFilterPlugin/CalorimeterRegion true",
"/ldmx/plugins/TrackFilterPlugin/create KeepNeutrons",
# save all parents of PN secondaries
"/ldmx/plugins/TrackFilterPlugin/parent photonNuclear true",
"/ldmx/plugins/TrackFilterPlugin/CalorimeterRegion true",
"/ldmx/plugins/TrackFilterPlugin/create PNParentFilter",
]
tsDigisTag = TrigScintDigiProducer.tagger()
tsDigisDown = TrigScintDigiProducer.down()
#set the PE response to 100 (default is 10, too low)
tsDigisUp.pe_per_mip = 100.
tsDigisTag.pe_per_mip = tsDigisUp.pe_per_mip
tsDigisDown.pe_per_mip = tsDigisUp.pe_per_mip
from LDMX.Ecal import digi
from LDMX.Ecal import vetos
from LDMX.EventProc import hcal
from LDMX.EventProc.simpleTrigger import simpleTrigger
from LDMX.EventProc.trackerHitKiller import trackerHitKiller
p.sequence = [
sim,
digi.EcalDigiProducer(),
digi.EcalRecProducer(),
vetos.EcalVetoProcessor(),
hcal.HcalDigiProducer(),
hcal.HcalVetoProcessor(), tsDigisUp, tsDigisTag, tsDigisDown,
trackerHitKiller, simpleTrigger,
ldmxcfg.Producer('finableTrack', 'ldmx::FindableTrackProcessor',
'EventProc'),
ldmxcfg.Producer('trackerVeto', 'ldmx::TrackerVetoProcessor', 'EventProc')
]
p.outputFiles = ["/tmp/simoutput.root"]
p.maxEvents = 1000
with open('/tmp/parameterDump.json', 'w') as outfile:
json.dump(p.parameterDump(), outfile, indent=4)
#!/usr/bin/python from LDMX.Framework import ldmxcfg basicOneElectron = ldmxcfg.Producer( "basicOneElectron", "ldmx::Simulator") basicOneElectron.parameters[ "description" ] = "One e- fired far upstream without any plugins or modifications to the physics" basicOneElectron.parameters[ "mpgNparticles" ] = 1 basicOneElectron.parameters[ "mpgPdgId" ] = 11 basicOneElectron.parameters[ "mpgVertex" ] = [ -27.926, 5, -700 ] basicOneElectron.parameters[ "mpgMomentum" ] = [ 313.8, 0, 3987.7 ]
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
ecalVeto = ldmxcfg.Producer("EcalVeto", "ldmx::EcalVetoProcessor")
ecalVeto.parameters["num_ecal_layers"] = 34
ecalVeto.parameters["do_bdt"] = 1
ecalVeto.parameters["bdt_file"] = "cal_bdt.pkl"
ecalVeto.parameters["disc_cut"] = 0.999672
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
hcalDigis = ldmxcfg.Producer("hcalDigis", "ldmx::HcalDigiProducer")
# set the mean noise in PE units
hcalDigis.parameters["meanNoise"] = 2.0
#!/usr/bin/python
import sys
import os
# We need the ldmx configuration package to construct the processor objects
from LDMX.Framework import ldmxcfg
# 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
myProcess = ldmxcfg.Producer("myProcessor", "ldmx::MyProcessor")
# Define the sequence of event processor to be run
p.sequence = [myProcess]
# Determine the input file from the first argument to this script.
p.inputFiles = [sys.argv[1]]
# Provide the list of output files to produce, either one to contain the results of all input files or one output file name per input file name
p.outputFiles = ["my_processor_results.root"]
# Utility function to interpret and print out the configuration to the screen
p.printMe()
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,
findableTrack, trackerVeto
]
# Default to dropping all events
p.skimDefaultIsDrop()
# Use output of trigger module to decide what to keep
#!/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
from LDMX.Framework import ldmxcfg
simpleTrigger = ldmxcfg.Producer("simpleTrigger", "ldmx::TriggerProcessor")
# set the mean noise in PE units
simpleTrigger.parameters["threshold"] = 12.0
simpleTrigger.parameters["mode"] = 0
simpleTrigger.parameters["start_layer"] = 1
simpleTrigger.parameters["end_layer"] = 16
#!/usr/bin/python
import sys
import os
# we need the ldmx configuration package to construct the object
from LDMX.Framework import ldmxcfg
ecalClusters = ldmxcfg.Producer("ecalClusters", "ldmx::EcalClusterProducer")
# Cluster weight cutoff in appropriate units
ecalClusters.parameters["cutoff"] = 10.0
# Seed threshold for clustering
ecalClusters.parameters["seedThreshold"] = 100.0 # MeV
# Pass name for ecal digis
ecalClusters.parameters["digisPassName"] = "recon"
# Name of the algo to save to the root file
ecalClusters.parameters["algoName"] = "MyClusterAlgo"
# Name of the cluster collection to make
ecalClusters.parameters["clusterCollName"] = "ecalClusters"
# Name of the cluster algo collection to make
ecalClusters.parameters["algoCollName"] = "ClusterAlgoResult"
import os
# we need the ldmx configuration package to construct the object
from LDMX.Framework import ldmxcfg
# Setup producers with default templates
from LDMX.EventProc.ecalDigis import ecalDigis
from LDMX.EventProc.hcalDigis import hcalDigis
from LDMX.EventProc.simpleTrigger import simpleTrigger
from LDMX.EventProc.trackerHitKiller import trackerHitKiller
p = ldmxcfg.Process("recon")
p.libraries.append("libEventProc.so")
# Load the PN re-weighting processor
pnWeight = ldmxcfg.Producer("pn_reweight", "ldmx::PnWeightProcessor")
pnWeight.parameters["w_threshold"] = 1150.
pnWeight.parameters["theta_threshold"] = 100.
ecalVeto = ldmxcfg.Producer("ecalVeto", "ldmx::EcalVetoProcessor")
ecalVeto.parameters["num_ecal_layers"] = 34
ecalVeto.parameters["do_bdt"] = 1
ecalVeto.parameters["bdt_file"] = "fid_bdt.pkl"
ecalVeto.parameters["cellxy_file"] = "cellxy.txt"
ecalVeto.parameters["disc_cut"] = 0.95
NonFidecalVeto = ldmxcfg.Producer("NonFidecalVeto",
"ldmx::NonFidEcalVetoProcessor")
NonFidecalVeto.parameters["num_ecal_layers"] = 34
NonFidecalVeto.parameters["do_bdt"] = 1
#Files in order of increasing mass
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
ecalPNBias = ldmxcfg.Producer("ecalPNBias", "ldmx::Simulator")
ecalPNBias.parameters[
"description"] = "Sample of events where 4GeV undergoes hard brem in target and PN in ecal"
ecalPNBias.parameters["preInitCommands"] = [
"/ldmx/biasing/enable", "/ldmx/biasing/particle gamma",
"/ldmx/biasing/process photonNuclear", "/ldmx/biasing/volume ecal",
"/ldmx/biasing/xsec 1000", "/ldmx/biasing/threshold 2500"
]
ecalPNBias.parameters["postInitCommands"] = [
# skip events that don't have a hard brem in the target
# sets minimum recoil energy at 1500MeV and brem energy at 2500MeV
"/ldmx/plugins/load TargetBremFilter libBiasing.so",
"/ldmx/plugins/TargetBremFilter/volume target_PV",
"/ldmx/plugins/TargetBremFilter/recoil_threshold 1500",
"/ldmx/plugins/TargetBremFilter/brem_threshold 2500",
# filters for PN processes in ecal
"/ldmx/plugins/load EcalProcessFilter libBiasing.so"
"/ldmx/plugins/EcalProcessFilter/volume ecal",
# normal upstream 4GeV electron gun
"/gun/particle e-",
"/gun/energy 4 GeV",
"/gun/position -27.926 5 -700 mm",
"/gun/direction 0.3138 0 3.9877 GeV",
]
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.
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
genParticleSourceExample = ldmxcfg.Producer("genParticleSourceExample",
"ldmx::Simulator")
genParticleSourceExample.parameters[
"description"] = "Example of a General Particle Source"
genParticleSourceExample.parameters["postInitCommands"] = [
"/ldmx/generators/gps/enable", "/gps/particle pi-",
"/gps/direction 0 0 4.0", "/gps/energy 4.0 GeV", "/gps/position 0 0 -1 mm"
]
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
ecalMuPair = ldmxcfg.Producer("ecalMuPair", "ldmx::Simulator")
ecalMuPair.parameters[
"description"] = "Generation of gamma -> 2mu pairs within ECal"
ecalMuPair.parameters["preInitCommands"] = [
"/ldmx/biasing/enable",
"/ldmx/biasing/particle gamma",
"/ldmx/biasing/process GammaToMuPair", #make gamma -> 2mu pretty much certain in ECal
"/ldmx/biasing/volume Ecal",
"/ldmx/biasing/xsec 10000000",
"/ldmx/biasing/threshold 0"
]
ecalMuPair.parameters["postInitCommands"] = [
"/gun/particle e-",
"/gun/energy 4 GeV",
"/gun/position -27.926 5 -700 mm",
"/gun/direction 0.3138 0 3.9877 GeV",
"/ldmx/plugins/TargetBremFilter libBiasing.so", #filters for hard brem
"/ldmx/plugins/load EcalProcessFilter libBiasing.so" # filters for process specified in ECal in biasing
]
#!/usr/bin/python
import sys
# Load the configuration package
from LDMX.Framework import ldmxcfg
# Set the process name
p=ldmxcfg.Process("recon")
# Load the library that contains the Ecal veto processor
p.libraries.append("libEventProc.so")
# Configure the Ecal veto processor
ecalVeto = ldmxcfg.Producer("ecalVeto", "ldmx::EcalVetoProcessor")
ecalVeto.parameters["num_ecal_layers"] = 34
ecalVeto.parameters["do_bdt"] = 1
ecalVeto.parameters["bdt_file"] = "fid_bdt.pkl"
ecalVeto.parameters["cellxy_file"] = "cellxy.txt"
ecalVeto.parameters["disc_cut"] = 0.95
# Configure the Non-Fiducial Ecal veto processor
NonFidecalVeto = ldmxcfg.Producer("NonFidecalVeto", "ldmx::NonFidEcalVetoProcessor")
NonFidecalVeto.parameters["num_ecal_layers"] = 34
NonFidecalVeto.parameters["do_bdt"] = 1
#Files in order of increasing mass
NonFidecalVeto.parameters["nf_bdt_files"] = ["p001_nf_bdt.pkl", "p01_nf_bdt.pkl", "p1_nf_bdt.pkl", "p0_nf_bdt.pkl"]
NonFidecalVeto.parameters["cellxy_file"] = "cellxy.txt"
#Disc cuts in order of increasing mass
NonFidecalVeto.parameters["disc_cut"] = [0.99, 0.95, 0.94, 0.94]
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"). Usually, this is set to recon.
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")
# Load the PN re-weighting processor
pn_reweight = ldmxcfg.Producer("pn_reweight", "ldmx::PnWeightProcessor")
# Set the W_p threshold above which an event will be re-weighted. For the
# definition of W_p, see the processor.
pn_reweight.parameters["wp_threshold"] = 1500.
# Define the sequence of event processors to be run
p.sequence = [pn_reweight]
# Provide the list of input files to run on
p.inputFiles = ["ldmx_sim_events.root"]
# Provide the list of output files to produce, either one to contain the results of all input files or one output file name per input file name
p.outputFiles = ["ldmx_digi_events.root"]
# Utility function to interpret and print out the configuration to the screen
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
trackerHitKiller = ldmxcfg.Producer("trackerHitKiller",
"ldmx::TrackerHitKiller")
# Configure
trackerHitKiller.parameters['hitEfficiency'] = 99.0
import sys
from LDMX.Framework import ldmxcfg
from LDMX.EventProc.ecalDigis import ecalDigis
from LDMX.EventProc.simpleTrigger import simpleTrigger
from LDMX.EventProc.hcalDigis import hcalDigis
from LDMX.EventProc.trackerHitKiller import trackerHitKiller
p = ldmxcfg.Process("recon")
p.libraries.append("libEventProc.so")
ecalVeto = ldmxcfg.Producer("ecalVeto", "ldmx::EcalVetoProcessor")
ecalVeto.parameters["num_ecal_layers"] = 34
ecalVeto.parameters["do_bdt"] = 1
ecalVeto.parameters["bdt_file"] = "fid_bdt.pkl"
ecalVeto.parameters["disc_cut"] = 0.94
ecalVeto.parameters["cellxy_file"] = "cellxy.txt"
ecalVeto.parameters["collection_name"] = "ecalVeto.dockertest"
hcalVeto = ldmxcfg.Producer("hcalVeto", "ldmx::HcalVetoProcessor")
hcalVeto.parameters["pe_threshold"] = 8.0
hcalVeto.parameters["collection_name"] = "hcalVeto.dockertest"
simpleTrigger.parameters["threshold"] = 1500.0
simpleTrigger.parameters["end_layer"] = 20
findable_track = ldmxcfg.Producer("findable", "ldmx::FindableTrackProcessor")
p.sequence = [
ecalDigis, hcalDigis, ecalVeto, simpleTrigger, trackerHitKiller,
findable_track
]
p.inputFiles = ["output.root"]
p.outputFiles = ["file_tskim_recon.root"]
p.printMe()
p.histogramFile = "histo.root"
#!/usr/bin/python
from LDMX.Framework import ldmxcfg
targetENBias = ldmxcfg.Producer("targetENBias", "ldmx::Simulator")
targetENBias.parameters[
"description"] = "Sample of events where 4GeV undergoes EN reaction in target"
targetENBias.parameters["preInitCommands"] = [
"/ldmx/biasing/enable", "/ldmx/biasing/particle e-",
"/ldmx/biasing/process electronNuclear", "/ldmx/biasing/volume target",
"/ldmx/biasing/threshold 0"
]
targetENBias.parameters["postInitCommands"] = [
"/ldmx/biasing/xsec/bias_incident", #only bias incident particle
"/ldmx/biasing/xsec/particle e-",
"/ldmx/biasing/xsec/process electronNuclear",
"/ldmx/biasing/xsec/threshold 0",
"/ldmx/biasing/xsec/factor 100000",
"/gun/particle e-",
"/gun/energy 4 GeV",
"/gun/position -27.926 5 -700 mm",
"/gun/direction 0.3138 0 3.9877 GeV",
"/ldmx/plugins/load TargetProcessFilter libBiasing.so" # filters for process specified in target in biasing
]
from LDMX.Framework import ldmxcfg
# Create a process with pass name "vetoana"
p = ldmxcfg.Process('vetoana')
# 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("ecal", "ldmx::ECalVetoAnalyzer", "Analysis")
ecal_veto_ana.ecal_veto_collection = "EcalVeto"
ecal_veto_ana.hcal_veto_collection = "HcalVeto"
ecal_veto_ana.tracker_veto_collection = "TrackerVeto"
ecal_veto_ana.trig_result_collection = "Trigger"
ecal_veto_ana.ecal_simhit_collection = "EcalSimHits"
ecal_veto_ana.ecal_rechit_collection = "EcalRecHits"
ecal_veto_ana.sim_particle_collection = "SimParticles"
import LDMX.Ecal.EcalGeometry
#from LDMX.DetDescr import EcalHexReadout
#ecal_veto_ana.hexReadout = EcalHexReadout.EcalHexReadout()
# Should now be done automatically upon import LDMX.Ecal.EcalGeometry
# Define the order in which the analyzers will be executed.
p.sequence = [ecal_veto_ana]
from LDMX.Framework import ldmxcfg
hcalVeto = ldmxcfg.Producer("HcalVeto", "ldmx::HcalVetoProcessor")
hcalVeto.parameters['pe_threshold'] = 5.0
hcalVeto.parameters['max_time'] = 50.0
hcalVeto.parameters['max_depth'] = 4000.0
hcalVeto.parameters['back_min_pe'] = 1.
