diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 79dff3cb2cbf8a0d7a3e704675510136d323343b..5c30b61ea7bc79c3c5cd3f7308db2c725f255a45 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -71,12 +71,11 @@ include:
# - local: 'benchmarks/rich/config.yml'
- local: 'benchmarks/imaging_ecal/config.yml'
- local: 'benchmarks/imaging_shower_ML/config.yml'
- - local: 'benchmarks/full/config.yml'
- local: 'benchmarks/B0/config.yml'
final_report:
stage: finish
- needs: ["ecal_collect", "tracking_central_electrons", "clustering:results", "full:results","track_finding:collect","track_fitting:collect"]
+ needs: ["ecal_collect", "tracking_central_electrons", "clustering:results", "track_finding:collect", "track_fitting:collect"]
script:
# disabled while we address ACTS issues
#- mkdir -p results/views && cd results/views && bash ../../bin/download_views
diff --git a/benchmarks/full/config.yml b/benchmarks/full/config.yml
deleted file mode 100644
index 3ad6d6ef0bef04368950c78c4172db4cc69b2638..0000000000000000000000000000000000000000
--- a/benchmarks/full/config.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-full:reco:
- extends: .rec_benchmark
- stage: run
- timeout: 24 hours
- script:
- - bash benchmarks/full/full_reconstruction.sh -t full_${REGIONS}_${PARTICLES} -n 100 -p "${PARTICLES}" --pmin 1 --pmax 20 --region "${REGIONS}"
- parallel:
- matrix:
- - REGIONS: ["forward", "barrel", "backward"]
- PARTICLES: ["electron", "pion+", "pion-", "kaon+", "kaon-", "proton", "neutron", "positron", "photon"]
- #PARTICLES: ["electron", "pion0", "pion+", "pion-", "kaon0S", "kaon0L", "kaon+", "kaon-", "proton", "neutron", "positron", "photon"]
-
-full:results:
- extends: .rec_benchmark
- stage: collect
- needs: ["full:reco"]
- script:
- - ls -lrth
- #- python dvcs/scripts/merge_results.py
-
diff --git a/benchmarks/full/full_reconstruction.sh b/benchmarks/full/full_reconstruction.sh
deleted file mode 100644
index 3d60204dfdb1bf32e27d317602ed53045878b92a..0000000000000000000000000000000000000000
--- a/benchmarks/full/full_reconstruction.sh
+++ /dev/null
@@ -1,185 +0,0 @@
-#!/bin/bash
-
-print_env.sh
-
-function print_the_help {
- echo "USAGE: ${0} -n <nevents> -t <nametag> -p <particle> "
- echo " OPTIONS: "
- echo " -n,--nevents Number of events"
- echo " -t,--nametag name tag"
- echo " -p,--particle particle type"
- echo " allowed types: pion0, pion+, pion-, kaon0, kaon+, kaon-, proton, neutron, electron, positron, photon"
- echo " --pmin minimum particle momentum (GeV)"
- echo " --pmax maximum particle momentum (GeV)"
- echo " --angmin minimum particle angle (deg)"
- echo " --angmax maximum particle angle (deg)"
- echo " --region detector region"
- echo " allowed regions: farbackward, backward, barrel, forward, farforward"
- exit
-}
-
-POSITIONAL=()
-while [[ $# -gt 0 ]]
-do
- key="$1"
-
- case $key in
- -h|--help)
- shift # past argument
- print_the_help
- ;;
- -t|--nametag)
- nametag="$2"
- shift # past argument
- shift # past value
- ;;
- -p|--particle)
- particle="$2"
- shift # past argument
- shift # past value
- ;;
- -n|--nevents)
- export JUGGLER_N_EVENTS="$2"
- shift # past argument
- shift # past value
- ;;
- --pmin)
- export PMIN="$2"
- shift
- shift
- ;;
- --pmax)
- export PMAX="$2"
- shift
- shift
- ;;
- --angmin)
- export ANGMIN="$2"
- shift
- shift
- ;;
- --angmax)
- export ANGMAX="$2"
- shift
- shift
- ;;
- --region)
- export REGION="$2"
- shift
- shift
- ;;
- *) # unknown option
- #POSITIONAL+=("$1") # save it in an array for later
- echo "unknown option $1"
- print_the_help
- shift # past argument
- ;;
- esac
-done
-set -- "${POSITIONAL[@]}" # restore positional parameters
-
-if [[ ! -n "${JUGGLER_N_EVENTS}" ]] ; then
- export JUGGLER_N_EVENTS=1000
-fi
-
-if [[ ! -n "${PARTICLE}" ]] ; then
- export PARTICLE="electron"
-fi
-
-if [[ ! -n "${PMIN}" ]] ; then
- export PMIN=1.0
-fi
-
-if [[ ! -n "${PMAX}" ]] ; then
- export PMAX=10.0
-fi
-
-if [[ ! -n "${ANGMIN}" ]] ; then
- export ANGMIN=3
-fi
-
-if [[ ! -n "${ANGMAX}" ]] ; then
- export ANGMAX=177
-fi
-
-if [[ ! -n "${REGION}" ]] ; then
- export REGION="ignore"
-fi
-
-if [[ ! -n "${JUGGLER_DETECTOR}" ]] ; then
- export JUGGLER_DETECTOR="athena"
-fi
-
-if [[ ! -n "${JUGGLER_INSTALL_PREFIX}" ]] ; then
- export JUGGLER_INSTALL_PREFIX="/usr/local"
-fi
-
-compact_path=${DETECTOR_PATH}/${JUGGLER_DETECTOR}.xml
-export JUGGLER_FILE_NAME_TAG="${nametag}"
-export JUGGLER_GEN_FILE="gen_${JUGGLER_FILE_NAME_TAG}.hepmc"
-
-export JUGGLER_SIM_FILE="sim_${JUGGLER_FILE_NAME_TAG}.root"
-export JUGGLER_REC_FILE="rec_${JUGGLER_FILE_NAME_TAG}.root"
-
-echo "JUGGLER_N_EVENTS = ${JUGGLER_N_EVENTS}"
-echo "DETECTOR_PATH = ${DETECTOR_PATH}"
-echo "JUGGLER_DETECTOR = ${JUGGLER_DETECTOR}"
-
-# Generate the input events
-if [ ! -f ${JUGGLER_GEN_FILE} ] ; then
- python benchmarks/full/scripts/gen_particles.py ${JUGGLER_GEN_FILE} -n ${JUGGLER_N_EVENTS}\
- --angmin ${ANGMIN} --angmax ${ANGMAX} --phmin 0 --phmax 360 --pmin ${PMIN} --pmax ${PMAX}\
- --regions="${REGION}" --particles="${particle}"
-fi
-
-if [[ "$?" -ne "0" ]] ; then
- echo "ERROR running script: generating input events"
- exit 1
-fi
-
-ls -lh ${JUGGLER_GEN_FILE}
-
-# Run geant4 simulations
-if [ ! -f ${JUGGLER_SIM_FILE} ] ; then
- npsim --runType batch \
- -v WARNING \
- --part.minimalKineticEnergy "1*TeV" \
- --numberOfEvents ${JUGGLER_N_EVENTS} \
- --compactFile ${compact_path} \
- --inputFiles ${JUGGLER_GEN_FILE} \
- --outputFile ${JUGGLER_SIM_FILE}
-fi
-
-if [[ "$?" -ne "0" ]] ; then
- echo "ERROR running npdet"
- exit 1
-fi
-
-rootls -t "${JUGGLER_SIM_FILE}"
-
-# Directory for results
-mkdir -p results
-
-OPTION_DIR=benchmarks/full/options
-SCRIPT_DIR=benchmarks/full/scripts
-
-# Run Juggler
-gaudirun.py ${OPTION_DIR}/full_reconstruction.py
-if [[ "$?" -ne "0" ]] ; then
- echo "ERROR running reconstruction (juggler)"
- exit 1
-fi
-
-rootls -t "${JUGGLER_REC_FILE}"
-
-# Run analysis scripts
-#python ${SCRIPT_DIR}/full_reconstruction.py ${JUGGLER_SIM_FILE} ${JUGGLER_REC_FILE} -o results
-
-root_filesize=$(stat --format=%s "${JUGGLER_REC_FILE}")
-if [[ "${JUGGLER_N_EVENTS}" -lt "500" ]] ; then
- # file must be less than 10 MB to upload
- if [[ "${root_filesize}" -lt "10000000" ]] ; then
- cp ${JUGGLER_REC_FILE} results/.
- fi
-fi
-
diff --git a/benchmarks/full/options/full_reconstruction.py b/benchmarks/full/options/full_reconstruction.py
deleted file mode 100644
index ac1173277ccac65a720903e46e01e6827cc8d88f..0000000000000000000000000000000000000000
--- a/benchmarks/full/options/full_reconstruction.py
+++ /dev/null
@@ -1,602 +0,0 @@
-from Gaudi.Configuration import *
-
-from Configurables import ApplicationMgr, EICDataSvc, PodioOutput, GeoSvc
-from GaudiKernel import SystemOfUnits as units
-from GaudiKernel.SystemOfUnits import MeV, GeV, mm, cm, mrad
-
-import json
-
-detector_name = "athena"
-if "JUGGLER_DETECTOR" in os.environ :
- detector_name = str(os.environ["JUGGLER_DETECTOR"])
-
-detector_path = ""
-if "DETECTOR_PATH" in os.environ :
- detector_path = str(os.environ["DETECTOR_PATH"])
-
-compact_path = os.path.join(detector_path, detector_name)
-
-# RICH reconstruction
-qe_data = [(1.0, 0.25), (7.5, 0.25),]
-
-# CAL reconstruction
-# get sampling fractions from system environment variable
-ci_ecal_sf = float(os.environ.get("CI_ECAL_SAMP_FRAC", 0.253))
-cb_hcal_sf = float(os.environ.get("CB_HCAL_SAMP_FRAC", 0.038))
-ci_hcal_sf = float(os.environ.get("CI_HCAL_SAMP_FRAC", 0.025))
-ce_hcal_sf = float(os.environ.get("CE_HCAL_SAMP_FRAC", 0.025))
-
-# input arguments from calibration file
-with open('config/emcal_barrel_calibration.json') as f:
- calib_data = json.load(f)['electron']
-
-print(calib_data)
-
-img_barrel_sf = float(calib_data['sampling_fraction_img'])
-scifi_barrel_sf = float(calib_data['sampling_fraction_scfi'])
-
-# input and output
-input_sims = [f.strip() for f in str.split(os.environ["JUGGLER_SIM_FILE"], ",") if f.strip()]
-output_rec = str(os.environ["JUGGLER_REC_FILE"])
-n_events = int(os.environ["JUGGLER_N_EVENTS"])
-
-# geometry service
-geo_service = GeoSvc("GeoSvc", detectors=["{}.xml".format(compact_path)], OutputLevel=WARNING)
-# data service
-podioevent = EICDataSvc("EventDataSvc", inputs=input_sims, OutputLevel=WARNING)
-
-# juggler components
-from Configurables import PodioInput
-from Configurables import Jug__Base__InputCopier_dd4pod__Geant4ParticleCollection_dd4pod__Geant4ParticleCollection_ as MCCopier
-from Configurables import Jug__Base__InputCopier_dd4pod__CalorimeterHitCollection_dd4pod__CalorimeterHitCollection_ as CalCopier
-from Configurables import Jug__Base__InputCopier_dd4pod__TrackerHitCollection_dd4pod__TrackerHitCollection_ as TrkCopier
-from Configurables import Jug__Base__InputCopier_dd4pod__PhotoMultiplierHitCollection_dd4pod__PhotoMultiplierHitCollection_ as PMTCopier
-
-from Configurables import Jug__Base__MC2DummyParticle as MC2DummyParticle
-
-from Configurables import Jug__Digi__PhotoMultiplierDigi as PhotoMultiplierDigi
-from Configurables import Jug__Digi__CalorimeterHitDigi as CalHitDigi
-from Configurables import Jug__Digi__UFSDTrackerDigi as TrackerDigi
-
-from Configurables import Jug__Reco__TrackerHitReconstruction as TrackerHitReconstruction
-from Configurables import Jug__Reco__TrackingHitsCollector2 as TrackingHitsCollector
-from Configurables import Jug__Reco__TrackerSourceLinker as TrackerSourceLinker
-from Configurables import Jug__Reco__TrackerSourcesLinker as TrackerSourcesLinker
-#from Configurables import Jug__Reco__TrackingHitsSourceLinker as TrackingHitsSourceLinker
-from Configurables import Jug__Reco__TrackParamTruthInit as TrackParamTruthInit
-from Configurables import Jug__Reco__TrackParamClusterInit as TrackParamClusterInit
-from Configurables import Jug__Reco__TrackParamVertexClusterInit as TrackParamVertexClusterInit
-from Configurables import Jug__Reco__TrackFindingAlgorithm as TrackFindingAlgorithm
-from Configurables import Jug__Reco__ParticlesFromTrackFit as ParticlesFromTrackFit
-from Configurables import Jug__Reco__ParticlesWithTruthPID as ParticlesWithTruthPID
-
-from Configurables import Jug__Reco__CalorimeterHitReco as CalHitReco
-from Configurables import Jug__Reco__CalorimeterHitsMerger as CalHitsMerger
-from Configurables import Jug__Reco__CalorimeterIslandCluster as IslandCluster
-
-from Configurables import Jug__Reco__ImagingPixelReco as ImCalPixelReco
-from Configurables import Jug__Reco__ImagingTopoCluster as ImagingCluster
-
-from Configurables import Jug__Reco__ClusterRecoCoG as RecoCoG
-from Configurables import Jug__Reco__ImagingClusterReco as ImagingClusterReco
-
-from Configurables import Jug__Reco__PhotoMultiplierReco as PhotoMultiplierReco
-from Configurables import Jug__Reco__PhotoRingClusters as PhotoRingClusters
-
-from Configurables import Jug__Reco__EMCalReconstruction as EMCalReconstruction
-
-# branches needed from simulation root file
-sim_coll = [
- "mcparticles",
- "EcalEndcapNHits",
- "EcalEndcapPHits",
- "EcalBarrelHits",
- "EcalBarrelScFiHits",
- "HcalBarrelHits",
- "HcalEndcapPHits",
- "HcalEndcapNHits",
- "TrackerEndcapHits",
- "TrackerBarrelHits",
- "GEMTrackerEndcapHits",
- "VertexBarrelHits",
- "VertexEndcapHits",
- "DRICHHits",
- "MRICHHits"
-]
-
-# list of algorithms
-algorithms = []
-
-# input
-podin = PodioInput("PodioReader", collections=sim_coll)
-algorithms.append(podin)
-
-## copiers to get around input --> output copy bug. Note the "2" appended to the output collection.
-copier = MCCopier("MCCopier",
- inputCollection="mcparticles",
- outputCollection="mcparticles2")
-algorithms.append(copier)
-
-# Generated particles
-dummy = MC2DummyParticle("dummy",
- inputCollection="mcparticles",
- outputCollection="GeneratedParticles",
- smearing=0)
-algorithms.append(dummy)
-
-# Crystal Endcap Ecal
-ce_ecal_daq = dict(
- dynamicRangeADC=5.*units.GeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=3)
-
-ce_ecal_digi = CalHitDigi("ce_ecal_digi",
- inputHitCollection="EcalEndcapNHits",
- outputHitCollection="EcalEndcapNRawHits",
- energyResolutions=[0., 0.02, 0.],
- **ce_ecal_daq)
-algorithms.append(ce_ecal_digi)
-
-ce_ecal_reco = CalHitReco("ce_ecal_reco",
- inputHitCollection=ce_ecal_digi.outputHitCollection,
- outputHitCollection="EcalEndcapNRecHits",
- thresholdFactor=4, # 4 sigma cut on pedestal sigma
- readoutClass="EcalEndcapNHits",
- sectorField="sector",
- **ce_ecal_daq)
-algorithms.append(ce_ecal_reco)
-
-ce_ecal_cl = IslandCluster("ce_ecal_cl",
- inputHitCollection=ce_ecal_reco.outputHitCollection,
- outputProtoClusterCollection="EcalEndcapNProtoClusters",
- splitCluster=False,
- minClusterHitEdep=1.0*units.MeV, # discard low energy hits
- minClusterCenterEdep=30*units.MeV,
- sectorDist=5.0*units.cm,
- dimScaledLocalDistXY=[1.8, 1.8]) # dimension scaled dist is good for hybrid sectors with different module size
-algorithms.append(ce_ecal_cl)
-
-ce_ecal_clreco = RecoCoG("ce_ecal_clreco",
- inputHitCollection=ce_ecal_cl.inputHitCollection,
- inputProtoClusterCollection=ce_ecal_cl.outputProtoClusterCollection,
- outputClusterCollection="EcalEndcapNClusters",
- outputInfoCollection="EcalEndcapNClusterInfo",
- samplingFraction=0.998, # this accounts for a small fraction of leakage
- logWeightBase=4.6)
-algorithms.append(ce_ecal_clreco)
-
-# Endcap Sampling Ecal
-ci_ecal_daq = dict(
- dynamicRangeADC=50.*units.MeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=10)
-
-ci_ecal_digi = CalHitDigi("ci_ecal_digi",
- inputHitCollection="EcalEndcapPHits",
- outputHitCollection="EcalEndcapPRawHits",
- **ci_ecal_daq)
-algorithms.append(ci_ecal_digi)
-
-ci_ecal_reco = CalHitReco("ci_ecal_reco",
- inputHitCollection=ci_ecal_digi.outputHitCollection,
- outputHitCollection="EcalEndcapPRecHits",
- thresholdFactor=5.0,
- **ci_ecal_daq)
-algorithms.append(ci_ecal_reco)
-
-# merge hits in different layer (projection to local x-y plane)
-ci_ecal_merger = CalHitsMerger("ci_ecal_merger",
- inputHitCollection=ci_ecal_reco.outputHitCollection,
- outputHitCollection="EcalEndcapPRecMergedHits",
- fields=["layer", "slice"],
- fieldRefNumbers=[1, 0],
- readoutClass="EcalEndcapPHits")
-algorithms.append(ci_ecal_merger)
-
-ci_ecal_cl = IslandCluster("ci_ecal_cl",
- inputHitCollection=ci_ecal_merger.outputHitCollection,
- outputProtoClusterCollection="EcalEndcapPProtoClusters",
- splitCluster=False,
- minClusterCenterEdep=10.*units.MeV,
- localDistXY=[10*units.mm, 10*units.mm])
-algorithms.append(ci_ecal_cl)
-
-ci_ecal_clreco = RecoCoG("ci_ecal_clreco",
- inputHitCollection=ci_ecal_cl.inputHitCollection,
- inputProtoClusterCollection=ci_ecal_cl.outputProtoClusterCollection,
- outputClusterCollection="EcalEndcapPClusters",
- outputInfoCollection="EcalEndcapPClustersInfo",
- logWeightBase=6.2,
- samplingFraction=ci_ecal_sf)
-algorithms.append(ci_ecal_clreco)
-
-# Central Barrel Ecal (Imaging Cal.)
-img_barrel_daq = dict(
- dynamicRangeADC=3*units.MeV,
- capacityADC=8192,
- pedestalMean=400,
- pedestalSigma=20) # about 6 keV
-
-img_barrel_digi = CalHitDigi("img_barrel_digi",
- inputHitCollection="EcalBarrelHits",
- outputHitCollection="EcalBarrelImagingRawHits",
- energyResolutions=[0., 0.02, 0.], # 2% flat resolution
- **img_barrel_daq)
-algorithms.append(img_barrel_digi)
-
-img_barrel_reco = ImCalPixelReco("img_barrel_reco",
- inputHitCollection=img_barrel_digi.outputHitCollection,
- outputHitCollection="EcalBarrelImagingRecHits",
- thresholdFactor=3, # about 20 keV
- readoutClass="EcalBarrelHits", # readout class
- layerField="layer", # field to get layer id
- sectorField="module", # field to get sector id
- **img_barrel_daq)
-algorithms.append(img_barrel_reco)
-
-img_barrel_cl = ImagingCluster("img_barrel_cl",
- inputHitCollection=img_barrel_reco.outputHitCollection,
- outputProtoClusterCollection="EcalBarrelImagingProtoClusters",
- localDistXY=[2.*units.mm, 2*units.mm], # same layer
- layerDistEtaPhi=[10*units.mrad, 10*units.mrad], # adjacent layer
- neighbourLayersRange=2, # id diff for adjacent layer
- sectorDist=3.*units.cm) # different sector
-algorithms.append(img_barrel_cl)
-
-img_barrel_clreco = ImagingClusterReco("img_barrel_clreco",
- samplingFraction=img_barrel_sf,
- inputHitCollection=img_barrel_cl.inputHitCollection,
- inputProtoClusterCollection=img_barrel_cl.outputProtoClusterCollection,
- outputClusterCollection="EcalBarrelImagingClusters",
- outputInfoCollection="EcalBarrelImagingClustersInfo",
- outputLayerCollection="EcalBarrelImagingLayers")
-algorithms.append(img_barrel_clreco)
-
-# Central ECAL SciFi
-scfi_barrel_daq = dict(
- dynamicRangeADC=50.*MeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=10)
-
-scfi_barrel_digi = CalHitDigi("scfi_barrel_digi",
- inputHitCollection="EcalBarrelScFiHits",
- outputHitCollection="EcalBarrelScFiRawHits",
- **scfi_barrel_daq)
-algorithms.append(scfi_barrel_digi)
-
-scfi_barrel_reco = CalHitReco("scfi_barrel_reco",
- inputHitCollection=scfi_barrel_digi.outputHitCollection,
- outputHitCollection="EcalBarrelScFiRecHits",
- thresholdFactor=5.0,
- readoutClass="EcalBarrelScFiHits",
- layerField="layer",
- sectorField="module",
- localDetFields=["system", "module"], # use local coordinates in each module (stave)
- **scfi_barrel_daq)
-algorithms.append(scfi_barrel_reco)
-
-# merge hits in different layer (projection to local x-y plane)
-scfi_barrel_merger = CalHitsMerger("scfi_barrel_merger",
- inputHitCollection=scfi_barrel_reco.outputHitCollection,
- outputHitCollection="EcalBarrelScFiMergedHits",
- fields=["fiber"],
- fieldRefNumbers=[1],
- readoutClass="EcalBarrelScFiHits")
-algorithms.append(scfi_barrel_merger)
-
-scfi_barrel_cl = IslandCluster("scfi_barrel_cl",
- inputHitCollection=scfi_barrel_merger.outputHitCollection,
- outputProtoClusterCollection="EcalBarrelScFiProtoClusters",
- splitCluster=False,
- minClusterCenterEdep=10.*MeV,
- localDistXZ=[30*mm, 30*mm])
-algorithms.append(scfi_barrel_cl)
-
-scfi_barrel_clreco = RecoCoG("scfi_barrel_clreco",
- inputHitCollection=scfi_barrel_cl.inputHitCollection,
- inputProtoClusterCollection=scfi_barrel_cl.outputProtoClusterCollection,
- outputClusterCollection="EcalBarrelScFiClusters",
- outputInfoCollection="EcalBarrelScFiClustersInfo",
- logWeightBase=6.2,
- samplingFraction= scifi_barrel_sf)
-algorithms.append(scfi_barrel_clreco)
-
-# Central Barrel Hcal
-cb_hcal_daq = dict(
- dynamicRangeADC=50.*units.MeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=10)
-
-cb_hcal_digi = CalHitDigi("cb_hcal_digi",
- inputHitCollection="HcalBarrelHits",
- outputHitCollection="HcalBarrelRawHits",
- **cb_hcal_daq)
-algorithms.append(cb_hcal_digi)
-
-cb_hcal_reco = CalHitReco("cb_hcal_reco",
- inputHitCollection=cb_hcal_digi.outputHitCollection,
- outputHitCollection="HcalBarrelRecHits",
- thresholdFactor=5.0,
- readoutClass="HcalBarrelHits",
- layerField="layer",
- sectorField="module",
- **cb_hcal_daq)
-algorithms.append(cb_hcal_reco)
-
-cb_hcal_merger = CalHitsMerger("cb_hcal_merger",
- inputHitCollection=cb_hcal_reco.outputHitCollection,
- outputHitCollection="HcalBarrelMergedHits",
- readoutClass="HcalBarrelHits",
- fields=["layer", "slice"],
- fieldRefNumbers=[1, 0])
-algorithms.append(cb_hcal_merger)
-
-cb_hcal_cl = IslandCluster("cb_hcal_cl",
- inputHitCollection=cb_hcal_merger.outputHitCollection,
- outputProtoClusterCollection="HcalBarrelProtoClusters",
- splitCluster=False,
- minClusterCenterEdep=30.*units.MeV,
- localDistXY=[15.*units.cm, 15.*units.cm])
-algorithms.append(cb_hcal_cl)
-
-cb_hcal_clreco = RecoCoG("cb_hcal_clreco",
- inputHitCollection=cb_hcal_cl.inputHitCollection,
- inputProtoClusterCollection=cb_hcal_cl.outputProtoClusterCollection,
- outputClusterCollection="HcalBarrelClusters",
- outputInfoCollection="HcalBarrelClustersInfo",
- logWeightBase=6.2,
- samplingFraction=cb_hcal_sf)
-algorithms.append(cb_hcal_clreco)
-
-# Hcal Hadron Endcap
-ci_hcal_daq = dict(
- dynamicRangeADC=50.*units.MeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=10)
-
-ci_hcal_digi = CalHitDigi("ci_hcal_digi",
- inputHitCollection="HcalEndcapPHits",
- outputHitCollection="HcalEndcapPRawHits",
- **ci_hcal_daq)
-algorithms.append(ci_hcal_digi)
-
-ci_hcal_reco = CalHitReco("ci_hcal_reco",
- inputHitCollection=ci_hcal_digi.outputHitCollection,
- outputHitCollection="HcalEndcapPRecHits",
- thresholdFactor=5.0,
- **ci_hcal_daq)
-algorithms.append(ci_hcal_reco)
-
-ci_hcal_merger = CalHitsMerger("ci_hcal_merger",
- inputHitCollection=ci_hcal_reco.outputHitCollection,
- outputHitCollection="HcalEndcapPMergedHits",
- readoutClass="HcalEndcapPHits",
- fields=["layer", "slice"],
- fieldRefNumbers=[1, 0])
-algorithms.append(ci_hcal_merger)
-
-ci_hcal_cl = IslandCluster("ci_hcal_cl",
- inputHitCollection=ci_hcal_merger.outputHitCollection,
- outputProtoClusterCollection="HcalEndcapPProtoClusters",
- splitCluster=False,
- minClusterCenterEdep=30.*units.MeV,
- localDistXY=[15.*units.cm, 15.*units.cm])
-algorithms.append(ci_hcal_cl)
-
-ci_hcal_clreco = RecoCoG("ci_hcal_clreco",
- inputHitCollection=ci_hcal_cl.inputHitCollection,
- inputProtoClusterCollection=ci_hcal_cl.outputProtoClusterCollection,
- outputClusterCollection="HcalEndcapPClusters",
- outputInfoCollection="HcalEndcapPClustersInfo",
- logWeightBase=6.2,
- samplingFraction=ci_hcal_sf)
-algorithms.append(ci_hcal_clreco)
-
-# Hcal Electron Endcap
-ce_hcal_daq = dict(
- dynamicRangeADC=50.*units.MeV,
- capacityADC=32768,
- pedestalMean=400,
- pedestalSigma=10)
-
-ce_hcal_digi = CalHitDigi("ce_hcal_digi",
- inputHitCollection="HcalEndcapNHits",
- outputHitCollection="HcalEndcapNRawHits",
- **ce_hcal_daq)
-algorithms.append(ce_hcal_digi)
-
-ce_hcal_reco = CalHitReco("ce_hcal_reco",
- inputHitCollection=ce_hcal_digi.outputHitCollection,
- outputHitCollection="HcalEndcapNRecHits",
- thresholdFactor=5.0,
- **ce_hcal_daq)
-algorithms.append(ce_hcal_reco)
-
-ce_hcal_merger = CalHitsMerger("ce_hcal_merger",
- inputHitCollection=ce_hcal_reco.outputHitCollection,
- outputHitCollection="HcalEndcapNMergedHits",
- readoutClass="HcalEndcapNHits",
- fields=["layer", "slice"],
- fieldRefNumbers=[1, 0])
-algorithms.append(ce_hcal_merger)
-
-ce_hcal_cl = IslandCluster("ce_hcal_cl",
- inputHitCollection=ce_hcal_merger.outputHitCollection,
- outputProtoClusterCollection="HcalEndcapNProtoClusters",
- splitCluster=False,
- minClusterCenterEdep=30.*units.MeV,
- localDistXY=[15.*units.cm, 15.*units.cm])
-algorithms.append(ce_hcal_cl)
-
-ce_hcal_clreco = RecoCoG("ce_hcal_clreco",
- inputHitCollection=ce_hcal_cl.inputHitCollection,
- inputProtoClusterCollection=ce_hcal_cl.outputProtoClusterCollection,
- outputClusterCollection="HcalEndcapNClusters",
- outputInfoCollection="HcalEndcapNClustersInfo",
- logWeightBase=6.2,
- samplingFraction=ce_hcal_sf)
-algorithms.append(ce_hcal_clreco)
-
-# Tracking
-trk_b_digi = TrackerDigi("trk_b_digi",
- inputHitCollection="TrackerBarrelHits",
- outputHitCollection="TrackerBarrelRawHits",
- timeResolution=8)
-algorithms.append(trk_b_digi)
-
-trk_ec_digi = TrackerDigi("trk_ec_digi",
- inputHitCollection="TrackerEndcapHits",
- outputHitCollection="TrackerEndcapRawHits",
- timeResolution=8)
-algorithms.append(trk_ec_digi)
-
-vtx_b_digi = TrackerDigi("vtx_b_digi",
- inputHitCollection="VertexBarrelHits",
- outputHitCollection="VertexBarrelRawHits",
- timeResolution=8)
-algorithms.append(vtx_b_digi)
-
-vtx_ec_digi = TrackerDigi("vtx_ec_digi",
- inputHitCollection="VertexEndcapHits",
- outputHitCollection="VertexEndcapRawHits",
- timeResolution=8)
-algorithms.append(vtx_ec_digi)
-
-gem_ec_digi = TrackerDigi("gem_ec_digi",
- inputHitCollection="GEMTrackerEndcapHits",
- outputHitCollection="GEMTrackerEndcapRawHits",
- timeResolution=10)
-algorithms.append(gem_ec_digi)
-
-# Tracker and vertex reconstruction
-trk_b_reco = TrackerHitReconstruction("trk_b_reco",
- inputHitCollection = trk_b_digi.outputHitCollection,
- outputHitCollection="TrackerBarrelRecHits")
-algorithms.append(trk_b_reco)
-
-trk_ec_reco = TrackerHitReconstruction("trk_ec_reco",
- inputHitCollection = trk_ec_digi.outputHitCollection,
- outputHitCollection="TrackerEndcapRecHits")
-algorithms.append(trk_ec_reco)
-
-vtx_b_reco = TrackerHitReconstruction("vtx_b_reco",
- inputHitCollection = vtx_b_digi.outputHitCollection,
- outputHitCollection="VertexBarrelRecHits")
-algorithms.append(vtx_b_reco)
-
-vtx_ec_reco = TrackerHitReconstruction("vtx_ec_reco",
- inputHitCollection = vtx_ec_digi.outputHitCollection,
- outputHitCollection="VertexEndcapRecHits")
-algorithms.append(vtx_ec_reco)
-
-gem_ec_reco = TrackerHitReconstruction("gem_ec_reco",
- inputHitCollection=gem_ec_digi.outputHitCollection,
- outputHitCollection="GEMTrackerEndcapRecHits")
-algorithms.append(gem_ec_reco)
-
-# Tracking hit collector
-trk_hit_col = TrackingHitsCollector("trk_hit_col",
- inputTrackingHits=[
- str(trk_b_reco.outputHitCollection),
- str(trk_ec_reco.outputHitCollection),
- str(vtx_b_reco.outputHitCollection),
- str(vtx_ec_reco.outputHitCollection),
- str(gem_ec_reco.outputHitCollection) ],
- trackingHits="trackingHits")
-algorithms.append(trk_hit_col)
-
-# Hit Source linker
-sourcelinker = TrackerSourceLinker("trk_srcslnkr",
- inputHitCollection = trk_hit_col.trackingHits,
- outputSourceLinks = "TrackSourceLinks",
- outputMeasurements = "TrackMeasurements")
-algorithms.append(sourcelinker)
-
-## Track param init
-truth_trk_init = TrackParamTruthInit("truth_trk_init",
- inputMCParticles="mcparticles",
- outputInitialTrackParameters="InitTrackParams")
-algorithms.append(truth_trk_init)
-
-# Tracking algorithms
-trk_find_alg = TrackFindingAlgorithm("trk_find_alg",
- inputSourceLinks = sourcelinker.outputSourceLinks,
- inputMeasurements = sourcelinker.outputMeasurements,
- inputInitialTrackParameters = truth_trk_init.outputInitialTrackParameters,
- outputTrajectories = "trajectories")
-algorithms.append(trk_find_alg)
-
-parts_from_fit = ParticlesFromTrackFit("parts_from_fit",
- inputTrajectories = trk_find_alg.outputTrajectories,
- outputParticles = "outputParticles",
- outputTrackParameters = "outputTrackParameters")
-algorithms.append(parts_from_fit)
-
-# Event building
-parts_with_truth_pid = ParticlesWithTruthPID("parts_with_truth_pid",
- inputMCParticles = "mcparticles",
- inputTrackParameters = parts_from_fit.outputTrackParameters,
- outputParticles = "ReconstructedParticles")
-algorithms.append(parts_with_truth_pid)
-
-# DRICH
-drich_digi = PhotoMultiplierDigi("drich_digi",
- inputHitCollection="DRICHHits",
- outputHitCollection="DRICHRawHits",
- quantumEfficiency=[(a*units.eV, b) for a, b in qe_data])
-algorithms.append(drich_digi)
-
-drich_reco = PhotoMultiplierReco("drich_reco",
- inputHitCollection=drich_digi.outputHitCollection,
- outputHitCollection="DRICHRecHits")
-algorithms.append(drich_reco)
-
-# FIXME
-#drich_cluster = PhotoRingClusters("drich_cluster",
-# inputHitCollection=pmtreco.outputHitCollection,
-# #inputTrackCollection="ReconstructedParticles",
-# outputClusterCollection="ForwardRICHClusters")
-
-# MRICH
-mrich_digi = PhotoMultiplierDigi("mrich_digi",
- inputHitCollection="MRICHHits",
- outputHitCollection="MRICHRawHits",
- quantumEfficiency=[(a*units.eV, b) for a, b in qe_data])
-algorithms.append(mrich_digi)
-
-mrich_reco = PhotoMultiplierReco("mrich_reco",
- inputHitCollection=mrich_digi.outputHitCollection,
- outputHitCollection="MRICHRecHits")
-algorithms.append(mrich_reco)
-
-# FIXME
-#mrich_cluster = PhotoRingClusters("drich_cluster",
-# inputHitCollection=pmtreco.outputHitCollection,
-# #inputTrackCollection="ReconstructedParticles",
-# outputClusterCollection="ForwardRICHClusters")
-
-# Output
-podout = PodioOutput("out", filename=output_rec)
-podout.outputCommands = [
- "keep *",
- "drop *Hits",
- "keep *Layers",
- "keep *Clusters",
- "drop *ProtoClusters",
- "drop outputParticles",
- "drop InitTrackParams",
- ] + [ "drop " + c for c in sim_coll]
-algorithms.append(podout)
-
-ApplicationMgr(
- TopAlg = algorithms,
- EvtSel = 'NONE',
- EvtMax = n_events,
- ExtSvc = [podioevent,geo_service],
- OutputLevel=WARNING
- )
diff --git a/benchmarks/full/scripts/gen_particles.py b/benchmarks/full/scripts/gen_particles.py
deleted file mode 100644
index 0609714c5bd10b38230e82c6de12be6768be7b08..0000000000000000000000000000000000000000
--- a/benchmarks/full/scripts/gen_particles.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import os
-from pyHepMC3 import HepMC3 as hm
-import numpy as np
-import argparse
-
-
-PARTICLES = {
- "pion0": (111, 0.1349766), # pi0
- "pion+": (211, 0.13957018), # pi+
- "pion-": (-211, 0.13957018), # pi-
- "kaon0L": (130, 0.497648), # K0L
- "kaon0S": (310, 0.497648), # K0S
- "kaon0": (311, 0.497648), # K0
- "kaon+": (321, 0.493677), # K+
- "kaon-": (-321, 0.493677), # K-
- "proton": (2212, 0.938272), # proton
- "neutron": (2112, 0.939565), # neutron
- "electron": (11, 0.51099895e-3), # electron
- "positron": (-11, 0.51099895e-3),# positron
- "photon": (22, 0), # photon
-}
-
-REGIONS = {
- "farforward": (1, 4),
- "forward": (3, 50),
- "barrel": (45, 135),
- "backward": (130, 177),
- "farbackward": (176, 179),
-}
-
-def gen_event(p, theta, phi, pid, mass):
- evt = hm.GenEvent(momentum_unit=hm.Units.MomentumUnit.GEV, length_unit=hm.Units.LengthUnit.MM)
- # final state
- state = 1
- e0 = np.sqrt(p*p + mass*mass)
- px = np.cos(phi)*np.sin(theta)
- py = np.sin(phi)*np.sin(theta)
- pz = np.cos(theta)
-
- # beam
- pbeam = hm.GenParticle(hm.FourVector(0, 0, 0, 0.938272), 2212, 4)
- ebeam = hm.GenParticle(hm.FourVector(0, 0, e0, np.sqrt(e0*e0 + 0.511e-3*0.511e-3)), 11, 4)
-
- # out particle
- hout = hm.GenParticle(hm.FourVector(px*p, py*p, pz*p, e0), pid, state)
-
- # vertex
- vert = hm.GenVertex()
- vert.add_particle_in(ebeam)
- vert.add_particle_in(pbeam)
- vert.add_particle_out(hout)
- evt.add_vertex(vert)
- return evt
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
-
- parser.add_argument('output', help='path to the output file')
- parser.add_argument('-n', type=int, default=1000, dest='nev', help='number of events to generate')
- parser.add_argument('-s', type=int, default=-1, dest='seed', help='seed for random generator')
- parser.add_argument('--parray', type=str, default="", dest='parray',
- help='an array of momenta in GeV, separated by \",\"')
- parser.add_argument('--pmin', type=float, default=8.0, dest='pmin', help='minimum momentum in GeV')
- parser.add_argument('--pmax', type=float, default=100.0, dest='pmax', help='maximum momentum in GeV')
- parser.add_argument('--angmin', type=float, default=0.0, dest='angmin', help='minimum angle in degree')
- parser.add_argument('--angmax', type=float, default=20.0, dest='angmax', help='maximum angle in degree')
- parser.add_argument('--phmin', type=float, default=0.0, dest='phmin', help='minimum angle in degree')
- parser.add_argument('--phmax', type=float, default=360.0, dest='phmax', help='maximum angle in degree')
- parser.add_argument('--particles', type=str, default='electron', dest='particles',
- help='particle names, support {}'.format(list(PARTICLES.keys())))
- parser.add_argument('--regions', type=str, default='ignored', dest='regions',
- help='detector regions, support {}'.format(list(REGIONS.keys())))
-
- args = parser.parse_args()
-
- # random seed (< 0 will get it from enviroment variable 'SEED', or a system random number)
- if args.seed < 0:
- args.seed = os.environ.get('SEED', int.from_bytes(os.urandom(4), byteorder='big', signed=False))
- print("Random seed is {}".format(args.seed))
- np.random.seed(args.seed)
-
- output = hm.WriterAscii(args.output);
- if output.failed():
- print("Cannot open file \"{}\"".format(args.output))
- sys.exit(2)
-
- # build particle info
- parts = []
- for pid in args.particles.split(','):
- pid = pid.strip()
- if pid not in PARTICLES.keys():
- print('pid {:d} not found in dictionary, ignored.'.format(pid))
- continue
- parts.append(PARTICLES[pid])
-
- # interpret region
- (angmin, angmax) = (args.angmin, args.angmax)
- for region in args.regions.split(','):
- region = region.strip()
- if region not in REGIONS.keys():
- print('region {:d} not found in dictionary, ignored.'.format(pid))
- continue
- (angmin, angmax) = REGIONS[region]
-
- # p values
- pvals = np.random.uniform(args.pmin, args.pmax, args.nev) if not args.parray else \
- np.random.choice([float(p.strip()) for p in args.parray.split(',')], args.nev)
- thvals = np.random.uniform(angmin, angmax, args.nev)/180.*np.pi
- phivals = np.random.uniform(args.phmin, args.phmax, args.nev)/180.*np.pi
- partvals = [parts[i] for i in np.random.choice(len(parts), args.nev)]
-
- count = 0
- for p, theta, phi, (pid, mass) in zip(pvals, thvals, phivals, partvals):
- if (count % 1000 == 0):
- print("Generated {} events".format(count), end='\r')
- evt = gen_event(p, theta, phi, pid, mass)
- output.write_event(evt)
- evt.clear()
- count += 1
-
- print("Generated {} events".format(args.nev))
- output.close()
-