PhotoNuclearDQM.h

#ifndef DQM_PHOTONUCLEARDQM_H
#define DQM_PHOTONUCLEARDQM_H
 
#include <Math/Vector3D.h>
 
#include <algorithm>
 
#include "Framework/Configure/Parameters.h"
#include "Framework/Event.h"
#include "Framework/EventProcessor.h"
#include "SimCore/Event/PhotonuclearInteraction.h"
#include "SimCore/Event/SimParticle.h"
#include "TH1F.h"
#include "TH2F.h"
#include "Tools/AnalysisUtils.h"
 
namespace dqm {
 
// Forward declarations within the ldmx workspace
class Event;
class SimParticle;
 
class PhotoNuclearDQM : public framework::Analyzer {
  // Classification schemes for PN events
  enum class CompactEventType {
    single_neutron = 0,
    single_charged_kaon = 1,
    single_neutral_kaon = 2,
    two_neutrons = 3,
    soft = 4,
    other = 5,
  };
  enum class EventType {
    nothing_hard = 0,
    single_neutron = 1,
    two_neutrons = 2,
    three_or_more_neutrons = 3,
    single_charged_pion = 4,
    two_charged_pions = 5,
    single_neutral_pion = 6,
    single_charged_pion_and_nucleon = 7,
    single_charged_pion_and_two_nucleons = 8,
    two_charged_pions_and_nucleon = 9,
    single_neutral_pion_and_nucleon = 10,
    single_neutral_pion_and_two_nucleons = 11,
    single_neutral_pion_charged_pion_and_nucleon = 12,
    single_proton = 13,
    two_protons = 14,
    proton_neutron = 15,
    klong = 16,
    charged_kaon = 17,
    kshort = 18,
    exotics = 19,
    multibody = 20,
  };
 
 public:
  PhotoNuclearDQM(const std::string &name, framework::Process &process);
 
  virtual ~PhotoNuclearDQM() = default;
 
  void configure(framework::config::Parameters &parameters) override;
 
  void analyze(const framework::Event &event) override;
 
 private:
  EventType classifyEvent(
      const std::vector<const ldmx::SimParticle *> daughters, double threshold);
 
  std::string sim_particles_coll_name_;
  std::string sim_particles_passname_;
 
  std::string pn_collection_name_;
  std::string pn_pass_name_;
 
  CompactEventType classifyCompactEvent(
      const ldmx::SimParticle *pnGamma,
      const std::vector<const ldmx::SimParticle *> daughters, double threshold);
 
  void findRecoilProperties(const ldmx::SimParticle *recoil);
 
  std::vector<const ldmx::SimParticle *> findDaughters(
      const std::map<int, ldmx::SimParticle> &particleMap,
      const ldmx::SimParticle *parent) const;
 
  void findParticleKinematics(
      const std::vector<const ldmx::SimParticle *> &pnDaughters);
 
  void findSubleadingKinematics(
      const ldmx::SimParticle *pnGamma,
      const std::vector<const ldmx::SimParticle *> &pnDaughters,  //
      const EventType eventType);
 
  void analyzeInteractionDetails(const framework::Event &event);
 
 public:
  constexpr bool isLightIon(const int pdgCode) const {
    if (pdgCode > 1000000000) {
      // Check if the atomic number is less than or equal to 4
      return ((pdgCode / 10) % 1000) <= 4;
    }
    return false;
  }
 
  bool count_light_ions_;
};
 
}  // namespace dqm
 
#endif  // _DQM_ECAL_PN_H_