dqm::PhotoNuclearDQM Class Reference

Public Member Functions
	PhotoNuclearDQM (const std::string &name, framework::Process &process)
void	configure (framework::config::Parameters &parameters) override
	Read common configuration parameters: sim_particles_coll_name, sim_particles_passname, count_light_ions.
void	analyze (const framework::Event &event) override
	Process the event and make histograms or summaries.
Public Member Functions inherited from dqm::NuclearDQM
	NuclearDQM (const std::string &name, framework::Process &process)
Public Member Functions inherited from framework::Analyzer
	Analyzer (const std::string &name, Process &process)
	Class constructor.
virtual void	process (Event &event) final
	Processing an event for an Analyzer is calling analyze.
virtual void	beforeNewRun (ldmx::RunHeader &run_header) final
	Don't allow Analyzers to add parameters to the run header.
Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()=default
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Member Functions
void	findRecoilProperties (const ldmx::SimParticle *recoil)
	Fill recoil-electron vertex histograms.
void	analyzeInteractionDetails (const framework::Event &event)
	Analyze the PhotonuclearInteraction collection when present.

Private Attributes
std::string	pn_collection_name_
std::string	pn_pass_name_

Additional Inherited Members
Public Types inherited from dqm::NuclearDQM
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 }
	Classification of PN/EN events by the hard particles produced above a kinetic-energy threshold. More...
enum class	CompactEventType {   single_neutron = 0 , single_charged_kaon = 1 , single_neutral_kaon = 2 , two_neutrons = 3 ,   soft = 4 , other = 5 }
	Compact classification focusing on very-high-energy single particles. More...
Protected Member Functions inherited from dqm::NuclearDQM
std::vector< const ldmx::SimParticle * >	findDaughters (const std::map< int, ldmx::SimParticle > &particleMap, const ldmx::SimParticle *parent, int require_process_type=-1) const
	Return daughters of parent that pass PDG-based filtering:
void	findParticleKinematics (const std::vector< const ldmx::SimParticle * > &daughters, const std::string &prefix)
	Fill kinematic histograms for the nuclear interaction products.
void	findExtendedKinematics (const std::vector< const ldmx::SimParticle * > &daughters, const std::string &prefix)
	Fill extended kinematic histograms for EN interactions: hardest_pi_ke/theta (π± only), hardest_pi0_ke/theta, {prefix}_proton_mult, {prefix}_charged_pion_mult, {prefix}_neutral_pion_mult, leading_particle_type.
void	findSubleadingKinematics (const ldmx::SimParticle *initiator, const std::vector< const ldmx::SimParticle * > &daughters, EventType eventType)
	Fill subleading-kinematics histograms for 1n, 2n, charged-kaon and neutral-kaon event types.
EventType	classifyEvent (const std::vector< const ldmx::SimParticle * > &daughters, double threshold)
	Classify the event by the number and type of hard daughters above threshold [MeV] of kinetic energy.
CompactEventType	classifyCompactEvent (const ldmx::SimParticle *initiator, const std::vector< const ldmx::SimParticle * > &daughters, double threshold)
	Compact classification: looks for a single particle carrying >= 80% of the initiator energy, or two neutrons each above threshold [MeV].
constexpr bool	isLightIon (int pdgCode) const
	Return true if pdgCode is a light ion (Z <= 4).
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from dqm::NuclearDQM
std::string	sim_particles_coll_name_
std::string	sim_particles_passname_
bool	count_light_ions_ {true}
Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 10 of file PhotoNuclearDQM.h.

Constructor & Destructor Documentation

PhotoNuclearDQM()

dqm::PhotoNuclearDQM::PhotoNuclearDQM	(	const std::string &	name,
		framework::Process &	process )

Definition at line 6 of file PhotoNuclearDQM.cxx.

    : NuclearDQM(name, process) {}

Member Function Documentation

analyze()

void dqm::PhotoNuclearDQM::analyze ( const framework::Event & event )

overridevirtual

Process the event and make histograms or summaries.

Parameters

event

The Event to analyze

Implements framework::Analyzer.

