From b6c0926f5aa93c8b09b4092da37d91982f40dc8e Mon Sep 17 00:00:00 2001 From: sungbinoh Date: Wed, 28 Feb 2024 19:57:05 -0600 Subject: [PATCH 01/13] A commit to add CRT and PDS info in calib ntuple using updated reco2_sce.fcl and additional modules. --- sbndcode/CMakeLists.txt | 1 + sbndcode/CRT/CRTAna/CRTCalibAna_module.cc | 1331 +++++++++++++++++ .../standard/reco/reco2_sce.fcl | 26 +- sbndcode/PDS/CMakeLists.txt | 1 + sbndcode/PDS/OpReco/CMakeLists.txt | 38 + sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc | 760 ++++++++++ 6 files changed, 2156 insertions(+), 1 deletion(-) create mode 100644 sbndcode/CRT/CRTAna/CRTCalibAna_module.cc create mode 100644 sbndcode/PDS/CMakeLists.txt create mode 100644 sbndcode/PDS/OpReco/CMakeLists.txt create mode 100644 sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc diff --git a/sbndcode/CMakeLists.txt b/sbndcode/CMakeLists.txt index 24962599d..928924035 100644 --- a/sbndcode/CMakeLists.txt +++ b/sbndcode/CMakeLists.txt @@ -15,6 +15,7 @@ add_subdirectory(OpDetSim) add_subdirectory(OpDetReco) add_subdirectory(OpDetAnalyzer) add_subdirectory(OpT0Finder) +add_subdirectory(PDS) #add_subdirectory(CosmicId) add_subdirectory(ShowerAna) add_subdirectory(Commissioning) diff --git a/sbndcode/CRT/CRTAna/CRTCalibAna_module.cc b/sbndcode/CRT/CRTAna/CRTCalibAna_module.cc new file mode 100644 index 000000000..ef660c09e --- /dev/null +++ b/sbndcode/CRT/CRTAna/CRTCalibAna_module.cc @@ -0,0 +1,1331 @@ +//////////////////////////////////////////////////////////////////////// +// Class: CRTCalibAna +// Plugin Type: analyzer +// File: CRTCalibAna_module.cc +// Author: Sungbin Oh based on Henry Lay (h.lay@lancaster.ac.uk) CRTCalibAna_module.cc +//////////////////////////////////////////////////////////////////////// + +#include "art/Framework/Core/EDAnalyzer.h" +#include "art/Framework/Core/ModuleMacros.h" +#include "art/Framework/Principal/Event.h" +#include "art/Framework/Principal/Handle.h" +#include "art/Framework/Principal/Run.h" +#include "art/Framework/Principal/SubRun.h" +#include "canvas/Utilities/InputTag.h" +#include "fhiclcpp/ParameterSet.h" +#include "messagefacility/MessageLogger/MessageLogger.h" +#include "art_root_io/TFileService.h" +#include "canvas/Persistency/Common/FindManyP.h" + +#include "TTree.h" + +#include "lardataobj/AnalysisBase/T0.h" +#include "lardataobj/RecoBase/Track.h" +#include "lardataobj/RecoBase/PFParticle.h" +#include "lardataobj/RecoBase/PFParticleMetadata.h" + +#include "larsim/Utils/TruthMatchUtils.h" +#include "lardata/DetectorInfoServices/DetectorClocksService.h" + +#include "sbnobj/SBND/CRT/FEBData.hh" +#include "sbnobj/SBND/CRT/CRTStripHit.hh" +#include "sbnobj/SBND/CRT/CRTCluster.hh" +#include "sbnobj/SBND/CRT/CRTSpacePoint.hh" +#include "sbnobj/SBND/CRT/CRTTrack.hh" + +#include "sbndcode/Geometry/GeometryWrappers/CRTGeoAlg.h" +#include "sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.h" +#include "sbndcode/CRT/CRTBackTracker/CRTBackTrackerAlg.h" +#include "sbndcode/CRT/CRTUtils/CRTCommonUtils.h" + +namespace sbnd::crt { + class CRTCalibAna; +} + +class sbnd::crt::CRTCalibAna : public art::EDAnalyzer { +public: + explicit CRTCalibAna(fhicl::ParameterSet const& p); + // The compiler-generated destructor is fine for non-base + // classes without bare pointers or other resource use. + + // Plugins should not be copied or assigned. + CRTCalibAna(CRTCalibAna const&) = delete; + CRTCalibAna(CRTCalibAna&&) = delete; + CRTCalibAna& operator=(CRTCalibAna const&) = delete; + CRTCalibAna& operator=(CRTCalibAna&&) = delete; + + // Required functions. + void analyze(art::Event const& e) override; + + void AnalyseMCParticles(std::vector> &MCParticleVec); + + void AnalyseSimDeposits(std::vector> &SimDepositVec); + + void AnalyseFEBDatas(std::vector> &FEBDataVec); + + void AnalyseCRTStripHits(const art::Event &e, const std::vector> &CRTStripHitVec); + + void AnalyseCRTClusters(const art::Event &e, const std::vector> &CRTClusterVec, const art::FindManyP &clustersToSpacePoints); + + void AnalyseTrueDepositsPerTagger(const std::map &recoStatusMap); + + void AnalyseTrueDeposits(const std::map> &recoStatusMap); + + void AnalyseCRTTracks(const art::Event &e, const std::vector> &CRTTrackVec); + + void AnalyseTPCMatching(const art::Event &e, const art::Handle> &TPCTrackHandle, + const art::Handle> &CRTSpacePointModuleLabel, const art::Handle> &PFPHandle, + const std::map &spacePointRecoStatusMap, const std::map> &trackRecoStatusMap); + +private: + + CRTGeoAlg fCRTGeoAlg; + TPCGeoAlg fTPCGeoAlg; + CRTBackTrackerAlg fCRTBackTrackerAlg; + + std::string fMCParticleModuleLabel, fSimDepositModuleLabel, fFEBDataModuleLabel, fCRTStripHitModuleLabel, + fCRTClusterModuleLabel, fCRTSpacePointModuleLabel, fCRTTrackModuleLabel, fTPCTrackModuleLabel, + fCRTSpacePointMatchingModuleLabel, fCRTTrackMatchingModuleLabel, fPFPModuleLabel; + bool fDebug; + + TTree* fDAQNtuple; + TTree* fHitNtuple; + TTree* fTree; + + // Tree variables + + int _run; + int _subrun; + int _event; + + std::vector _mc_trackid; + std::vector _mc_pdg; + std::vector _mc_status; + std::vector _mc_ndaughters; + std::vector> _mc_daughters; + std::vector _mc_vx; + std::vector _mc_vy; + std::vector _mc_vz; + std::vector _mc_vt; + std::vector _mc_endx; + std::vector _mc_endy; + std::vector _mc_endz; + std::vector _mc_endt; + std::vector _mc_vpx; + std::vector _mc_vpy; + std::vector _mc_vpz; + std::vector _mc_ve; + std::vector _mc_endpx; + std::vector _mc_endpy; + std::vector _mc_endpz; + std::vector _mc_ende; + + std::vector _ide_trackid; + std::vector _ide_e; + std::vector _ide_entryx; + std::vector _ide_entryy; + std::vector _ide_entryz; + std::vector _ide_entryt; + std::vector _ide_exitx; + std::vector _ide_exity; + std::vector _ide_exitz; + std::vector _ide_exitt; + + int _feb_NMaxCh; + std::vector _feb_mac5; + std::vector _feb_flags; + std::vector _feb_ts0; + std::vector _feb_ts1; + std::vector _feb_unixs; + std::vector> _feb_adc; + std::vector _feb_coinc; + + std::vector _sh_channel; + std::vector _sh_ts0; + std::vector _sh_ts1; + std::vector _sh_unixs; + std::vector _sh_pos; + std::vector _sh_err; + std::vector _sh_adc1; + std::vector _sh_adc2; + std::vector _sh_saturated1; + std::vector _sh_saturated2; + std::vector _sh_truth_trackid; + std::vector _sh_truth_completeness; + std::vector _sh_truth_purity; + std::vector _sh_truth_pos; + std::vector _sh_truth_energy; + std::vector _sh_truth_time; + + std::vector _cl_ts0; + std::vector _cl_ts1; + std::vector _cl_unixs; + std::vector _cl_nhits; + std::vector _cl_tagger; + std::vector _cl_composition; + std::vector _cl_truth_trackid; + std::vector _cl_truth_completeness; + std::vector _cl_truth_purity; + std::vector _cl_truth_hit_completeness; + std::vector _cl_truth_hit_purity; + std::vector _cl_truth_pdg; + std::vector _cl_truth_energy; + std::vector _cl_truth_time; + std::vector _cl_truth_x; + std::vector _cl_truth_y; + std::vector _cl_truth_z; + std::vector _cl_truth_core_energy; + std::vector _cl_truth_core_time; + std::vector _cl_truth_core_x; + std::vector _cl_truth_core_y; + std::vector _cl_truth_core_z; + std::vector _cl_has_sp; + std::vector _cl_sp_x; + std::vector _cl_sp_ex; + std::vector _cl_sp_y; + std::vector _cl_sp_ey; + std::vector _cl_sp_z; + std::vector _cl_sp_ez; + std::vector _cl_sp_pe; + std::vector _cl_sp_time; + std::vector _cl_sp_etime; + std::vector _cl_sp_complete; + + std::vector _td_tag_trackid; + std::vector _td_tag_pdg; + std::vector _td_tag_tagger; + std::vector _td_tag_energy; + std::vector _td_tag_time; + std::vector _td_tag_x; + std::vector _td_tag_y; + std::vector _td_tag_z; + std::vector _td_tag_reco_status; + + std::vector _td_trackid; + std::vector _td_pdg; + std::vector _td_energy; + std::vector _td_time; + std::vector _td_reconstructable; + std::vector _td_reco_status; + std::vector _td_reco_triple; + + std::vector _tr_start_x; + std::vector _tr_start_y; + std::vector _tr_start_z; + std::vector _tr_end_x; + std::vector _tr_end_y; + std::vector _tr_end_z; + std::vector _tr_dir_x; + std::vector _tr_dir_y; + std::vector _tr_dir_z; + std::vector _tr_time; + std::vector _tr_etime; + std::vector _tr_pe; + std::vector _tr_length; + std::vector _tr_tof; + std::vector _tr_theta; + std::vector _tr_phi; + std::vector _tr_triple; + std::vector> _tr_taggers; + std::vector _tr_truth_trackid; + std::vector _tr_truth_completeness; + std::vector _tr_truth_purity; + std::vector _tr_truth_pdg; + std::vector _tr_truth_energy; + std::vector _tr_truth_time; + std::vector _tr_truth_start_x; + std::vector _tr_truth_start_y; + std::vector _tr_truth_start_z; + std::vector _tr_truth_end_x; + std::vector _tr_truth_end_y; + std::vector _tr_truth_end_z; + std::vector _tr_truth_dir_x; + std::vector _tr_truth_dir_y; + std::vector _tr_truth_dir_z; + std::vector _tr_truth_particle_energy; + std::vector _tr_truth_length; + std::vector _tr_truth_tof; + std::vector _tr_truth_theta; + std::vector _tr_truth_phi; + + std::vector _tpc_start_x; + std::vector _tpc_start_y; + std::vector _tpc_start_z; + std::vector _tpc_end_x; + std::vector _tpc_end_y; + std::vector _tpc_end_z; + std::vector _tpc_dir_x; + std::vector _tpc_dir_y; + std::vector _tpc_dir_z; + std::vector _tpc_length; + std::vector _tpc_track_score; + std::vector _tpc_truth_trackid; + std::vector _tpc_truth_pdg; + std::vector _tpc_truth_energy; + std::vector _tpc_truth_time; + std::vector _tpc_sp_matchable; + std::vector _tpc_sp_matched; + std::vector _tpc_sp_good_match; + std::vector _tpc_sp_time; + std::vector _tpc_sp_score; + std::vector _tpc_tr_matchable; + std::vector _tpc_tr_matched; + std::vector _tpc_tr_good_match; + std::vector _tpc_tr_time; + std::vector _tpc_tr_score; +}; + +sbnd::crt::CRTCalibAna::CRTCalibAna(fhicl::ParameterSet const& p) + : EDAnalyzer{p} + , fCRTGeoAlg(p.get("CRTGeoAlg", fhicl::ParameterSet())) + , fCRTBackTrackerAlg(p.get("CRTBackTrackerAlg", fhicl::ParameterSet())) + { + fMCParticleModuleLabel = p.get("MCParticleModuleLabel", "largeant"); + fSimDepositModuleLabel = p.get("SimDepositModuleLabel", "genericcrt"); + fFEBDataModuleLabel = p.get("FEBDataModuleLabel", "crtsim"); + fCRTStripHitModuleLabel = p.get("CRTStripHitModuleLabel", "crtstrips"); + fCRTClusterModuleLabel = p.get("CRTClusterModuleLabel", "crtclustering"); + fCRTSpacePointModuleLabel = p.get("CRTSpacePointModuleLabel", "crtspacepoints"); + fCRTTrackModuleLabel = p.get("CRTTrackModuleLabel", "crttracks"); + fTPCTrackModuleLabel = p.get("TPCTrackModuleLabel", "pandoraSCETrack"); + fCRTSpacePointMatchingModuleLabel = p.get("CRTSpacePointMatchingModuleLabel", "crtspacepointmatchingSCE"); + fCRTTrackMatchingModuleLabel = p.get("CRTTrackMatchingModuleLabel", "crttrackmatchingSCE"); + fPFPModuleLabel = p.get("PFPModuleLabel", "pandora"); + fDebug = p.get("Debug", false); + + art::ServiceHandle fs; + + fDAQNtuple = fs->make("DAQTree", "MyCRTDAQ"); + fHitNtuple = fs->make("HitTree", "MyCRTHit"); + fTree = fs->make("CRTAna", "MyCRTAna"); + + // Define the branches of our DetSim n-tuple + fDAQNtuple->Branch("run", &_run); + fDAQNtuple->Branch("subrun", &_subrun); + fDAQNtuple->Branch("event", &_event); + //fDAQNtuple->Branch("nChan", &fNChan, "nChan/I"); + fDAQNtuple->Branch("t0", "std::vector", &_feb_ts0); + fDAQNtuple->Branch("t1", "std::vector", &_feb_ts1); + fDAQNtuple->Branch("flags", "std::vector", &_feb_flags); + fDAQNtuple->Branch("nmaxch", &_feb_NMaxCh); // == Just 32 + fDAQNtuple->Branch("adc", "std::vector>", &_feb_adc); + //fDAQNtuple->Branch("pe", fPE, "pe[nmaxch]/F"); + //fDAQNtuple->Branch("entry", &fEntry, "entry/I"); + fDAQNtuple->Branch("mac5", "std::vector", &_feb_mac5); + //fDAQNtuple->Branch("region", &fFEBReg, "region/I"); + //fDAQNtuple->Branch("subSys", &fDetSubSys, "subSys/I"); + //fDAQNtuple->Branch("gate_type", &m_gate_type, "gate_type/b"); // Trigger related from "ExtraTriggerInfo.h" + //fDAQNtuple->Branch("gate_start_timestamp", &m_gate_start_timestamp, "gate_start_timestamp/l");// Define the branches of our DetSim n-tuple + + // Define the branches of our SimHit n-tuple + fHitNtuple->Branch("run", &_run); + fHitNtuple->Branch("subrun", &_subrun); + fHitNtuple->Branch("event", &_event); + fHitNtuple->Branch("nHit", "std::vector", &_cl_nhits); + fHitNtuple->Branch("x", "std::vector", &_cl_sp_x); + fHitNtuple->Branch("y", "std::vector", &_cl_sp_y); + fHitNtuple->Branch("z", "std::vector", &_cl_sp_z); + fHitNtuple->Branch("xErr", "std::vector", &_cl_sp_ex); + fHitNtuple->Branch("yErr", "std::vector", &_cl_sp_ey); + fHitNtuple->Branch("zErr", "std::vector", &_cl_sp_ez); + fHitNtuple->Branch("t", "std::vector", &_cl_sp_time); + fHitNtuple->Branch("tErr", "std::vector", &_cl_sp_etime); + fHitNtuple->Branch("t0", "std::vector", &_cl_ts0); + fHitNtuple->Branch("t1", "std::vector", &_cl_ts1); + //fHitNtuple->Branch("NChan", &fHitNChan, "nChan/I"); + fHitNtuple->Branch("PEs", "std::vector", &_cl_sp_pe); + //fHitNtuple->Branch("Macs", &fHitMac, "Mac[32]/I"); + //fHitNtuple->Branch("Chans", &fHitChan, "Chans[32]/I"); + //fHitNtuple->Branch("region", &fHitReg, "region/I"); + //fHitNtuple->Branch("tagger", &ftagger, "tagger/C"); + //fHitNtuple->Branch("subSys", &fHitSubSys, "subSys/I"); + //fHitNtuple->Branch("modID", &fHitMod, "modID/I"); + //fHitNtuple->Branch("stripID", &fHitStrip, "stripID/I"); + //fHitNtuple->Branch("nFeb", &fNHitFeb, "nFeb/I"); + //fHitNtuple->Branch("totPe", &fHitTotPe, "totPe/F"); + //fHitNtuple->Branch("gate_type", &m_gate_type, "gate_type/b"); + //fHitNtuple->Branch("gate_name", &m_gate_name); + //fHitNtuple->Branch("trigger_timestamp", &m_trigger_timestamp, "trigger_timestamp/l"); + //fHitNtuple->Branch("gate_start_timestamp", &m_gate_start_timestamp, "gate_start_timestamp/l"); + //fHitNtuple->Branch("trigger_gate_diff", &m_trigger_gate_diff, "trigger_gate_diff/l"); + //fHitNtuple->Branch("gate_crt_diff",&m_gate_crt_diff, "gate_crt_diff/l"); + //fHitNtuple->Branch("crt_global_trigger",&m_crt_global_trigger,"crt_global_trigger/l"); + //fHitNtuple->Branch("crtGT_trig_diff",&m_crtGT_trig_diff,"crtGT_trig_diff/L"); + + fTree->Branch("run", &_run); + fTree->Branch("subrun", &_subrun); + fTree->Branch("event", &_event); + + fTree->Branch("mc_trackid", "std::vector", &_mc_trackid); + fTree->Branch("mc_pdg", "std::vector", &_mc_pdg); + fTree->Branch("mc_status", "std::vector", &_mc_status); + fTree->Branch("mc_ndaughters", "std::vector", &_mc_ndaughters); + fTree->Branch("mc_daughters", "std::vector>", &_mc_daughters); + fTree->Branch("mc_vx", "std::vector", &_mc_vx); + fTree->Branch("mc_vy", "std::vector", &_mc_vy); + fTree->Branch("mc_vz", "std::vector", &_mc_vz); + fTree->Branch("mc_vt", "std::vector", &_mc_vt); + fTree->Branch("mc_endx", "std::vector", &_mc_endx); + fTree->Branch("mc_endy", "std::vector", &_mc_endy); + fTree->Branch("mc_endz", "std::vector", &_mc_endz); + fTree->Branch("mc_endt", "std::vector", &_mc_endt); + fTree->Branch("mc_vpx", "std::vector", &_mc_vpx); + fTree->Branch("mc_vpy", "std::vector", &_mc_vpy); + fTree->Branch("mc_vpz", "std::vector", &_mc_vpz); + fTree->Branch("mc_ve", "std::vector", &_mc_ve); + fTree->Branch("mc_endpx", "std::vector", &_mc_endpx); + fTree->Branch("mc_endpy", "std::vector", &_mc_endpy); + fTree->Branch("mc_endpz", "std::vector", &_mc_endpz); + fTree->Branch("mc_ende", "std::vector", &_mc_ende); + + fTree->Branch("ide_trackid", "std::vector", &_ide_trackid); + fTree->Branch("ide_e", "std::vector", &_ide_e); + fTree->Branch("ide_entryx", "std::vector", &_ide_entryx); + fTree->Branch("ide_entryy", "std::vector", &_ide_entryy); + fTree->Branch("ide_entryz", "std::vector", &_ide_entryz); + fTree->Branch("ide_entryt", "std::vector", &_ide_entryt); + fTree->Branch("ide_exitx", "std::vector", &_ide_exitx); + fTree->Branch("ide_exity", "std::vector", &_ide_exity); + fTree->Branch("ide_exitz", "std::vector", &_ide_exitz); + fTree->Branch("ide_exitt", "std::vector", &_ide_exitt); + + fTree->Branch("feb_mac5", "std::vector", &_feb_mac5); + fTree->Branch("feb_flags", "std::vector", &_feb_flags); + fTree->Branch("feb_ts0", "std::vector", &_feb_ts0); + fTree->Branch("feb_ts1", "std::vector", &_feb_ts1); + fTree->Branch("feb_unixs", "std::vector", &_feb_unixs); + fTree->Branch("feb_adc", "std::vector>", &_feb_adc); + fTree->Branch("feb_coinc", "std::vector", &_feb_coinc); + + fTree->Branch("sh_channel", "std::vector", &_sh_channel); + fTree->Branch("sh_ts0", "std::vector", &_sh_ts0); + fTree->Branch("sh_ts1", "std::vector", &_sh_ts1); + fTree->Branch("sh_unixs", "std::vector", &_sh_unixs); + fTree->Branch("sh_pos", "std::vector", &_sh_pos); + fTree->Branch("sh_err", "std::vector", &_sh_err); + fTree->Branch("sh_adc1", "std::vector", &_sh_adc1); + fTree->Branch("sh_adc2", "std::vector", &_sh_adc2); + fTree->Branch("sh_saturated1", "std::vector", &_sh_saturated1); + fTree->Branch("sh_saturated2", "std::vector", &_sh_saturated2); + fTree->Branch("sh_truth_trackid", "std::vector", &_sh_truth_trackid); + fTree->Branch("sh_truth_completeness", "std::vector", &_sh_truth_completeness); + fTree->Branch("sh_truth_purity", "std::vector", &_sh_truth_purity); + fTree->Branch("sh_truth_pos", "std::vector", &_sh_truth_pos); + fTree->Branch("sh_truth_energy", "std::vector", &_sh_truth_energy); + fTree->Branch("sh_truth_time", "std::vector", &_sh_truth_time); + + fTree->Branch("cl_ts0", "std::vector", &_cl_ts0); + fTree->Branch("cl_ts1", "std::vector", &_cl_ts1); + fTree->Branch("cl_unixs", "std::vector", &_cl_unixs); + fTree->Branch("cl_nhits", "std::vector", &_cl_nhits); + fTree->Branch("cl_tagger", "std::vector", &_cl_tagger); + fTree->Branch("cl_composition", "std::vector", &_cl_composition); + fTree->Branch("cl_truth_trackid", "std::vector", &_cl_truth_trackid); + fTree->Branch("cl_truth_completeness", "std::vector", &_cl_truth_completeness); + fTree->Branch("cl_truth_purity", "std::vector", &_cl_truth_purity); + fTree->Branch("cl_truth_hit_completeness", "std::vector", &_cl_truth_hit_completeness); + fTree->Branch("cl_truth_hit_purity", "std::vector", &_cl_truth_hit_purity); + fTree->Branch("cl_truth_pdg", "std::vector", &_cl_truth_pdg); + fTree->Branch("cl_truth_energy", "std::vector", &_cl_truth_energy); + fTree->Branch("cl_truth_time", "std::vector", &_cl_truth_time); + fTree->Branch("cl_truth_x", "std::vector", &_cl_truth_x); + fTree->Branch("cl_truth_y", "std::vector", &_cl_truth_y); + fTree->Branch("cl_truth_z", "std::vector", &_cl_truth_z); + fTree->Branch("cl_truth_core_energy", "std::vector", &_cl_truth_core_energy); + fTree->Branch("cl_truth_core_time", "std::vector", &_cl_truth_core_time); + fTree->Branch("cl_truth_core_x", "std::vector", &_cl_truth_core_x); + fTree->Branch("cl_truth_core_y", "std::vector", &_cl_truth_core_y); + fTree->Branch("cl_truth_core_z", "std::vector", &_cl_truth_core_z); + fTree->Branch("cl_has_sp", "std::vector", &_cl_has_sp); + fTree->Branch("cl_sp_x", "std::vector", &_cl_sp_x); + fTree->Branch("cl_sp_ex", "std::vector", &_cl_sp_ex); + fTree->Branch("cl_sp_y", "std::vector", &_cl_sp_y); + fTree->Branch("cl_sp_ey", "std::vector", &_cl_sp_ey); + fTree->Branch("cl_sp_z", "std::vector", &_cl_sp_z); + fTree->Branch("cl_sp_ez", "std::vector", &_cl_sp_ez); + fTree->Branch("cl_sp_pe", "std::vector", &_cl_sp_pe); + fTree->Branch("cl_sp_time", "std::vector", &_cl_sp_time); + fTree->Branch("cl_sp_etime", "std::vector", &_cl_sp_etime); + fTree->Branch("cl_sp_complete", "std::vector", &_cl_sp_complete); + + fTree->Branch("td_tag_trackid", "std::vector", &_td_tag_trackid); + fTree->Branch("td_tag_pdg", "std::vector", &_td_tag_pdg); + fTree->Branch("td_tag_tagger", "std::vector", &_td_tag_tagger); + fTree->Branch("td_tag_energy", "std::vector", &_td_tag_energy); + fTree->Branch("td_tag_time", "std::vector", &_td_tag_time); + fTree->Branch("td_tag_x", "std::vector", &_td_tag_x); + fTree->Branch("td_tag_y", "std::vector", &_td_tag_y); + fTree->Branch("td_tag_z", "std::vector", &_td_tag_z); + fTree->Branch("td_tag_reco_status", "std::vector", &_td_tag_reco_status); + + fTree->Branch("td_trackid", "std::vector", &_td_trackid); + fTree->Branch("td_pdg", "std::vector", &_td_pdg); + fTree->Branch("td_energy", "std::vector", &_td_energy); + fTree->Branch("td_time", "std::vector", &_td_time); + fTree->Branch("td_reconstructable", "std::vector", &_td_reconstructable); + fTree->Branch("td_reco_status", "std::vector", &_td_reco_status); + fTree->Branch("td_reco_triple", "std::vector", &_td_reco_triple); + + fTree->Branch("tr_start_x", "std::vector", &_tr_start_x); + fTree->Branch("tr_start_y", "std::vector", &_tr_start_y); + fTree->Branch("tr_start_z", "std::vector", &_tr_start_z); + fTree->Branch("tr_end_x", "std::vector", &_tr_end_x); + fTree->Branch("tr_end_y", "std::vector", &_tr_end_y); + fTree->Branch("tr_end_z", "std::vector", &_tr_end_z); + fTree->Branch("tr_dir_x", "std::vector", &_tr_dir_x); + fTree->Branch("tr_dir_y", "std::vector", &_tr_dir_y); + fTree->Branch("tr_dir_z", "std::vector", &_tr_dir_z); + fTree->Branch("tr_time", "std::vector", &_tr_time); + fTree->Branch("tr_etime", "std::vector", &_tr_etime); + fTree->Branch("tr_pe", "std::vector", &_tr_pe); + fTree->Branch("tr_length", "std::vector", &_tr_length); + fTree->Branch("tr_tof", "std::vector", &_tr_tof); + fTree->Branch("tr_theta", "std::vector", &_tr_theta); + fTree->Branch("tr_phi", "std::vector", &_tr_phi); + fTree->Branch("tr_triple", "std::vector", &_tr_triple); + fTree->Branch("tr_taggers", "std::vector>", &_tr_taggers); + fTree->Branch("tr_truth_trackid", "std::vector", &_tr_truth_trackid); + fTree->Branch("tr_truth_completeness", "std::vector", &_tr_truth_completeness); + fTree->Branch("tr_truth_purity", "std::vector", &_tr_truth_purity); + fTree->Branch("tr_truth_pdg", "std::vector", &_tr_truth_pdg); + fTree->Branch("tr_truth_energy", "std::vector", &_tr_truth_energy); + fTree->Branch("tr_truth_time", "std::vector", &_tr_truth_time); + fTree->Branch("tr_truth_start_x", "std::vector", &_tr_truth_start_x); + fTree->Branch("tr_truth_start_y", "std::vector", &_tr_truth_start_y); + fTree->Branch("tr_truth_start_z", "std::vector", &_tr_truth_start_z); + fTree->Branch("tr_truth_end_x", "std::vector", &_tr_truth_end_x); + fTree->Branch("tr_truth_end_y", "std::vector", &_tr_truth_end_y); + fTree->Branch("tr_truth_end_z", "std::vector", &_tr_truth_end_z); + fTree->Branch("tr_truth_dir_x", "std::vector", &_tr_truth_dir_x); + fTree->Branch("tr_truth_dir_y", "std::vector", &_tr_truth_dir_y); + fTree->Branch("tr_truth_dir_z", "std::vector", &_tr_truth_dir_z); + fTree->Branch("tr_truth_particle_energy", "std::vector", &_tr_truth_particle_energy); + fTree->Branch("tr_truth_length", "std::vector", &_tr_truth_length); + fTree->Branch("tr_truth_tof", "std::vector", &_tr_truth_tof); + fTree->Branch("tr_truth_theta", "std::vector", &_tr_truth_theta); + fTree->Branch("tr_truth_phi", "std::vector", &_tr_truth_phi); + + fTree->Branch("tpc_start_x", "std::vector", &_tpc_start_x); + fTree->Branch("tpc_start_y", "std::vector", &_tpc_start_y); + fTree->Branch("tpc_start_z", "std::vector", &_tpc_start_z); + fTree->Branch("tpc_end_x", "std::vector", &_tpc_end_x); + fTree->Branch("tpc_end_y", "std::vector", &_tpc_end_y); + fTree->Branch("tpc_end_z", "std::vector", &_tpc_end_z); + fTree->Branch("tpc_dir_x", "std::vector", &_tpc_dir_x); + fTree->Branch("tpc_dir_y", "std::vector", &_tpc_dir_y); + fTree->Branch("tpc_dir_z", "std::vector", &_tpc_dir_z); + fTree->Branch("tpc_length", "std::vector", &_tpc_length); + fTree->Branch("tpc_track_score", "std::vector", &_tpc_track_score); + fTree->Branch("tpc_truth_trackid", "std::vector", &_tpc_truth_trackid); + fTree->Branch("tpc_truth_pdg", "std::vector", &_tpc_truth_pdg); + fTree->Branch("tpc_truth_energy", "std::vector", &_tpc_truth_energy); + fTree->Branch("tpc_truth_time", "std::vector", &_tpc_truth_time); + fTree->Branch("tpc_sp_matchable", "std::vector", &_tpc_sp_matchable); + fTree->Branch("tpc_sp_matched", "std::vector", &_tpc_sp_matched); + fTree->Branch("tpc_sp_good_match", "std::vector", &_tpc_sp_good_match); + fTree->Branch("tpc_sp_time", "std::vector", &_tpc_sp_time); + fTree->Branch("tpc_sp_score", "std::vector", &_tpc_sp_score); + fTree->Branch("tpc_tr_matchable", "std::vector", &_tpc_tr_matchable); + fTree->Branch("tpc_tr_matched", "std::vector", &_tpc_tr_matched); + fTree->Branch("tpc_tr_good_match", "std::vector", &_tpc_tr_good_match); + fTree->Branch("tpc_tr_time", "std::vector", &_tpc_tr_time); + fTree->Branch("tpc_tr_score", "std::vector", &_tpc_tr_score); + + if(fDebug) + { + for(auto const &[name, tagger] : fCRTGeoAlg.GetTaggers()) + { + std::cout << "Tagger: " << tagger.name << '\n' + << "X - Min: " << tagger.minX << " Max: " << tagger.maxX << '\n' + << "Y - Min: " << tagger.minY << " Max: " << tagger.maxY << '\n' + << "Z - Min: " << tagger.minZ << " Max: " << tagger.maxZ << '\n' << std::endl; + } + + std::cout << std::endl; + + for(auto const &[name, module] : fCRTGeoAlg.GetModules()) + { + std::cout << "Module: " << module.name << " (" << module.taggerName << ")" << '\n'; + if(module.minos) + std::cout << "MINOS module" << std::endl; + std::cout << "X - Min: " << module.minX << " Max: " << module.maxX << " Diff: " << module.maxX - module.minX << '\n' + << "Y - Min: " << module.minY << " Max: " << module.maxY << " Diff: " << module.maxY - module.minY << '\n' + << "Z - Min: " << module.minZ << " Max: " << module.maxZ << " Diff: " << module.maxZ - module.minZ << '\n' + << "Orientation: " << module.orientation << '\n' << std::endl; + } + + std::cout << std::endl; + + for(auto const &[name, sipm] : fCRTGeoAlg.GetSiPMs()) + { + std::cout << "SiPM: " << sipm.channel << " (" << sipm.channel/32 << " - " << sipm.channel%32 << ")" << '\n' + << "x: " << sipm.x << " y: " << sipm.y << " z: " << sipm.z << std::endl; + } + } + } + +void sbnd::crt::CRTCalibAna::analyze(art::Event const& e) +{ + fCRTBackTrackerAlg.SetupMaps(e); + fCRTBackTrackerAlg.RunSpacePointRecoStatusChecks(e); + fCRTBackTrackerAlg.RunTrackRecoStatusChecks(e); + + _run = e.id().run(); + _subrun = e.id().subRun(); + _event = e.id().event(); + + if(fDebug) std::cout << "This is event " << _run << "-" << _subrun << "-" << _event << std::endl; + + // Get MCParticles + art::Handle> MCParticleHandle; + e.getByLabel(fMCParticleModuleLabel, MCParticleHandle); + if(!MCParticleHandle.isValid()){ + std::cout << "MCParticle product " << fMCParticleModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> MCParticleVec; + art::fill_ptr_vector(MCParticleVec, MCParticleHandle); + + // Fill MCParticle variables + AnalyseMCParticles(MCParticleVec); + + // Get SimDeposits + art::Handle> SimDepositHandle; + e.getByLabel(fSimDepositModuleLabel, SimDepositHandle); + if(!SimDepositHandle.isValid()){ + std::cout << "SimDeposit product " << fSimDepositModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> SimDepositVec; + art::fill_ptr_vector(SimDepositVec, SimDepositHandle); + + // Fill SimDeposit variables + AnalyseSimDeposits(SimDepositVec); + + // Get FEBDatas + art::Handle> FEBDataHandle; + e.getByLabel(fFEBDataModuleLabel, FEBDataHandle); + if(!FEBDataHandle.isValid()){ + std::cout << "FEBData product " << fFEBDataModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> FEBDataVec; + art::fill_ptr_vector(FEBDataVec, FEBDataHandle); + + // Fill FEBData variables + AnalyseFEBDatas(FEBDataVec); + + // Get CRTStripHits + art::Handle> CRTStripHitHandle; + e.getByLabel(fCRTStripHitModuleLabel, CRTStripHitHandle); + if(!CRTStripHitHandle.isValid()){ + std::cout << "CRTStripHit product " << fCRTStripHitModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> CRTStripHitVec; + art::fill_ptr_vector(CRTStripHitVec, CRTStripHitHandle); + + // Fill CRTStripHit variables + AnalyseCRTStripHits(e, CRTStripHitVec); + + // Get CRTClusters + art::Handle> CRTClusterHandle; + e.getByLabel(fCRTClusterModuleLabel, CRTClusterHandle); + if(!CRTClusterHandle.isValid()){ + std::cout << "CRTCluster product " << fCRTClusterModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> CRTClusterVec; + art::fill_ptr_vector(CRTClusterVec, CRTClusterHandle); + + // Get CRTSpacePoint to CRTCluster Assns + art::FindManyP clustersToSpacePoints(CRTClusterHandle, e, fCRTSpacePointModuleLabel); + + // Fill CRTCluster variables + AnalyseCRTClusters(e, CRTClusterVec, clustersToSpacePoints); + + // Get Map of TrueDeposits per tagger from BackTracker + std::map spacePointRecoStatusMap = fCRTBackTrackerAlg.GetSpacePointRecoStatusMap(); + + // Fill TrueDeposit variables + AnalyseTrueDepositsPerTagger(spacePointRecoStatusMap); + + // Get CRTTracks + art::Handle> CRTTrackHandle; + e.getByLabel(fCRTTrackModuleLabel, CRTTrackHandle); + if(!CRTTrackHandle.isValid()){ + std::cout << "CRTTrack product " << fCRTTrackModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + std::vector> CRTTrackVec; + art::fill_ptr_vector(CRTTrackVec, CRTTrackHandle); + + // Fill CRTTrack variables + AnalyseCRTTracks(e, CRTTrackVec); + + // Get Map of TrueDeposits from BackTracker + std::map> trackRecoStatusMap = fCRTBackTrackerAlg.GetTrackRecoStatusMap(); + + // Fill TrueDeposit variables + AnalyseTrueDeposits(trackRecoStatusMap); + + // Get TPC tracks + art::Handle> TPCTrackHandle; + e.getByLabel(fTPCTrackModuleLabel, TPCTrackHandle); + if(!TPCTrackHandle.isValid()){ + std::cout << "TPCTrack product " << fTPCTrackModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + + // Get CRTSpacePoints + art::Handle> CRTSpacePointHandle; + e.getByLabel(fCRTSpacePointModuleLabel, CRTSpacePointHandle); + if(!CRTSpacePointHandle.isValid()){ + std::cout << "CRTSpacePoint product " << fCRTSpacePointModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + + // Get PFPs + art::Handle> PFPHandle; + e.getByLabel(fPFPModuleLabel, PFPHandle); + if(!PFPHandle.isValid()){ + std::cout << "PFP product " << fPFPModuleLabel << " not found..." << std::endl; + throw std::exception(); + } + + // Fill TPC matching variables + AnalyseTPCMatching(e, TPCTrackHandle, CRTSpacePointHandle, PFPHandle, spacePointRecoStatusMap, trackRecoStatusMap); + + // Fill the Tree + fDAQNtuple->Fill(); + fHitNtuple->Fill(); + fTree->Fill(); +} + +void sbnd::crt::CRTCalibAna::AnalyseMCParticles(std::vector> &MCParticleVec) +{ + const unsigned nMCParticles = MCParticleVec.size(); + + _mc_trackid.resize(nMCParticles); + _mc_pdg.resize(nMCParticles); + _mc_status.resize(nMCParticles); + _mc_ndaughters.resize(nMCParticles); + _mc_daughters.resize(nMCParticles); + _mc_vx.resize(nMCParticles); + _mc_vy.resize(nMCParticles); + _mc_vz.resize(nMCParticles); + _mc_vt.resize(nMCParticles); + _mc_endx.resize(nMCParticles); + _mc_endy.resize(nMCParticles); + _mc_endz.resize(nMCParticles); + _mc_endt.resize(nMCParticles); + _mc_vpx.resize(nMCParticles); + _mc_vpy.resize(nMCParticles); + _mc_vpz.resize(nMCParticles); + _mc_ve.resize(nMCParticles); + _mc_endpx.resize(nMCParticles); + _mc_endpy.resize(nMCParticles); + _mc_endpz.resize(nMCParticles); + _mc_ende.resize(nMCParticles); + + for(unsigned i = 0; i < nMCParticles; ++i) + { + const auto mcp = MCParticleVec[i]; + + _mc_trackid[i] = mcp->TrackId(); + _mc_pdg[i] = mcp->PdgCode(); + _mc_status[i] = mcp->StatusCode(); + _mc_ndaughters[i] = mcp->NumberDaughters(); + _mc_vx[i] = mcp->Vx(); + _mc_vy[i] = mcp->Vy(); + _mc_vz[i] = mcp->Vz(); + _mc_vt[i] = mcp->T(); + _mc_endx[i] = mcp->EndX(); + _mc_endy[i] = mcp->EndY(); + _mc_endz[i] = mcp->EndZ(); + _mc_endt[i] = mcp->EndT(); + _mc_vpx[i] = mcp->Px(); + _mc_vpy[i] = mcp->Py(); + _mc_vpz[i] = mcp->Pz(); + _mc_ve[i] = mcp->E(); + _mc_endpx[i] = mcp->EndPx(); + _mc_endpy[i] = mcp->EndPy(); + _mc_endpz[i] = mcp->EndPz(); + _mc_ende[i] = mcp->EndE(); + + _mc_daughters[i].resize(_mc_ndaughters[i]); + + for(unsigned ii = 0; ii < _mc_ndaughters[i]; ++ii) + _mc_daughters[i][ii] = mcp->Daughter(ii); + } +} + +void sbnd::crt::CRTCalibAna::AnalyseSimDeposits(std::vector> &SimDepositVec) +{ + const unsigned nAuxDetSimChannels = SimDepositVec.size(); + unsigned nIDEs = 0; + + for(unsigned i = 0; i < nAuxDetSimChannels; ++i) + { + const auto auxDetSimChannel = SimDepositVec[i]; + nIDEs += auxDetSimChannel->AuxDetIDEs().size(); + } + + _ide_trackid.resize(nIDEs); + _ide_e.resize(nIDEs); + _ide_entryx.resize(nIDEs); + _ide_entryy.resize(nIDEs); + _ide_entryz.resize(nIDEs); + _ide_entryt.resize(nIDEs); + _ide_exitx.resize(nIDEs); + _ide_exity.resize(nIDEs); + _ide_exitz.resize(nIDEs); + _ide_exitt.resize(nIDEs); + + unsigned ide_counter = 0; + + for(unsigned i = 0; i < nAuxDetSimChannels; ++i) + { + const auto auxDetSimChannel = SimDepositVec[i]; + const auto ideVec = auxDetSimChannel->AuxDetIDEs(); + + for(unsigned ii = 0; ii < ideVec.size(); ++ii) + { + const auto ide = ideVec[ii]; + + _ide_trackid[ide_counter] = ide.trackID; + _ide_e[ide_counter] = ide.energyDeposited; + _ide_entryx[ide_counter] = ide.entryX; + _ide_entryy[ide_counter] = ide.entryY; + _ide_entryz[ide_counter] = ide.entryZ; + _ide_entryt[ide_counter] = ide.entryT; + _ide_exitx[ide_counter] = ide.exitX; + _ide_exity[ide_counter] = ide.exitY; + _ide_exitz[ide_counter] = ide.exitZ; + _ide_exitt[ide_counter] = ide.exitT; + + ++ide_counter; + } + } +} + +void sbnd::crt::CRTCalibAna::AnalyseFEBDatas(std::vector> &FEBDataVec) +{ + const unsigned nFEBData = FEBDataVec.size(); + + _feb_mac5.resize(nFEBData); + _feb_flags.resize(nFEBData); + _feb_ts0.resize(nFEBData); + _feb_ts1.resize(nFEBData); + _feb_unixs.resize(nFEBData); + _feb_adc.resize(nFEBData, std::vector(32)); + _feb_coinc.resize(nFEBData); + + _feb_NMaxCh = 32; + for(unsigned i = 0; i < nFEBData; ++i) + { + const auto data = FEBDataVec[i]; + + _feb_mac5[i] = data->Mac5(); + _feb_flags[i] = data->Flags(); + _feb_ts0[i] = data->Ts0(); + _feb_ts1[i] = data->Ts1(); + _feb_unixs[i] = data->UnixS(); + _feb_coinc[i] = data->Coinc(); + + for(unsigned j = 0; j < 32; ++j) + _feb_adc[i][j] = data->ADC(j); + } +} + +void sbnd::crt::CRTCalibAna::AnalyseCRTStripHits(const art::Event &e, const std::vector> &CRTStripHitVec) +{ + const unsigned nStripHits = CRTStripHitVec.size(); + + _sh_channel.resize(nStripHits); + _sh_ts0.resize(nStripHits); + _sh_ts1.resize(nStripHits); + _sh_unixs.resize(nStripHits); + _sh_pos.resize(nStripHits); + _sh_err.resize(nStripHits); + _sh_adc1.resize(nStripHits); + _sh_adc2.resize(nStripHits); + _sh_saturated1.resize(nStripHits); + _sh_saturated2.resize(nStripHits); + _sh_truth_trackid.resize(nStripHits); + _sh_truth_completeness.resize(nStripHits); + _sh_truth_purity.resize(nStripHits); + _sh_truth_pos.resize(nStripHits); + _sh_truth_energy.resize(nStripHits); + _sh_truth_time.resize(nStripHits); + + for(unsigned i = 0; i < nStripHits; ++i) + { + const auto hit = CRTStripHitVec[i]; + + _sh_channel[i] = hit->Channel(); + _sh_ts0[i] = hit->Ts0(); + _sh_ts1[i] = hit->Ts1(); + _sh_unixs[i] = hit->UnixS(); + _sh_pos[i] = hit->Pos(); + _sh_err[i] = hit->Error(); + _sh_adc1[i] = hit->ADC1(); + _sh_adc2[i] = hit->ADC2(); + _sh_saturated1[i] = hit->Saturated1(); + _sh_saturated2[i] = hit->Saturated2(); + + const CRTBackTrackerAlg::TruthMatchMetrics truthMatch = fCRTBackTrackerAlg.TruthMatching(e, hit); + const std::vector localpos = fCRTGeoAlg.StripWorldToLocalPos(hit->Channel(), truthMatch.deposit.x, truthMatch.deposit.y, truthMatch.deposit.z); + const double width = fCRTGeoAlg.GetStrip(hit->Channel()).width; + + _sh_truth_trackid[i] = truthMatch.trackid; + _sh_truth_completeness[i] = truthMatch.completeness; + _sh_truth_purity[i] = truthMatch.purity; + _sh_truth_pos[i] = localpos[1] + width / 2.; + _sh_truth_energy[i] = truthMatch.deposit.energy; + _sh_truth_time[i] = truthMatch.deposit.time; + } +} + +void sbnd::crt::CRTCalibAna::AnalyseCRTClusters(const art::Event &e, const std::vector> &CRTClusterVec, const art::FindManyP &clustersToSpacePoints) +{ + const unsigned nClusters = CRTClusterVec.size(); + + _cl_ts0.resize(nClusters); + _cl_ts1.resize(nClusters); + _cl_unixs.resize(nClusters); + _cl_nhits.resize(nClusters); + _cl_tagger.resize(nClusters); + _cl_composition.resize(nClusters); + _cl_truth_trackid.resize(nClusters); + _cl_truth_completeness.resize(nClusters); + _cl_truth_purity.resize(nClusters); + _cl_truth_hit_completeness.resize(nClusters); + _cl_truth_hit_purity.resize(nClusters); + _cl_truth_pdg.resize(nClusters); + _cl_truth_energy.resize(nClusters); + _cl_truth_time.resize(nClusters); + _cl_truth_x.resize(nClusters); + _cl_truth_y.resize(nClusters); + _cl_truth_z.resize(nClusters); + _cl_truth_core_energy.resize(nClusters); + _cl_truth_core_time.resize(nClusters); + _cl_truth_core_x.resize(nClusters); + _cl_truth_core_y.resize(nClusters); + _cl_truth_core_z.resize(nClusters); + _cl_has_sp.resize(nClusters); + _cl_sp_x.resize(nClusters); + _cl_sp_ex.resize(nClusters); + _cl_sp_y.resize(nClusters); + _cl_sp_ey.resize(nClusters); + _cl_sp_z.resize(nClusters); + _cl_sp_ez.resize(nClusters); + _cl_sp_pe.resize(nClusters); + _cl_sp_time.resize(nClusters); + _cl_sp_etime.resize(nClusters); + _cl_sp_complete.resize(nClusters); + + for(unsigned i = 0; i < nClusters; ++i) + { + const auto cluster = CRTClusterVec[i]; + + _cl_ts0[i] = cluster->Ts0(); + _cl_ts1[i] = cluster->Ts1(); + _cl_unixs[i] = cluster->UnixS(); + _cl_nhits[i] = cluster->NHits(); + _cl_tagger[i] = cluster->Tagger(); + _cl_composition[i] = cluster->Composition(); + + const CRTBackTrackerAlg::TruthMatchMetrics truthMatch = fCRTBackTrackerAlg.TruthMatching(e, cluster); + _cl_truth_trackid[i] = truthMatch.trackid; + _cl_truth_completeness[i] = truthMatch.completeness; + _cl_truth_purity[i] = truthMatch.purity; + _cl_truth_hit_completeness[i] = truthMatch.hitcompleteness; + _cl_truth_hit_purity[i] = truthMatch.hitpurity; + _cl_truth_pdg[i] = truthMatch.deposit.pdg; + _cl_truth_energy[i] = truthMatch.deposit.energy; + _cl_truth_time[i] = truthMatch.deposit.time; + _cl_truth_x[i] = truthMatch.deposit.x; + _cl_truth_y[i] = truthMatch.deposit.y; + _cl_truth_z[i] = truthMatch.deposit.z; + _cl_truth_core_energy[i] = truthMatch.deposit.coreEnergy; + _cl_truth_core_time[i] = truthMatch.deposit.coreTime; + _cl_truth_core_x[i] = truthMatch.deposit.coreX; + _cl_truth_core_y[i] = truthMatch.deposit.coreY; + _cl_truth_core_z[i] = truthMatch.deposit.coreZ; + + const auto spacepoints = clustersToSpacePoints.at(cluster.key()); + if(spacepoints.size() == 1) + { + const auto spacepoint = spacepoints[0]; + + _cl_has_sp[i] = true; + _cl_sp_x[i] = spacepoint->X(); + _cl_sp_ex[i] = spacepoint->XErr(); + _cl_sp_y[i] = spacepoint->Y(); + _cl_sp_ey[i] = spacepoint->YErr(); + _cl_sp_z[i] = spacepoint->Z(); + _cl_sp_ez[i] = spacepoint->ZErr(); + _cl_sp_pe[i] = spacepoint->PE(); + _cl_sp_time[i] = spacepoint->Time(); + _cl_sp_etime[i] = spacepoint->TimeErr(); + _cl_sp_complete[i] = spacepoint->Complete(); + } + else + { + _cl_has_sp[i] = false; + _cl_sp_x[i] = -999999.; + _cl_sp_ex[i] = -999999.; + _cl_sp_y[i] = -999999.; + _cl_sp_ey[i] = -999999.; + _cl_sp_z[i] = -999999.; + _cl_sp_ez[i] = -999999.; + _cl_sp_pe[i] = -999999.; + _cl_sp_time[i] = -999999.; + _cl_sp_etime[i] = -999999.; + _cl_sp_complete[i] = false; + } + } +} + +void sbnd::crt::CRTCalibAna::AnalyseTrueDepositsPerTagger(const std::map &recoStatusMap) +{ + const unsigned nTrueDeposits = recoStatusMap.size(); + + _td_tag_trackid.resize(nTrueDeposits); + _td_tag_pdg.resize(nTrueDeposits); + _td_tag_tagger.resize(nTrueDeposits); + _td_tag_energy.resize(nTrueDeposits); + _td_tag_time.resize(nTrueDeposits); + _td_tag_x.resize(nTrueDeposits); + _td_tag_y.resize(nTrueDeposits); + _td_tag_z.resize(nTrueDeposits); + _td_tag_reco_status.resize(nTrueDeposits); + + unsigned entry = 0; + for(auto const& [category, status] : recoStatusMap) + { + const CRTBackTrackerAlg::TrueDeposit deposit = fCRTBackTrackerAlg.GetTrueDeposit(category); + + _td_tag_trackid[entry] = deposit.trackid; + _td_tag_pdg[entry] = deposit.pdg; + _td_tag_tagger[entry] = deposit.tagger; + _td_tag_energy[entry] = deposit.energy; + _td_tag_time[entry] = deposit.time; + _td_tag_x[entry] = deposit.x; + _td_tag_y[entry] = deposit.y; + _td_tag_z[entry] = deposit.z; + _td_tag_reco_status[entry] = status; + + ++entry; + } +} + +void sbnd::crt::CRTCalibAna::AnalyseTrueDeposits(const std::map> &recoStatusMap) +{ + const unsigned nTrueDeposits = recoStatusMap.size(); + + _td_trackid.resize(nTrueDeposits); + _td_pdg.resize(nTrueDeposits); + _td_energy.resize(nTrueDeposits); + _td_time.resize(nTrueDeposits); + _td_reconstructable.resize(nTrueDeposits); + _td_reco_status.resize(nTrueDeposits); + _td_reco_triple.resize(nTrueDeposits); + + unsigned entry = 0; + for(auto const& [trackid, status] : recoStatusMap) + { + const CRTBackTrackerAlg::TrueDeposit deposit = fCRTBackTrackerAlg.GetTrueDeposit(trackid); + + _td_trackid[entry] = deposit.trackid; + _td_pdg[entry] = deposit.pdg; + _td_energy[entry] = deposit.energy; + _td_time[entry] = deposit.time; + _td_reconstructable[entry] = deposit.reconstructable; + _td_reco_status[entry] = status.first; + _td_reco_triple[entry] = status.second; + + ++entry; + } +} + +void sbnd::crt::CRTCalibAna::AnalyseCRTTracks(const art::Event &e, const std::vector> &CRTTrackVec) +{ + const unsigned nTracks = CRTTrackVec.size(); + + _tr_start_x.resize(nTracks); + _tr_start_y.resize(nTracks); + _tr_start_z.resize(nTracks); + _tr_end_x.resize(nTracks); + _tr_end_y.resize(nTracks); + _tr_end_z.resize(nTracks); + _tr_dir_x.resize(nTracks); + _tr_dir_y.resize(nTracks); + _tr_dir_z.resize(nTracks); + _tr_time.resize(nTracks); + _tr_etime.resize(nTracks); + _tr_pe.resize(nTracks); + _tr_length.resize(nTracks); + _tr_tof.resize(nTracks); + _tr_theta.resize(nTracks); + _tr_phi.resize(nTracks); + _tr_triple.resize(nTracks); + _tr_taggers.resize(nTracks); + _tr_truth_trackid.resize(nTracks); + _tr_truth_completeness.resize(nTracks); + _tr_truth_purity.resize(nTracks); + _tr_truth_pdg.resize(nTracks); + _tr_truth_energy.resize(nTracks); + _tr_truth_time.resize(nTracks); + _tr_truth_start_x.resize(nTracks); + _tr_truth_start_y.resize(nTracks); + _tr_truth_start_z.resize(nTracks); + _tr_truth_end_x.resize(nTracks); + _tr_truth_end_y.resize(nTracks); + _tr_truth_end_z.resize(nTracks); + _tr_truth_dir_x.resize(nTracks); + _tr_truth_dir_y.resize(nTracks); + _tr_truth_dir_z.resize(nTracks); + _tr_truth_particle_energy.resize(nTracks); + _tr_truth_length.resize(nTracks); + _tr_truth_tof.resize(nTracks); + _tr_truth_theta.resize(nTracks); + _tr_truth_phi.resize(nTracks); + + for(unsigned i = 0; i < nTracks; ++i) + { + const auto track = CRTTrackVec[i]; + + const geo::Point_t start = track->Start(); + _tr_start_x[i] = start.X(); + _tr_start_y[i] = start.Y(); + _tr_start_z[i] = start.Z(); + + const geo::Point_t end = track->End(); + _tr_end_x[i] = end.X(); + _tr_end_y[i] = end.Y(); + _tr_end_z[i] = end.Z(); + + const geo::Vector_t dir = track->Direction(); + _tr_dir_x[i] = dir.X(); + _tr_dir_y[i] = dir.Y(); + _tr_dir_z[i] = dir.Z(); + + _tr_time[i] = track->Time(); + _tr_etime[i] = track->TimeErr(); + _tr_pe[i] = track->PE(); + _tr_length[i] = track->Length(); + _tr_tof[i] = track->ToF(); + _tr_theta[i] = TMath::RadToDeg() * track->Theta(); + _tr_phi[i] = TMath::RadToDeg() * track->Phi(); + _tr_triple[i] = track->Triple(); + _tr_taggers[i] = track->Taggers(); + + const CRTBackTrackerAlg::TruthMatchMetrics truthMatch = fCRTBackTrackerAlg.TruthMatching(e, track); + _tr_truth_trackid[i] = truthMatch.trackid; + _tr_truth_completeness[i] = truthMatch.completeness; + _tr_truth_purity[i] = truthMatch.purity; + _tr_truth_pdg[i] = truthMatch.deposit.pdg; + _tr_truth_energy[i] = truthMatch.deposit.energy; + _tr_truth_time[i] = truthMatch.deposit.time; + + _tr_truth_particle_energy[i] = truthMatch.trackinfo.energy; + + const geo::Point_t true_start(truthMatch.trackinfo.deposit1.x, truthMatch.trackinfo.deposit1.y, truthMatch.trackinfo.deposit1.z); + const geo::Point_t true_end(truthMatch.trackinfo.deposit2.x, truthMatch.trackinfo.deposit2.y, truthMatch.trackinfo.deposit2.z); + const geo::Vector_t true_dir = (true_end - true_start).Unit(); + + _tr_truth_start_x[i] = true_start.X(); + _tr_truth_start_y[i] = true_start.Y(); + _tr_truth_start_z[i] = true_start.Z(); + + _tr_truth_end_x[i] = true_end.X(); + _tr_truth_end_y[i] = true_end.Y(); + _tr_truth_end_z[i] = true_end.Z(); + + _tr_truth_dir_x[i] = true_dir.X(); + _tr_truth_dir_y[i] = true_dir.Y(); + _tr_truth_dir_z[i] = true_dir.Z(); + + _tr_truth_length[i] = (true_end - true_start).R(); + _tr_truth_tof[i] = truthMatch.trackinfo.deposit2.time - truthMatch.trackinfo.deposit1.time; + _tr_truth_theta[i] = TMath::RadToDeg() * true_dir.Theta(); + _tr_truth_phi[i] = TMath::RadToDeg() * true_dir.Phi(); + } +} + +void sbnd::crt::CRTCalibAna::AnalyseTPCMatching(const art::Event &e, const art::Handle> &TPCTrackHandle, + const art::Handle> &CRTSpacePointHandle, const art::Handle> &PFPHandle, + const std::map &spacePointRecoStatusMap, const std::map> &trackRecoStatusMap) +{ + std::vector> TPCTrackVec; + art::fill_ptr_vector(TPCTrackVec, TPCTrackHandle); + + const unsigned nTracks = TPCTrackVec.size(); + + _tpc_start_x.resize(nTracks); + _tpc_start_y.resize(nTracks); + _tpc_start_z.resize(nTracks); + _tpc_end_x.resize(nTracks); + _tpc_end_y.resize(nTracks); + _tpc_end_z.resize(nTracks); + _tpc_dir_x.resize(nTracks); + _tpc_dir_y.resize(nTracks); + _tpc_dir_z.resize(nTracks); + _tpc_length.resize(nTracks); + _tpc_track_score.resize(nTracks); + _tpc_truth_trackid.resize(nTracks); + _tpc_truth_pdg.resize(nTracks); + _tpc_truth_energy.resize(nTracks); + _tpc_truth_time.resize(nTracks); + _tpc_sp_matchable.resize(nTracks); + _tpc_sp_matched.resize(nTracks); + _tpc_sp_good_match.resize(nTracks); + _tpc_sp_time.resize(nTracks); + _tpc_sp_score.resize(nTracks); + _tpc_tr_matchable.resize(nTracks); + _tpc_tr_matched.resize(nTracks); + _tpc_tr_good_match.resize(nTracks); + _tpc_tr_time.resize(nTracks); + _tpc_tr_score.resize(nTracks); + + art::FindOneP tracksToPFPs(TPCTrackHandle, e, fTPCTrackModuleLabel); + art::FindOneP pfpsToMetadata(PFPHandle, e, fPFPModuleLabel); + art::FindManyP tracksToHits(TPCTrackHandle, e, fTPCTrackModuleLabel); + art::FindOneP tracksToSPMatches(TPCTrackHandle, e, fCRTSpacePointMatchingModuleLabel); + art::FindOneP spsToClusters(CRTSpacePointHandle, e, fCRTSpacePointModuleLabel); + art::FindOneP tracksToTrackMatches(TPCTrackHandle, e, fCRTTrackMatchingModuleLabel); + + const detinfo::DetectorClocksData clockData = art::ServiceHandle()->DataFor(e); + int nActualTracks = 0; + + for(unsigned i = 0; i < nTracks; ++i) + { + const auto track = TPCTrackVec[i]; + const auto pfp = tracksToPFPs.at(track.key()); + const auto meta = pfpsToMetadata.at(pfp.key()); + const auto props = meta->GetPropertiesMap(); + + if(pfp->PdgCode() != 13) + continue; + + const geo::Point_t start = track->Start(); + _tpc_start_x[nActualTracks] = start.X(); + _tpc_start_y[nActualTracks] = start.Y(); + _tpc_start_z[nActualTracks] = start.Z(); + + const geo::Point_t end = track->End(); + _tpc_end_x[nActualTracks] = end.X(); + _tpc_end_y[nActualTracks] = end.Y(); + _tpc_end_z[nActualTracks] = end.Z(); + + const geo::Vector_t dir = track->StartDirection(); + _tpc_dir_x[nActualTracks] = dir.X(); + _tpc_dir_y[nActualTracks] = dir.Y(); + _tpc_dir_z[nActualTracks] = dir.Z(); + + _tpc_length[nActualTracks] = track->Length(); + + const auto trackscore = props.find("TrackScore"); + if(trackscore != props.end()) + _tpc_track_score[nActualTracks] = trackscore->second; + else + _tpc_track_score[nActualTracks] = -std::numeric_limits::max(); + + const std::vector> trackHits = tracksToHits.at(track.key()); + const int trackid = fCRTBackTrackerAlg.RollUpID(TruthMatchUtils::TrueParticleIDFromTotalRecoHits(clockData,trackHits,true)); + + _tpc_truth_trackid[nActualTracks] = trackid; + + int pdg; + double energy, time; + fCRTBackTrackerAlg.TrueParticlePDGEnergyTime(trackid, pdg, energy, time); + + _tpc_truth_pdg[nActualTracks] = pdg; + _tpc_truth_energy[nActualTracks] = energy; + _tpc_truth_time[nActualTracks] = time; + + bool sp_matchable = false, tr_matchable = false; + + for(auto const& [ category, status ] : spacePointRecoStatusMap) + sp_matchable |= (category.trackid == trackid && status); + + tr_matchable |= trackRecoStatusMap.count(trackid) != 0; + if(tr_matchable) tr_matchable = trackRecoStatusMap.at(trackid).first; + + _tpc_sp_matchable[nActualTracks] = sp_matchable; + _tpc_tr_matchable[nActualTracks] = tr_matchable; + + const art::Ptr spacepoint = tracksToSPMatches.at(track.key()); + + if(spacepoint.isNonnull()) + { + const anab::T0 spMatch = tracksToSPMatches.data(track.key()).ref(); + const art::Ptr cluster = spsToClusters.at(spacepoint.key()); + const CRTBackTrackerAlg::TruthMatchMetrics truthMatch = fCRTBackTrackerAlg.TruthMatching(e, cluster); + + _tpc_sp_matched[nActualTracks] = true; + _tpc_sp_good_match[nActualTracks] = truthMatch.trackid == trackid; + _tpc_sp_time[nActualTracks] = spacepoint->Time(); + _tpc_sp_score[nActualTracks] = spMatch.TriggerConfidence(); + } + else + { + _tpc_sp_matched[nActualTracks] = false; + _tpc_sp_good_match[nActualTracks] = false; + _tpc_sp_time[nActualTracks] = -std::numeric_limits::max(); + _tpc_sp_score[nActualTracks] = -std::numeric_limits::max(); + } + + const art::Ptr crttrack = tracksToTrackMatches.at(track.key()); + + if(crttrack.isNonnull()) + { + const anab::T0 trackMatch = tracksToTrackMatches.data(track.key()).ref(); + const CRTBackTrackerAlg::TruthMatchMetrics truthMatch = fCRTBackTrackerAlg.TruthMatching(e, crttrack); + + _tpc_tr_matched[nActualTracks] = true; + _tpc_tr_good_match[nActualTracks] = truthMatch.trackid == trackid; + _tpc_tr_time[nActualTracks] = crttrack->Time(); + _tpc_tr_score[nActualTracks] = trackMatch.TriggerConfidence(); + } + else + { + _tpc_tr_matched[nActualTracks] = false; + _tpc_tr_good_match[nActualTracks] = false; + _tpc_tr_time[nActualTracks] = -std::numeric_limits::max(); + _tpc_tr_score[nActualTracks] = -std::numeric_limits::max(); + } + + ++nActualTracks; + } + + _tpc_start_x.resize(nActualTracks); + _tpc_start_y.resize(nActualTracks); + _tpc_start_z.resize(nActualTracks); + _tpc_end_x.resize(nActualTracks); + _tpc_end_y.resize(nActualTracks); + _tpc_end_z.resize(nActualTracks); + _tpc_dir_x.resize(nActualTracks); + _tpc_dir_y.resize(nActualTracks); + _tpc_dir_z.resize(nActualTracks); + _tpc_length.resize(nActualTracks); + _tpc_track_score.resize(nActualTracks); + _tpc_truth_trackid.resize(nActualTracks); + _tpc_truth_pdg.resize(nActualTracks); + _tpc_truth_energy.resize(nActualTracks); + _tpc_truth_time.resize(nActualTracks); + _tpc_sp_matchable.resize(nActualTracks); + _tpc_sp_matched.resize(nActualTracks); + _tpc_sp_good_match.resize(nActualTracks); + _tpc_sp_time.resize(nActualTracks); + _tpc_sp_score.resize(nActualTracks); + _tpc_tr_matchable.resize(nActualTracks); + _tpc_tr_matched.resize(nActualTracks); + _tpc_tr_good_match.resize(nActualTracks); + _tpc_tr_time.resize(nActualTracks); + _tpc_tr_score.resize(nActualTracks); +} + +DEFINE_ART_MODULE(sbnd::crt::CRTCalibAna) diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index c02b370e5..62b10adab 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -8,17 +8,41 @@ # # job configuration +#include "simulationservices_sbnd.fcl" +#include "crtbacktrackeralg_sbnd.fcl" #include "reco_sbnd.fcl" process_name: Reco2 +services.ParticleInventoryService: @local::sbnd_particleinventoryservice +services.BackTrackerService: @local::sbnd_backtrackerservice +services.DetectorClocksService: @local::sbnd_detectorclocks + physics.reco2_sce: [@sequence::physics.reco2, pandoraSCE, pandoraSCETrack, pandoraSCEShower, pandoraSCEShowerSBN, pandoraSCECalo, pandoraSCEPid, crtspacepointmatchingSCE, crttrackmatchingSCE, fmatchSCE, fmatchopSCE, fmatcharaSCE, fmatchoparaSCE, opt0finderSCE] physics.trigger_paths: [ reco2_sce ] -physics.end_paths: [stream1, caloskimana] +physics.analyzers.crtskim: { + module_type: "CRTCalibAna" + CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd +} +physics.crtskimana: [ "crtskim" ] + +physics.analyzers.pmtskim: { + module_type: "SBNDFlashAssAna" + TriggerLabel: "generator" + DumpWaveformsInfo: false + OpDetWaveformLabels: ["opdecopmt", "opdecoxarapuca"] + OpHitLabels: ["ophitpmt", "ophitxarapuca"] + FlashLabels: ["opflashtpc0", "opflashtpc1", "opflashtpc0xarapuca", "opflashtpc1xarapuca"] + PEOpHitThreshold: 0 + Debug: false +} +physics.pmtskimana: [ "pmtskim" ] + +physics.end_paths: [stream1, caloskimana, crtskimana, pmtskimana] # turn on space charge service #include "enable_spacecharge_services_sbnd.fcl" diff --git a/sbndcode/PDS/CMakeLists.txt b/sbndcode/PDS/CMakeLists.txt new file mode 100644 index 000000000..982c5e99c --- /dev/null +++ b/sbndcode/PDS/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(OpReco) diff --git a/sbndcode/PDS/OpReco/CMakeLists.txt b/sbndcode/PDS/OpReco/CMakeLists.txt new file mode 100644 index 000000000..d2265d92d --- /dev/null +++ b/sbndcode/PDS/OpReco/CMakeLists.txt @@ -0,0 +1,38 @@ +set( MODULE_LIBRARIES + sbnobj::Common_Trigger + larcorealg::Geometry + larcore::Geometry_Geometry_service + lardataobj::RecoBase + lardataobj::Simulation + larcoreobj::SummaryData + larana::OpticalDetector_OpHitFinder + larreco::Calorimetry + lardata::Utilities + nusimdata::SimulationBase + nurandom::RandomUtils_NuRandomService_service + larsim::PhotonPropagation_PhotonVisibilityService_service + art::Framework_Core + art::Framework_Principal + art::Framework_Services_Registry + art_root_io::tfile_support + art_root_io::TFileService_service + art::Persistency_Common + art::Persistency_Provenance + art::Utilities + canvas::canvas + messagefacility::MF_MessageLogger + messagefacility::headers + fhiclcpp::fhiclcpp + cetlib::cetlib + CLHEP::Random + ROOT::Geom + ROOT::XMLIO + ROOT::Gdml + ROOT::FFTW + ROOT::Core + ROOT::Tree +) +cet_build_plugin(SBNDFlashAssAna art::module LIBRARIES ${MODULE_LIBRARIES}) + +install_headers() +install_source() diff --git a/sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc b/sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc new file mode 100644 index 000000000..46d0f690d --- /dev/null +++ b/sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc @@ -0,0 +1,760 @@ +//////////////////////////////////////////////////////////////////////// +// Class: SBNDFlashAssAna +// Plugin Type: analyzer (art v09_75_03_02) +// File: SBNDFlashAssAna_module.cc +// +// Copied ICARUSFlashAssAna_module.cc from icaruscode to sbndcode (mailto:ascarpel@bnl.gov) +// +// Module that dumps the association between Flashes and OpHit +// +// mailto:sungbino@fnal.gov +//////////////////////////////////////////////////////////////////////// + +#include "art/Framework/Core/EDAnalyzer.h" +#include "art/Framework/Core/ModuleMacros.h" +#include "art/Framework/Principal/Event.h" +#include "art/Framework/Principal/Handle.h" +#include "art/Framework/Principal/Run.h" +#include "art/Framework/Principal/SubRun.h" +#include "canvas/Utilities/InputTag.h" +#include "fhiclcpp/ParameterSet.h" +#include "fhiclcpp/types/Atom.h" +#include "fhiclcpp/types/Sequence.h" + +#include "art_root_io/TFileService.h" + +#include "messagefacility/MessageLogger/MessageLogger.h" + +#include "canvas/Persistency/Common/FindMany.h" +#include "canvas/Persistency/Common/FindOne.h" +#include "canvas/Persistency/Common/FindManyP.h" +#include "canvas/Persistency/Common/FindOneP.h" +#include "canvas/Persistency/Common/Assns.h" + +#include "larcore/Geometry/Geometry.h" +#include "larcore/CoreUtils/ServiceUtil.h" // lar::providerFrom() +#include "lardataobj/RawData/OpDetWaveform.h" +#include "lardataobj/RecoBase/OpHit.h" +#include "lardataobj/RecoBase/OpFlash.h" +#include "lardataobj/Simulation/BeamGateInfo.h" +#include "lardataobj/RawData/TriggerData.h" +#include "sbnobj/Common/Trigger/ExtraTriggerInfo.h" + +#include "TTree.h" + +#include +#include +#include // std::accumulate + + + +namespace opana { + class SBNDFlashAssAna; +} + + +class opana::SBNDFlashAssAna : public art::EDAnalyzer { + + public: + + struct Config { + + using Name = fhicl::Name; + using Comment = fhicl::Comment; + + fhicl::Atom TriggerLabel { + Name("TriggerLabel"), + Comment("Label for the Trigger fragment label") + }; + + fhicl::Atom DumpWaveformsInfo { + Name("DumpWaveformsInfo"), + Comment("Set the option to save some aggregated waveform information") + }; + + fhicl::Sequence OpDetWaveformLabels { + Name("OpDetWaveformLabels"), + Comment("Tags for the raw::OpDetWaveform data products") + }; + + fhicl::Sequence OpHitLabels { + Name("OpHitLabels"), + Comment("Tags for the recob::OpHit data products") + }; + + fhicl::Sequence FlashLabels { + Name("FlashLabels"), + Comment("Tags for the recob::Flashe data products") + }; + + fhicl::Atom PEOpHitThreshold { + Name("PEOpHitThreshold"), + Comment("Threshold in PE for an OpHit to be considered in the information calculated for a flash") + }; + + fhicl::Atom Debug { + Name("Debug"), + Comment("Be more verbose"), + false + }; + + }; + + using Parameters = art::EDAnalyzer::Table; + + explicit SBNDFlashAssAna(Parameters const& config); + + SBNDFlashAssAna(SBNDFlashAssAna const&) = delete; + SBNDFlashAssAna(SBNDFlashAssAna&&) = delete; + SBNDFlashAssAna& operator=(SBNDFlashAssAna const&) = delete; + SBNDFlashAssAna& operator=(SBNDFlashAssAna&&) = delete; + + void analyze(art::Event const& e) override; + + void beginJob() override; + void endJob() override; + + template T Median( std::vector data ) const; + + geo::CryostatID::CryostatID_t getCryostatByChannel( int channel ); + + int getSideByChannel( const int channel ); + + void processOpHits( art::Event const& e, unsigned int cryo ); + + void processOpHitsFlash( std::vector> const &ophits, + int &multiplicity_left, int &multiplicity_right, + float &sum_pe_left, float &sum_pe_right, + float *xyz, + std::vector &pmt_start_time, + std::vector &pmt_pe, + std::vector &pmt_max_amplitude, + TTree *ophittree ); + + static std::string_view firstLine(std::string const& s, const char* endl = "\r"); + + private: + + art::InputTag fTriggerLabel; + bool fSaveWaveformInfo; + std::vector fOpDetWaveformLabels; + std::vector fOpHitLabels; + std::vector fFlashLabels; + float fPEOpHitThreshold; + bool fDebug; + + + TTree *fEventTree; + std::vector fOpDetWaveformTrees; + std::vector fOpFlashTrees; + std::vector fOpHitTrees; + std::vector fOpHitFlashTrees; + + int m_run; + int m_event; + int m_timestamp; + //int m_nflashes; + //int m_nophit; + short m_baseline; + short m_chargesum; + int m_nticks; + float m_beam_gate_start=-99999; + float m_beam_gate_width=-99999; + int m_beam_type=-1; + int m_trigger_type=-1; + unsigned int m_gate_type; + std::string m_gate_name; + uint64_t m_trigger_timestamp; + uint64_t m_gate_start_timestamp; + uint64_t m_trigger_gate_diff; + uint64_t lvdsCryoE[2]; + uint64_t lvdsCryoW[2]; + + int m_flash_id; + int m_multiplicity; + int m_multiplicity_left; + int m_multiplicity_right; + float m_sum_pe; + float m_sum_pe_left; + float m_sum_pe_right; + float m_flash_time; + //float m_flash_x; + //float m_flash_width_x; + float m_flash_y; + float m_flash_width_y; + float m_flash_z; + float m_flash_width_z; + std::vector m_pmt_time; + std::vector m_pmt_pe; + std::vector m_pmt_max_amplitude; + + int m_channel_id; + float m_integral; // in ADC x tick + float m_amplitude; // in ADC + float m_start_time; + float m_peak_time; + float m_rise_time; + float m_width; + float m_abs_start_time; + float m_pe; + float m_fast_to_total; + + std::vector m_pmt_x; + std::vector m_pmt_y; + std::vector m_pmt_z; + + geo::GeometryCore const* fGeom; + +}; + + +opana::SBNDFlashAssAna::SBNDFlashAssAna(Parameters const& config) + : EDAnalyzer(config) + , fTriggerLabel( config().TriggerLabel() ) + , fSaveWaveformInfo( config().DumpWaveformsInfo() ) + , fOpDetWaveformLabels( config().OpDetWaveformLabels() ) + , fOpHitLabels( config().OpHitLabels() ) + , fFlashLabels( config().FlashLabels() ) + , fPEOpHitThreshold( config().PEOpHitThreshold() ) + , fDebug( config().Debug() ) + , fGeom( lar::providerFrom() ) +{ } + + +void opana::SBNDFlashAssAna::beginJob() { + + art::ServiceHandle tfs; + + TTree* fGeoTree = tfs->make("geotree", "geometry information" ); + fGeoTree->Branch("pmt_x",&m_pmt_x); + fGeoTree->Branch("pmt_y",&m_pmt_y); + fGeoTree->Branch("pmt_z",&m_pmt_z); + + for(size_t opch=0; opchNOpChannels(); ++opch) { + + auto const PDSxyz = fGeom->OpDetGeoFromOpChannel(opch).GetCenter(); + + //std::cout << PDSxyz[0] << " " << PDSxyz[1] << " " << PDSxyz[2] << std::endl; + + m_pmt_x.push_back(PDSxyz.X()); + m_pmt_y.push_back(PDSxyz.Y()); + m_pmt_z.push_back(PDSxyz.Z()); + + } + + fGeoTree->Fill(); + + fEventTree = tfs->make("eventstree", "higher level information on the event" ); + fEventTree->Branch("run", &m_run, "run/I"); + fEventTree->Branch("event", &m_event, "event/I"); + fEventTree->Branch("timestamp", &m_timestamp, "timestamp/I"); + //fEventTree->Branch("nflashes", &m_nflashes, "nflashes/I"); + //fEventTree->Branch("nophits", &m_nophit, "nophits/I"); + fEventTree->Branch("beam_gate_start", &m_beam_gate_start, "beam_gate_start/F"); + fEventTree->Branch("beam_gate_width", &m_beam_gate_width, "beam_gate_width/F"); + fEventTree->Branch("beam_type", &m_beam_type, "beam_type/I"); + fEventTree->Branch("gate_type", &m_gate_type, "gate_type/b"); + fEventTree->Branch("gate_name", &m_gate_name); + fEventTree->Branch("trigger_type", &m_trigger_type, "trigger_type/I"); + fEventTree->Branch("trigger_timestamp", &m_trigger_timestamp, "trigger_timestamp/l"); + fEventTree->Branch("gate_start_timestamp", &m_gate_start_timestamp, "gate_start_timestamp/l"); + fEventTree->Branch("trigger_gate_diff", &m_trigger_gate_diff, "trigger_gate_diff/l"); + fEventTree->Branch("lvdsCryoE", &lvdsCryoE, "lvdsCryoE[2]/l"); + fEventTree->Branch("lvdsCryoW", &lvdsCryoW, "lvdsCryoW[2]/l"); + + // This tree will hold some aggregated optical waveform information + // The flag must be enabled to have the information saved + if( !fOpDetWaveformLabels.empty() && fSaveWaveformInfo ) { + + for( auto const & label : fOpDetWaveformLabels ) { + + std::string name = label.label()+"wfttree"; + std::string info = "TTree with aggregated optical waveform information with label: " + label.label(); + + TTree* ttree = tfs->make(name.c_str(), info.c_str()); + ttree->Branch("run", &m_run, "run/I"); + ttree->Branch("event", &m_event, "event/I"); + ttree->Branch("timestamp", &m_timestamp, "timestamp/I"); + ttree->Branch("channel_id", &m_channel_id, "channel_id/I"); + ttree->Branch("baseline", &m_baseline, "baseline/s"); + ttree->Branch("chargesum", &m_chargesum, "chargesum/s"); + ttree->Branch("nticks", &m_nticks, "nticks/I"); + + fOpDetWaveformTrees.push_back(ttree); + + } + + } + + + // This ttree will hold the ophit information when a flash is not found in the event + // NB: information of the optical hits in events where flashes are present are lost + + for( auto const & label : fOpHitLabels ) { + + std::string name = label.label()+"_ttree"; + std::string info = "TTree for the recob::OpHit objects with label " + label.label() + " in events without flashes."; + + TTree* ttree = tfs->make(name.c_str(), info.c_str()); + ttree->Branch("run", &m_run, "run/I"); + ttree->Branch("event", &m_event, "event/I"); + ttree->Branch("timestamp", &m_timestamp, "timestamp/I"); + ttree->Branch("channel_id", &m_channel_id, "channel_id/I"); + ttree->Branch("integral", &m_integral, "integral/F"); + ttree->Branch("amplitude", &m_amplitude, "amplitude/F"); + ttree->Branch("start_time", &m_start_time, "start_time/F"); + ttree->Branch("peak_time", &m_peak_time, "peak_time/F"); + ttree->Branch("rise_time", &m_rise_time, "rise_time/F"); + ttree->Branch("abs_start_time", &m_abs_start_time, "abs_start_time/F"); + ttree->Branch("pe", &m_pe, "pe/F"); + ttree->Branch("width", &m_width, "width/F"); + ttree->Branch("fast_to_total", &m_fast_to_total, "fast_to_total/F"); + + fOpHitTrees.push_back(ttree); + + } + + + if ( !fFlashLabels.empty() ) { + + for( auto const & label : fFlashLabels ) { + + // TTree for the flash in a given cryostat + std::string name = label.label()+"_flashtree"; + std::string info = "TTree for the recob::Flashes with label "+label.label(); + + TTree* ttree = tfs->make(name.c_str(), info.c_str() ); + ttree->Branch("run", &m_run, "run/I"); + ttree->Branch("event", &m_event, "event/I"); + ttree->Branch("timestamp", &m_timestamp, "timestamp/I"); + ttree->Branch("flash_id", &m_flash_id, "flash_id/I"); + ttree->Branch("multiplicity", &m_multiplicity, "multiplicity/I"); + ttree->Branch("multiplicity_right", &m_multiplicity_right, "multiplicity_right/I" ); + ttree->Branch("multiplicity_left", &m_multiplicity_left, "multiplicity_left/I" ); + ttree->Branch("sum_pe", &m_sum_pe, "sum_pe/F"); + ttree->Branch("sum_pe_right", &m_sum_pe_right, "sum_pe_right/F"); + ttree->Branch("sum_pe_left", &m_sum_pe_left, "sum_pe_left/F"); + ttree->Branch("flash_time", &m_flash_time, "flash_time/F"); + //ttree->Branch("flash_x", &m_flash_x, "flash_x/F"); + //ttree->Branch("flash_width_x", &m_flash_width_x, "flash_width_x/F"); + ttree->Branch("flash_y", &m_flash_y, "flash_y/F"); + ttree->Branch("flash_width_y", &m_flash_width_y, "flash_width_y/F"); + ttree->Branch("flash_z", &m_flash_z, "flash_z/F"); + ttree->Branch("flash_width_z", &m_flash_width_z, "flash_width_z/F"); + ttree->Branch("pmt_x",&m_pmt_x); + ttree->Branch("pmt_y",&m_pmt_y); + ttree->Branch("pmt_z",&m_pmt_z); + ttree->Branch("time_pmt", & m_pmt_time); + ttree->Branch("pe_pmt", & m_pmt_pe ); + ttree->Branch("amplitude_pmt", &m_pmt_max_amplitude); + + fOpFlashTrees.push_back( ttree ); + + // Now the ttree for the OpHit associated in the flash + name = label.label()+"_ophittree"; + info = "Three for the recob::OpHit associated with an OpHitFlash"+label.label(); + + TTree* ophittree = tfs->make(name.c_str(), info.c_str() ); + ophittree->Branch("run", &m_run, "run/I"); + ophittree->Branch("event", &m_event, "event/I"); + ophittree->Branch("timestamp", &m_timestamp, "timestamp/I"); + ophittree->Branch("flash_id", &m_flash_id, "flash_id/I"); + ophittree->Branch("channel_id", &m_channel_id, "channel_id/I"); + ophittree->Branch("integral", &m_integral, "integral/F"); + ophittree->Branch("amplitude", &m_amplitude, "amplitude/F"); + ophittree->Branch("start_time", &m_start_time, "start_time/F"); + ophittree->Branch("peak_time", &m_peak_time, "peak_time/F"); + ophittree->Branch("rise_time", &m_rise_time, "rise_time/F"); + ophittree->Branch("abs_start_time", &m_abs_start_time, "abs_start_time/F"); + ophittree->Branch("pe", &m_pe, "pe/F"); + ophittree->Branch("width", &m_width, "width/F"); + ophittree->Branch("fast_to_total", &m_fast_to_total, "fast_to_total/F"); + + fOpHitFlashTrees.push_back( ophittree ); + + } + } + +} + + + +template + T opana::SBNDFlashAssAna::Median( std::vector data ) const { + + std::nth_element( data.begin(), data.begin() + data.size()/2, data.end() ); + + return data[ data.size()/2 ]; + +} + + +geo::CryostatID::CryostatID_t opana::SBNDFlashAssAna::getCryostatByChannel( int channel ) { + + + const geo::OpDetGeo& opdetgeo = fGeom->OpDetGeoFromOpChannel(channel); + geo::CryostatID::CryostatID_t cid = opdetgeo.ID().Cryostat ; + + return cid; + +} + + +int opana::SBNDFlashAssAna::getSideByChannel( const int channel ) { + + /* + Channels are numbered from east to west, from North (cryo side) to South (beam side) + We look in the opposide direction wrt to the beam direction South->North: + + - Left is the east wall of each cryostat; + + - Right is the west side of each cryostat; + + - [ 0:89 ] and [180:269] are on the left, + the return value of the function is 0; + + - [ 90-179 ] and [ 270:359 ] are on the right, + the return value of the function is 1; + */ + + + int side = channel / 90; // always round down + + return side % 2; +} + + +void opana::SBNDFlashAssAna::processOpHits( art::Event const& e, unsigned int cryo ) { + + + if( fOpHitLabels.empty() ){ + + mf::LogError("SBNDFlashAssAna") << "No recob::OpHit labels selected."; + + return; + } + + for( size_t iOpHitLabel=0; iOpHitLabel> ophit_handle; + e.getByLabel( label, ophit_handle ); + + + // We want our flashes to be valid and not empty + if( !ophit_handle.isValid() || ophit_handle->empty() ) { + mf::LogError("SBNDFlashAssAna") + << "Invalid recob::OpHit with label '" << label.encode() << "'"; + continue; + } + + + for( auto const & ophit : *ophit_handle ) { + + //auto const & ophit = (*ophit_handle)[idx]; + + const int channel_id = ophit.OpChannel(); + + if( getCryostatByChannel(channel_id) != cryo ){ continue; } + + m_channel_id = channel_id; + m_integral = ophit.Area(); // in ADC x tick + m_amplitude = ophit.Amplitude(); // in ADC + m_start_time = ophit.StartTime(); + m_peak_time = ophit.PeakTime(); + m_rise_time = ophit.RiseTime(); + m_width = ophit.Width(); + m_abs_start_time = ophit.PeakTimeAbs() + (m_start_time - m_peak_time); + m_pe = ophit.PE(); + m_fast_to_total = ophit.FastToTotal(); + + fOpHitTrees[iOpHitLabel]->Fill(); + + } + } + + return; + +} + + +void opana::SBNDFlashAssAna::processOpHitsFlash( std::vector> const &ophits, + int &multiplicity_left, int &multiplicity_right, + float &sum_pe_left, float &sum_pe_right, + float *xyz, + std::vector &pmt_start_time, + std::vector &pmt_pe, + std::vector &pmt_max_amplitude, + TTree *ophittree ) { + + + std::unordered_map sumpe_map; + + // We caluclate the total charge clustered in the flash per channel taking part to the flash + for( auto const ophit : ophits ) { + + if ( ophit->PE() < fPEOpHitThreshold ) { continue; } + + const int channel_id = ophit->OpChannel(); + + sumpe_map[ channel_id ]+=ophit->PE() ; + + m_channel_id = channel_id; + m_integral = ophit->Area(); // in ADC x tick + m_amplitude = ophit->Amplitude(); // in ADC + m_start_time = ophit->StartTime(); + m_peak_time = ophit->PeakTime(); + m_rise_time = ophit->RiseTime(); + m_width = ophit->Width(); + m_abs_start_time = ophit->PeakTimeAbs() + (m_start_time - m_peak_time); + m_pe = ophit->PE(); + m_fast_to_total = ophit->FastToTotal(); + + pmt_pe[channel_id] += ophit->PE(); + + if( ( pmt_start_time[channel_id] == 0 ) || ( pmt_start_time[channel_id] > m_start_time )) { + pmt_start_time[channel_id] = m_start_time; + pmt_max_amplitude[channel_id] = m_amplitude; + } + + + ophittree->Fill(); + + } + + m_multiplicity_left = std::accumulate( sumpe_map.begin(), sumpe_map.end(), 0, + [&](int value, const std::map::value_type& p) { + return getSideByChannel(p.first)==0 ? ++value : value ; + }); + + m_multiplicity_right =std::accumulate( sumpe_map.begin(), sumpe_map.end(), 0, + [&](int value, const std::map::value_type& p) { + return getSideByChannel(p.first)==1 ? ++value : value ; + }); + + m_sum_pe_left = std::accumulate( sumpe_map.begin(), sumpe_map.end(), 0.0, + [&](float value, const std::map::value_type& p) { + return getSideByChannel(p.first)==0 ? value+p.second : value ; + }); + + m_sum_pe_right = std::accumulate( sumpe_map.begin(), sumpe_map.end(), 0.0, + [&](float value, const std::map::value_type& p) { + return getSideByChannel(p.first)==1 ? value+p.second : value ; + }); + + //for( int i=0; i<3; i++ ){ xyz[i] /= (m_sum_pe_left+ m_sum_pe_right); } + +} + + +void opana::SBNDFlashAssAna::endJob() { + +} + + +void opana::SBNDFlashAssAna::analyze(art::Event const& e) { + + + m_run = e.id().run(); + m_event = e.id().event(); + m_timestamp = e.time().timeHigh(); // precision to the second + + + /* + This part is for the trigger information + */ + + + // We work out the trigger information here + if( !fTriggerLabel.empty() ) { + + // Beam information + art::Handle> beamgate_handle; + e.getByLabel( fTriggerLabel, beamgate_handle ); + + if( beamgate_handle.isValid() ) { + + for( auto const & beamgate : *beamgate_handle ) { + + m_beam_gate_start = beamgate.Start(); + m_beam_gate_width = beamgate.Width(); + m_beam_type = beamgate.BeamType() ; + + } + + } + + else { + mf::LogError("SBNDFlashAssAna") << "No sim::BeamGateInfo associated to label: " << fTriggerLabel.label() << "\n" ; + } + + // Now trigger information + art::Handle trigger_handle; + e.getByLabel( fTriggerLabel, trigger_handle ); + + if( trigger_handle.isValid() ) { + + sbn::triggerSource bit = trigger_handle->sourceType; + + m_gate_type = (unsigned int)bit; + m_gate_name = bitName(bit); + m_trigger_type = value( trigger_handle->triggerType ); + m_trigger_timestamp = trigger_handle->triggerTimestamp; + m_gate_start_timestamp = trigger_handle->beamGateTimestamp; + m_trigger_gate_diff = trigger_handle->triggerTimestamp - trigger_handle->beamGateTimestamp; + lvdsCryoE[0] = trigger_handle->cryostats[0].LVDSstatus[0]; + lvdsCryoE[1] = trigger_handle->cryostats[0].LVDSstatus[1]; + lvdsCryoW[0] = trigger_handle->cryostats[1].LVDSstatus[0]; + lvdsCryoW[1] = trigger_handle->cryostats[1].LVDSstatus[1]; + + } + else{ + mf::LogError("SBNDFlashAssAna") << "No raw::Trigger associated to label: " << fTriggerLabel.label() << "\n" ; + } + + } + + else { + mf::LogError("SBNDFlashAssAna") << "Trigger Data product " << fTriggerLabel.label() << " not found!\n" ; + } + + + /* + Now we work on the waveforms if we are allowed to + */ + + if( !fOpDetWaveformLabels.empty() && fSaveWaveformInfo ) { + + for( size_t i=0; i> wfm_handle; + e.getByLabel( label, wfm_handle ); + + if( wfm_handle.isValid() && !wfm_handle->empty() ) { + + for( auto const & wave : *wfm_handle ){ + + m_channel_id = wave.ChannelNumber(); + m_nticks = wave.Waveform().size(); + m_baseline = Median( wave.Waveform() ); + m_chargesum = std::accumulate( wave.Waveform().begin(), wave.Waveform().end(), 0, + [ & ](short x, short y){ return ((m_baseline-x) + (m_baseline-y)) ; } ); + + fOpDetWaveformTrees[i]->Fill(); + + } + } + } + } + + + /* + Now we take care of the flashes: we separate the case where we have a flash and the case where we have not a flash + */ + + if ( !fFlashLabels.empty() ) { + + // Hold the cryostat information + std::vector cids; + + + for ( size_t iFlashLabel=0; iFlashLabel> flash_handle; + e.getByLabel( label, flash_handle ); + + // We want our flashes to be valid and not empty + if( !flash_handle.isValid() ) { + mf::LogError("SBNDFlashAssAna") + << "Not found a recob::OpFlash with label '" << label.encode() << "'"; + } else if ( flash_handle->empty() ) { + mf::LogWarning("SBNDFlashAssAna") + << "No recob::OpFlash in collection with label '" << label.encode() << "'"; + } + else { + + art::FindManyP ophitsPtr( flash_handle, e, label ); + + for ( size_t idx=0; idxsize(); idx++ ) { + + m_pmt_pe.resize(360); + m_pmt_time.resize(360); + m_pmt_max_amplitude.resize(360); + + m_flash_id = idx; + auto const & flash = (*flash_handle)[idx]; + + m_flash_time = flash.Time(); + m_sum_pe = flash.TotalPE(); + + auto const & ophits = ophitsPtr.at(idx); + + // We keep track of the cryistats where the flashes are found; + geo::CryostatID::CryostatID_t cid = getCryostatByChannel(ophits.front()->OpChannel()); + + auto const found = std::find(cids.begin(), cids.end(), cid); + if( found != cids.end() ){ + cids.push_back( cid ); + } + + // Get the multiplicity, the position and the number of PE per Side + float xyz[3] = {0.0, 0.0, 0.0}; + processOpHitsFlash( ophits, + m_multiplicity_left, m_multiplicity_right, + m_sum_pe_left, m_sum_pe_right, xyz, + m_pmt_time, m_pmt_pe, m_pmt_max_amplitude, + fOpHitFlashTrees[iFlashLabel] ); + + m_multiplicity = m_multiplicity_left+m_multiplicity_right; + + //m_flash_x = 0.0; + //m_flash_width_x = 0.0; + m_flash_y = flash.YCenter(); + m_flash_width_y = flash.YWidth(); + m_flash_z = flash.ZCenter(); + m_flash_width_z = flash.ZWidth(); + + fOpFlashTrees[iFlashLabel]->Fill(); + + m_pmt_pe.clear(); + m_pmt_time.clear(); + + } + } + } + + // If the flashes did not cover all three cryostats.. + // ..well, we save the ophits on what is missing + for( unsigned int cid=0; cidNcryostats(); cid++ ){ + + auto const found = std::find( cids.begin(), cids.end(), cid ); + if( found == cids.end() ){ + processOpHits(e, cid); + } + } + } + + else { + + mf::LogError("SBNDFlashAssAna") + << "No recob::OpFlash labels selected\n"; + + // We save the ophits anyways even in absence of flashes + for( unsigned int cid=0; cidNcryostats(); cid++ ){ + processOpHits(e, cid); + } + + } + + + fEventTree->Fill(); + +} + + +DEFINE_ART_MODULE(opana::SBNDFlashAssAna) From c4c238bd4eabbf290ed2c037eef82a3ac02a27de Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Mon, 11 Mar 2024 15:54:17 -0500 Subject: [PATCH 02/13] Re-organize the fcl files for calibration skimmers --- sbndcode/PDS/OpReco/pmtskim_sbnd.fcl | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 sbndcode/PDS/OpReco/pmtskim_sbnd.fcl diff --git a/sbndcode/PDS/OpReco/pmtskim_sbnd.fcl b/sbndcode/PDS/OpReco/pmtskim_sbnd.fcl new file mode 100644 index 000000000..6b3a3bb54 --- /dev/null +++ b/sbndcode/PDS/OpReco/pmtskim_sbnd.fcl @@ -0,0 +1,15 @@ +BEGIN_PROLOG + +pmtskim_sbnd: +{ + module_type: "SBNDFlashAssAna" + TriggerLabel: "generator" + DumpWaveformsInfo: false + OpDetWaveformLabels: ["opdecopmt", "opdecoxarapuca"] + OpHitLabels: ["ophitpmt", "ophitxarapuca"] + FlashLabels: ["opflashtpc0", "opflashtpc1", "opflashtpc0xarapuca", "opflashtpc1xarapuca"] + PEOpHitThreshold: 0 + Debug: false +} + +END_PROLOG From e1e23adb33398a0535415fb3863c341f9a1d892e Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Mon, 11 Mar 2024 15:55:05 -0500 Subject: [PATCH 03/13] Re-organize the calibration skimmer fcls --- .../CRTBackTracker/crtbacktrackeralg_sbnd.fcl | 1 + sbndcode/JobConfigurations/base/reco_sbnd.fcl | 4 +- .../standard/reco/reco2_sce.fcl | 38 +++++++++---------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl b/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl index 23ff75e4c..d1c5293d7 100644 --- a/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl +++ b/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl @@ -2,6 +2,7 @@ BEGIN_PROLOG crtbacktrackeralg_sbnd: { + module_type: "CRTCalibAna" SimModuleLabel: "largeant" SimDepositModuleLabel: "genericcrt" FEBDataModuleLabel: "crtsim" diff --git a/sbndcode/JobConfigurations/base/reco_sbnd.fcl b/sbndcode/JobConfigurations/base/reco_sbnd.fcl index 9921850e0..957ebdd71 100644 --- a/sbndcode/JobConfigurations/base/reco_sbnd.fcl +++ b/sbndcode/JobConfigurations/base/reco_sbnd.fcl @@ -245,9 +245,11 @@ physics: analyzers:{ caloskim: @local::caloskim_nodigits_goldentracks + , crtskim: @local::crtbacktrackeralg_sbnd + , pmtskim: @local::pmtskim_sbnd } - caloskimana: [ caloskim ] + caloskimana: [ caloskim, crtskim, pmtskim ] #define the output stream, there could be more than one if using filters stream1: [ out1 ] diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index 62b10adab..31c50c8d1 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -24,25 +24,25 @@ physics.reco2_sce: [@sequence::physics.reco2, physics.trigger_paths: [ reco2_sce ] -physics.analyzers.crtskim: { - module_type: "CRTCalibAna" - CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd -} -physics.crtskimana: [ "crtskim" ] - -physics.analyzers.pmtskim: { - module_type: "SBNDFlashAssAna" - TriggerLabel: "generator" - DumpWaveformsInfo: false - OpDetWaveformLabels: ["opdecopmt", "opdecoxarapuca"] - OpHitLabels: ["ophitpmt", "ophitxarapuca"] - FlashLabels: ["opflashtpc0", "opflashtpc1", "opflashtpc0xarapuca", "opflashtpc1xarapuca"] - PEOpHitThreshold: 0 - Debug: false -} -physics.pmtskimana: [ "pmtskim" ] - -physics.end_paths: [stream1, caloskimana, crtskimana, pmtskimana] +#physics.analyzers.crtskim: { +# module_type: "CRTCalibAna" +# CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd +#} +#physics.crtskimana: [ "crtskim" ] +# +#physics.analyzers.pmtskim: { +# module_type: "SBNDFlashAssAna" +# TriggerLabel: "generator" +# DumpWaveformsInfo: false +# OpDetWaveformLabels: ["opdecopmt", "opdecoxarapuca"] +# OpHitLabels: ["ophitpmt", "ophitxarapuca"] +# FlashLabels: ["opflashtpc0", "opflashtpc1", "opflashtpc0xarapuca", "opflashtpc1xarapuca"] +# PEOpHitThreshold: 0 +# Debug: false +#} +#physics.pmtskimana: [ "pmtskim" ] + +physics.end_paths: [stream1, caloskimana] # turn on space charge service #include "enable_spacecharge_services_sbnd.fcl" From 41f0e909d7b3c2e90d9ee7c39cdf338f9edfbdc2 Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Mon, 11 Mar 2024 20:36:28 -0500 Subject: [PATCH 04/13] Bug fix for the last commit... --- .../CRTBackTracker/crtbacktrackeralg_sbnd.fcl | 1 - sbndcode/JobConfigurations/base/reco_sbnd.fcl | 12 ++++++++--- .../standard/reco/reco2_sce.fcl | 20 +------------------ sbndcode/PDS/OpReco/CMakeLists.txt | 1 + 4 files changed, 11 insertions(+), 23 deletions(-) diff --git a/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl b/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl index d1c5293d7..23ff75e4c 100644 --- a/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl +++ b/sbndcode/CRT/CRTBackTracker/crtbacktrackeralg_sbnd.fcl @@ -2,7 +2,6 @@ BEGIN_PROLOG crtbacktrackeralg_sbnd: { - module_type: "CRTCalibAna" SimModuleLabel: "largeant" SimDepositModuleLabel: "genericcrt" FEBDataModuleLabel: "crtsim" diff --git a/sbndcode/JobConfigurations/base/reco_sbnd.fcl b/sbndcode/JobConfigurations/base/reco_sbnd.fcl index 957ebdd71..8657a14a5 100644 --- a/sbndcode/JobConfigurations/base/reco_sbnd.fcl +++ b/sbndcode/JobConfigurations/base/reco_sbnd.fcl @@ -51,6 +51,8 @@ ###include "hitparticleassociations.fcl" #include "sbnd_trackcalo_skimmer.fcl" +#include "crtbacktrackeralg_sbnd.fcl" +#include "pmtskim_sbnd.fcl" process_name: Reco @@ -245,11 +247,15 @@ physics: analyzers:{ caloskim: @local::caloskim_nodigits_goldentracks - , crtskim: @local::crtbacktrackeralg_sbnd - , pmtskim: @local::pmtskim_sbnd + crtskim: { + module_type: "CRTCalibAna" + CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd + } + pmtskim: @local::pmtskim_sbnd } - caloskimana: [ caloskim, crtskim, pmtskim ] +# caloskimana: [ caloskim, pmtskim ] +caloskimana: [ caloskim, crtskim, pmtskim ] #define the output stream, there could be more than one if using filters stream1: [ out1 ] diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index 31c50c8d1..8d7852801 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -9,7 +9,7 @@ # job configuration #include "simulationservices_sbnd.fcl" -#include "crtbacktrackeralg_sbnd.fcl" +##include "crtbacktrackeralg_sbnd.fcl" #include "reco_sbnd.fcl" process_name: Reco2 @@ -24,24 +24,6 @@ physics.reco2_sce: [@sequence::physics.reco2, physics.trigger_paths: [ reco2_sce ] -#physics.analyzers.crtskim: { -# module_type: "CRTCalibAna" -# CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd -#} -#physics.crtskimana: [ "crtskim" ] -# -#physics.analyzers.pmtskim: { -# module_type: "SBNDFlashAssAna" -# TriggerLabel: "generator" -# DumpWaveformsInfo: false -# OpDetWaveformLabels: ["opdecopmt", "opdecoxarapuca"] -# OpHitLabels: ["ophitpmt", "ophitxarapuca"] -# FlashLabels: ["opflashtpc0", "opflashtpc1", "opflashtpc0xarapuca", "opflashtpc1xarapuca"] -# PEOpHitThreshold: 0 -# Debug: false -#} -#physics.pmtskimana: [ "pmtskim" ] - physics.end_paths: [stream1, caloskimana] # turn on space charge service diff --git a/sbndcode/PDS/OpReco/CMakeLists.txt b/sbndcode/PDS/OpReco/CMakeLists.txt index d2265d92d..cffeb2aac 100644 --- a/sbndcode/PDS/OpReco/CMakeLists.txt +++ b/sbndcode/PDS/OpReco/CMakeLists.txt @@ -36,3 +36,4 @@ cet_build_plugin(SBNDFlashAssAna art::module LIBRARIES ${MODULE_LIBRARIES}) install_headers() install_source() +install_fhicl() From 1ffea3b5c5f31e3bc07a63c431264d15947a2a9f Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Mon, 11 Mar 2024 20:51:02 -0500 Subject: [PATCH 05/13] Add comments to explain the CRT variables --- sbndcode/CRT/CRTAna/CRTAnalysis_module.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/sbndcode/CRT/CRTAna/CRTAnalysis_module.cc b/sbndcode/CRT/CRTAna/CRTAnalysis_module.cc index 648aeb0a2..46ca4fd22 100644 --- a/sbndcode/CRT/CRTAna/CRTAnalysis_module.cc +++ b/sbndcode/CRT/CRTAna/CRTAnalysis_module.cc @@ -96,6 +96,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { int _subrun; int _event; + //mc truth std::vector _mc_trackid; std::vector _mc_pdg; std::vector _mc_status; @@ -118,6 +119,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector _mc_endpz; std::vector _mc_ende; + //G4 detector id std::vector _ide_trackid; std::vector _ide_e; std::vector _ide_entryx; @@ -129,6 +131,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector _ide_exitz; std::vector _ide_exitt; + //front end mother board std::vector _feb_mac5; std::vector _feb_flags; std::vector _feb_ts0; @@ -137,6 +140,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector> _feb_adc; std::vector _feb_coinc; + //strip hit to select the strip which has ADC above threshold std::vector _sh_channel; std::vector _sh_ts0; std::vector _sh_ts1; @@ -154,6 +158,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector _sh_truth_energy; std::vector _sh_truth_time; + //cluster from x-y coincidence for CRTSpacePoint , this is what we normally call a CRT hit std::vector _cl_ts0; std::vector _cl_ts1; std::vector _cl_unixs; @@ -188,6 +193,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector _cl_sp_etime; std::vector _cl_sp_complete; + //backtrack truth information from reco level std::vector _td_tag_trackid; std::vector _td_tag_pdg; std::vector _td_tag_tagger; @@ -206,6 +212,7 @@ class sbnd::crt::CRTAnalysis : public art::EDAnalyzer { std::vector _td_reco_status; std::vector _td_reco_triple; + //track level information std::vector _tr_start_x; std::vector _tr_start_y; std::vector _tr_start_z; From c2876f2e4f7dc24d8cfa66f0e5100a8683c644d1 Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 10:25:28 -0500 Subject: [PATCH 06/13] Remove some comments to tidy up --- sbndcode/JobConfigurations/base/reco_sbnd.fcl | 1 - sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl | 1 - 2 files changed, 2 deletions(-) diff --git a/sbndcode/JobConfigurations/base/reco_sbnd.fcl b/sbndcode/JobConfigurations/base/reco_sbnd.fcl index 6b8cc9ac6..6f2b40a11 100644 --- a/sbndcode/JobConfigurations/base/reco_sbnd.fcl +++ b/sbndcode/JobConfigurations/base/reco_sbnd.fcl @@ -254,7 +254,6 @@ physics: pmtskim: @local::pmtskim_sbnd } -# caloskimana: [ caloskim, pmtskim ] caloskimana: [ caloskim, crtskim, pmtskim ] #define the output stream, there could be more than one if using filters diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index 8d7852801..d1b3f1dc7 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -9,7 +9,6 @@ # job configuration #include "simulationservices_sbnd.fcl" -##include "crtbacktrackeralg_sbnd.fcl" #include "reco_sbnd.fcl" process_name: Reco2 From e2c6a16ec04efe324b80c43458272835a2ca8023 Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 11:21:52 -0500 Subject: [PATCH 07/13] Move PDS (calibration) to Calibration --- sbndcode/Calibration/CMakeLists.txt | 3 +-- sbndcode/{PDS => Calibration}/OpReco/CMakeLists.txt | 0 sbndcode/{PDS => Calibration}/OpReco/SBNDFlashAssAna_module.cc | 0 sbndcode/{PDS => Calibration}/OpReco/pmtskim_sbnd.fcl | 0 sbndcode/PDS/CMakeLists.txt | 1 - 5 files changed, 1 insertion(+), 3 deletions(-) rename sbndcode/{PDS => Calibration}/OpReco/CMakeLists.txt (100%) rename sbndcode/{PDS => Calibration}/OpReco/SBNDFlashAssAna_module.cc (100%) rename sbndcode/{PDS => Calibration}/OpReco/pmtskim_sbnd.fcl (100%) delete mode 100644 sbndcode/PDS/CMakeLists.txt diff --git a/sbndcode/Calibration/CMakeLists.txt b/sbndcode/Calibration/CMakeLists.txt index 139597f9c..982c5e99c 100644 --- a/sbndcode/Calibration/CMakeLists.txt +++ b/sbndcode/Calibration/CMakeLists.txt @@ -1,2 +1 @@ - - +add_subdirectory(OpReco) diff --git a/sbndcode/PDS/OpReco/CMakeLists.txt b/sbndcode/Calibration/OpReco/CMakeLists.txt similarity index 100% rename from sbndcode/PDS/OpReco/CMakeLists.txt rename to sbndcode/Calibration/OpReco/CMakeLists.txt diff --git a/sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc b/sbndcode/Calibration/OpReco/SBNDFlashAssAna_module.cc similarity index 100% rename from sbndcode/PDS/OpReco/SBNDFlashAssAna_module.cc rename to sbndcode/Calibration/OpReco/SBNDFlashAssAna_module.cc diff --git a/sbndcode/PDS/OpReco/pmtskim_sbnd.fcl b/sbndcode/Calibration/OpReco/pmtskim_sbnd.fcl similarity index 100% rename from sbndcode/PDS/OpReco/pmtskim_sbnd.fcl rename to sbndcode/Calibration/OpReco/pmtskim_sbnd.fcl diff --git a/sbndcode/PDS/CMakeLists.txt b/sbndcode/PDS/CMakeLists.txt deleted file mode 100644 index 982c5e99c..000000000 --- a/sbndcode/PDS/CMakeLists.txt +++ /dev/null @@ -1 +0,0 @@ -add_subdirectory(OpReco) From cb685455a91541b8ec1703953c239d7273bd84cf Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 11:53:59 -0500 Subject: [PATCH 08/13] Re-organize CRT fcl --- sbndcode/Calibration/CRT/CMakeLists.txt | 1 + sbndcode/Calibration/CRT/crtskim_sbnd.fcl | 6 ++++++ 2 files changed, 7 insertions(+) create mode 100644 sbndcode/Calibration/CRT/CMakeLists.txt create mode 100644 sbndcode/Calibration/CRT/crtskim_sbnd.fcl diff --git a/sbndcode/Calibration/CRT/CMakeLists.txt b/sbndcode/Calibration/CRT/CMakeLists.txt new file mode 100644 index 000000000..13355789a --- /dev/null +++ b/sbndcode/Calibration/CRT/CMakeLists.txt @@ -0,0 +1 @@ +install_fhicl() diff --git a/sbndcode/Calibration/CRT/crtskim_sbnd.fcl b/sbndcode/Calibration/CRT/crtskim_sbnd.fcl new file mode 100644 index 000000000..dde441a2d --- /dev/null +++ b/sbndcode/Calibration/CRT/crtskim_sbnd.fcl @@ -0,0 +1,6 @@ +BEGIN_PROLOG +crtskim_sbnd: { + module_type: "CRTCalibAna" + CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd +} +END_PROLOG From 2bf4e7506d993f1583b9d71f4054fa10e4714c7b Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 11:54:13 -0500 Subject: [PATCH 09/13] Re-organize CRT fcl --- sbndcode/CMakeLists.txt | 2 +- sbndcode/Calibration/CMakeLists.txt | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/sbndcode/CMakeLists.txt b/sbndcode/CMakeLists.txt index ac4478288..ea7091181 100644 --- a/sbndcode/CMakeLists.txt +++ b/sbndcode/CMakeLists.txt @@ -16,7 +16,7 @@ add_subdirectory(OpDetSim) add_subdirectory(OpDetReco) add_subdirectory(OpDetAnalyzer) add_subdirectory(OpT0Finder) -add_subdirectory(PDS) +#add_subdirectory(PDS) #add_subdirectory(CosmicId) add_subdirectory(ShowerAna) add_subdirectory(Commissioning) diff --git a/sbndcode/Calibration/CMakeLists.txt b/sbndcode/Calibration/CMakeLists.txt index 982c5e99c..33e31fba2 100644 --- a/sbndcode/Calibration/CMakeLists.txt +++ b/sbndcode/Calibration/CMakeLists.txt @@ -1 +1,2 @@ add_subdirectory(OpReco) +add_subdirectory(CRT) From c03f52492d7b5fc02ca4706ed9ff5efc03de63d2 Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 12:04:57 -0500 Subject: [PATCH 10/13] Move crt config out of reco_sbnd --- sbndcode/Calibration/CRT/crtskim_sbnd.fcl | 2 ++ sbndcode/JobConfigurations/base/reco_sbnd.fcl | 7 ++----- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/sbndcode/Calibration/CRT/crtskim_sbnd.fcl b/sbndcode/Calibration/CRT/crtskim_sbnd.fcl index dde441a2d..3514a39c1 100644 --- a/sbndcode/Calibration/CRT/crtskim_sbnd.fcl +++ b/sbndcode/Calibration/CRT/crtskim_sbnd.fcl @@ -1,3 +1,5 @@ +#include "crtbacktrackeralg_sbnd.fcl" + BEGIN_PROLOG crtskim_sbnd: { module_type: "CRTCalibAna" diff --git a/sbndcode/JobConfigurations/base/reco_sbnd.fcl b/sbndcode/JobConfigurations/base/reco_sbnd.fcl index 6f2b40a11..017b1443f 100644 --- a/sbndcode/JobConfigurations/base/reco_sbnd.fcl +++ b/sbndcode/JobConfigurations/base/reco_sbnd.fcl @@ -51,7 +51,7 @@ ###include "hitparticleassociations.fcl" #include "sbnd_trackcalo_skimmer.fcl" -#include "crtbacktrackeralg_sbnd.fcl" +#include "crtskim_sbnd.fcl" #include "pmtskim_sbnd.fcl" process_name: Reco @@ -247,10 +247,7 @@ physics: analyzers:{ caloskim: @local::caloskim_nodigits_goldentracks - crtskim: { - module_type: "CRTCalibAna" - CRTBackTrackerAlg: @local::crtbacktrackeralg_sbnd - } + crtskim: @local::crtskim_sbnd pmtskim: @local::pmtskim_sbnd } From 0249bcd1e00855d0885c467b15022cc92b6837bc Mon Sep 17 00:00:00 2001 From: Linyan Wan Date: Tue, 12 Mar 2024 13:00:35 -0500 Subject: [PATCH 11/13] Clock etc --- sbndcode/JobConfigurations/base/reco_sbnd.fcl | 1 + sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/sbndcode/JobConfigurations/base/reco_sbnd.fcl b/sbndcode/JobConfigurations/base/reco_sbnd.fcl index 017b1443f..7fdad8d1e 100644 --- a/sbndcode/JobConfigurations/base/reco_sbnd.fcl +++ b/sbndcode/JobConfigurations/base/reco_sbnd.fcl @@ -69,6 +69,7 @@ services: SignalShapingServiceSBND: @local::sbnd_signalshapingservice # from signalservices_sbnd.fcl BackTrackerService: @local::sbnd_backtrackerservice ParticleInventoryService: @local::sbnd_particleinventoryservice + DetectorClocksService: @local::sbnd_detectorclocks } #source is now a root file diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index d1b3f1dc7..7ca2f28d5 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -13,8 +13,8 @@ process_name: Reco2 -services.ParticleInventoryService: @local::sbnd_particleinventoryservice -services.BackTrackerService: @local::sbnd_backtrackerservice +#services.ParticleInventoryService: @local::sbnd_particleinventoryservice +#services.BackTrackerService: @local::sbnd_backtrackerservice services.DetectorClocksService: @local::sbnd_detectorclocks physics.reco2_sce: [@sequence::physics.reco2, From da5e56d8b2f434eaa364d5903120d146f2d47bbe Mon Sep 17 00:00:00 2001 From: linyan-w <53352772+linyan-w@users.noreply.github.com> Date: Tue, 12 Mar 2024 13:17:27 -0500 Subject: [PATCH 12/13] Update sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl Co-authored-by: VCLanNguyen <74775793+VCLanNguyen@users.noreply.github.com> --- sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl | 3 --- 1 file changed, 3 deletions(-) diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index 7ca2f28d5..d5bb1a321 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -13,9 +13,6 @@ process_name: Reco2 -#services.ParticleInventoryService: @local::sbnd_particleinventoryservice -#services.BackTrackerService: @local::sbnd_backtrackerservice -services.DetectorClocksService: @local::sbnd_detectorclocks physics.reco2_sce: [@sequence::physics.reco2, pandoraSCE, pandoraSCETrack, pandoraSCEShower, pandoraSCEShowerSBN, pandoraSCECalo, pandoraSCEPid, crtspacepointmatchingSCE, crttrackmatchingSCE, From 990167f5e74db5394a3b6522cdb42cd72f0837b0 Mon Sep 17 00:00:00 2001 From: linyan-w <53352772+linyan-w@users.noreply.github.com> Date: Tue, 12 Mar 2024 13:17:39 -0500 Subject: [PATCH 13/13] Update sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl Co-authored-by: VCLanNguyen <74775793+VCLanNguyen@users.noreply.github.com> --- sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl | 1 - 1 file changed, 1 deletion(-) diff --git a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl index d5bb1a321..74ee654d4 100644 --- a/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl +++ b/sbndcode/JobConfigurations/standard/reco/reco2_sce.fcl @@ -8,7 +8,6 @@ # # job configuration -#include "simulationservices_sbnd.fcl" #include "reco_sbnd.fcl" process_name: Reco2