Definition at line 84 of file PhotoNuclearDQM.cxx.

                                                         {
  // Get the particle map from the event.  If the particle map is empty,
  // don't process the event.
  auto particle_map{event.getMap<int, ldmx::SimParticle>(
      sim_particles_coll_name_, sim_particles_passname_)};
  if (particle_map.empty()) return;
 
  // Get the recoil electron
  auto [trackID, recoil] = analysis::getRecoil(particle_map);
  findRecoilProperties(recoil);
 
  // Use the recoil electron to retrieve the gamma that underwent a
  // photo-nuclear reaction.
  auto pn_gamma{analysis::getPNGamma(particle_map, recoil, 2500.)};
  if (pn_gamma == nullptr) {
    ldmx_log(warn) << "PN Daughter is lost, skipping";
    return;
  }
 
  const auto pn_daughters{findDaughters(particle_map, pn_gamma)};
 
  if (!pn_daughters.empty()) {
    auto pn_vertex_volume{pn_daughters[0]->getVertexVolume()};
    auto pn_interaction_material{pn_daughters[0]->getInteractionMaterial()};
 
    // Let's start with the PN vertex volume
    if (pn_vertex_volume.find("W_cooling") != std::string::npos) {
      // W_cooling_volume_X
      histograms_.fill("pn_vertex_volume", 2);
    } else if (pn_vertex_volume.find("C_volume") != std::string::npos) {
      // C_volume_X
      histograms_.fill("pn_vertex_volume", 3);
    } else if (pn_vertex_volume.find("PCB_volume") != std::string::npos) {
      histograms_.fill("pn_vertex_volume", 4);
    } else if (pn_vertex_volume.find("CarbonBasePlate") != std::string::npos) {
      // CarbonBasePlate_volume
      histograms_.fill("pn_vertex_volume", 5);
    } else if (pn_vertex_volume.find("W_front") != std::string::npos) {
      // W_front_volume_X
      histograms_.fill("pn_vertex_volume", 6);
    } else if (pn_vertex_volume.find("Si_volume") != std::string::npos) {
      histograms_.fill("pn_vertex_volume", 7);
    } else if (pn_vertex_volume.find("Glue") != std::string::npos) {
      histograms_.fill("pn_vertex_volume", 8);
    } else if (pn_vertex_volume.find("motherboard") != std::string::npos) {
      histograms_.fill("pn_vertex_volume", 9);
    } else {
      ldmx_log(debug) << " Else pn_vertex_volume = " << pn_vertex_volume
                      << " with pn_interaction_material = "
                      << pn_interaction_material;
      histograms_.fill("pn_vertex_volume", 1);
    }
 
    // Now the interaction material
    if (pn_interaction_material.find("Silicon") != std::string::npos ||
        pn_interaction_material.find("G4_Si") != std::string::npos) {
      histograms_.fill("pn_interaction_material", 2);
    } else if (pn_interaction_material.find("Tungsten") != std::string::npos ||
               pn_interaction_material.find("G4_W") != std::string::npos) {
      histograms_.fill("pn_interaction_material", 3);
    } else if (pn_interaction_material.find("FR4") != std::string::npos) {
      // Glass epoxy
      histograms_.fill("pn_interaction_material", 4);
    } else if (pn_interaction_material.find("Steel") != std::string::npos) {
      histograms_.fill("pn_interaction_material", 5);
    } else if (pn_interaction_material.find("Epoxy") != std::string::npos) {
      // CarbonEpoxyComposite
      histograms_.fill("pn_interaction_material", 6);
    } else if (pn_interaction_material.find("Scintillator") !=
               std::string::npos) {
      // This is the notion for PVT
      histograms_.fill("pn_interaction_material", 7);
    } else if (pn_interaction_material.find("Glue") != std::string::npos) {
      // This is the notion for PVT
      histograms_.fill("pn_interaction_material", 8);
    } else if (pn_interaction_material.find("Air") != std::string::npos ||
               pn_interaction_material.find("G4_AIR") != std::string::npos) {
      // Air
      histograms_.fill("pn_interaction_material", 9);
    } else {
      ldmx_log(debug) << " Else pn_interaction_material = "
                      << pn_interaction_material
                      << " with pn_vertex_volume = " << pn_vertex_volume;
      histograms_.fill("pn_interaction_material", 1);
    }
  } else {
    histograms_.fill("pn_vertex_volume", 0);
    histograms_.fill("pn_interaction_material", 0);
  }
 
  findParticleKinematics(pn_daughters, "pn");
 
  histograms_.fill("pn_particle_mult", pn_gamma->getDaughters().size());
  histograms_.fill("pn_gamma_energy", pn_gamma->getEnergy());
  histograms_.fill("pn_gamma_int_x", pn_gamma->getEndPoint()[0]);
  histograms_.fill("pn_gamma_int_y", pn_gamma->getEndPoint()[1]);
  histograms_.fill("pn_gamma_int_x:pn_gamma_int_y", pn_gamma->getEndPoint()[0],
                   pn_gamma->getEndPoint()[1]);
  histograms_.fill("pn_gamma_int_z", pn_gamma->getEndPoint()[2]);
  histograms_.fill("pn_gamma_vertex_x", pn_gamma->getVertex()[0]);
  histograms_.fill("pn_gamma_vertex_y", pn_gamma->getVertex()[1]);
  histograms_.fill("pn_gamma_vertex_z", pn_gamma->getVertex()[2]);
 
  // Classify the event
  auto event_type{classifyEvent(pn_daughters, 200)};
  auto event_type500_mev{classifyEvent(pn_daughters, 500)};
  auto event_type2000_mev{classifyEvent(pn_daughters, 2000)};
 
  auto event_type_comp{classifyCompactEvent(pn_gamma, pn_daughters, 200)};
  auto event_type_comp500_mev{
      classifyCompactEvent(pn_gamma, pn_daughters, 500)};
  auto event_type_comp2000_mev{
      classifyCompactEvent(pn_gamma, pn_daughters, 2000)};
 
  histograms_.fill("event_type", static_cast<int>(event_type));
  histograms_.fill("event_type_500mev", static_cast<int>(event_type500_mev));
  histograms_.fill("event_type_2000mev", static_cast<int>(event_type2000_mev));
  histograms_.fill("event_type_compact", static_cast<int>(event_type_comp));
  histograms_.fill("event_type_compact_500mev",
                   static_cast<int>(event_type_comp500_mev));
  histograms_.fill("event_type_compact_2000mev",
                   static_cast<int>(event_type_comp2000_mev));
 
  switch (event_type) {
    case EventType::single_neutron:
      if (pn_daughters.size() > 1) {
        auto second_hardest_pdg{std::abs(pn_daughters[1]->getPdgID())};
        int n_event_type{-10};
        if (second_hardest_pdg == 2112)
          n_event_type = 0;
        else if (second_hardest_pdg == 2212)
          n_event_type = 1;
        else if (second_hardest_pdg == 211)
          n_event_type = 2;
        else if (second_hardest_pdg == 111)
          n_event_type = 3;
        else
          n_event_type = 4;
        histograms_.fill("1n_event_type", n_event_type);
      }
      [[fallthrough]];  // Remaining code is important for 1n as well
    case EventType::two_neutrons:
    case EventType::charged_kaon:
    case EventType::klong:
    case EventType::kshort:
      findSubleadingKinematics(pn_gamma, pn_daughters, event_type);
      break;
    default:  // Nothing to do
      break;
  }
 
  // Analyze detailed photonuclear interaction tracking if available
  analyzeInteractionDetails(event);
}

analyzeInteractionDetails()

void dqm::PhotoNuclearDQM::analyzeInteractionDetails ( const framework::Event & event )

private

Analyze the PhotonuclearInteraction collection when present.

Fills target Z/A, cascade multiplicity, and descendant histograms.

Definition at line 25 of file PhotoNuclearDQM.cxx.

                                                                           {
  // Check if PhotonuclearInteraction collection exists
  if (!event.exists(pn_collection_name_, pn_pass_name_)) {
    // Collection not present - PN tracing was not enabled
    return;
  }
 
  // Get the PhotonuclearInteraction collection
  const auto& pn_interactions =
      event.getCollection<ldmx::PhotonuclearInteraction>(pn_collection_name_,
                                                         pn_pass_name_);
 
  // Analyze full cascade genealogy information not available from SimParticles:
  // - Target nucleus Z/A
  // - Immediate cascade multiplicity
  // - Full descendant genealogy tree (ALL particles, not just final state)
 
  int n_interactions = pn_interactions.size();
  histograms_.fill("pn_interaction_count", n_interactions);
 
  for (const auto& interaction : pn_interactions) {
    // Target nucleus information - UNIQUE to PhotonuclearInteraction
    histograms_.fill("pn_target_z", interaction.getTargetZ());
    histograms_.fill("pn_target_a", interaction.getTargetA());
    histograms_.fill("pn_target_z:target_a", interaction.getTargetZ(),
                     interaction.getTargetA());
 
    // Cascade multiplicity: how many particles created in initial cascade
    int n_cascade_secondaries = interaction.getNumImmediateSecondaries();
    histograms_.fill("pn_cascade_multiplicity", n_cascade_secondaries);
 
    // Full cascade genealogy tree - includes ALL descendants (intermediate +
    // final) This shows the complete cascade evolution, not just final state
    // particles
    auto descendant_map = interaction.getDescendantMap();
    int total_descendants = 0;
    for (const auto& [secondary_id, descendants] : descendant_map) {
      int n_desc = descendants.size();
      total_descendants += n_desc;
      // How many particles (intermediate + final) descended from each cascade
      // particle
      histograms_.fill("pn_descendants_per_cascade_particle", n_desc);
    }
    histograms_.fill("pn_total_final_state_descendants", total_descendants);
 
    // Cascade compactness: ratio shows what fraction of tree are immediate
    // secondaries ~1.0 → Compact cascade, few branches (most particles are
    // immediate secondaries) ~0.5 → Moderate branching (half the particles are
    // from further generations) ~0.1 → Highly branched cascade with extensive
    // decay/rescatter chains ~0.0 → Extreme branching (the "tungsten bomb"
    // scenarios)
    if (total_descendants > 0) {
      double compactness_ratio =
          static_cast<double>(n_cascade_secondaries) / total_descendants;
      histograms_.fill("pn_cascade_evolution_ratio", compactness_ratio);
    }
  }
}

References framework::Event::exists().

configure()

void dqm::PhotoNuclearDQM::configure ( framework::config::Parameters & parameters )

overridevirtual

Read common configuration parameters: sim_particles_coll_name, sim_particles_passname, count_light_ions.

Reimplemented from dqm::NuclearDQM.

Definition at line 10 of file PhotoNuclearDQM.cxx.

                                                                     {
  NuclearDQM::configure(parameters);
  pn_collection_name_ = parameters.get<std::string>("pn_collection_name",
                                                    "PhotonuclearInteractions");
  pn_pass_name_ = parameters.get<std::string>("pn_pass_name", "");
}

References framework::config::Parameters::get().

findRecoilProperties()

void dqm::PhotoNuclearDQM::findRecoilProperties ( const ldmx::SimParticle * recoil )

private

Fill recoil-electron vertex histograms.

Definition at line 17 of file PhotoNuclearDQM.cxx.

                                                                        {
  histograms_.fill("recoil_vertex_x", recoil->getVertex()[0]);
  histograms_.fill("recoil_vertex_y", recoil->getVertex()[1]);
  histograms_.fill("recoil_vertex_z", recoil->getVertex()[2]);
  histograms_.fill("recoil_vertex_x:recoil_vertex_y", recoil->getVertex()[0],
                   recoil->getVertex()[1]);
}

References ldmx::SimParticle::getVertex().

Member Data Documentation

pn_collection_name_

std::string dqm::PhotoNuclearDQM::pn_collection_name_

private

Definition at line 28 of file PhotoNuclearDQM.h.

pn_pass_name_

std::string dqm::PhotoNuclearDQM::pn_pass_name_

private

Definition at line 29 of file PhotoNuclearDQM.h.

---

The documentation for this class was generated from the following files:

• DQM/include/DQM/PhotoNuclearDQM.h
• DQM/src/DQM/PhotoNuclearDQM.cxx