dqm::NuclearDQM Class Reference

Base class for nuclear interaction DQM analyzers. More...

#include <NuclearDQM.h>

Public Types
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...

Public Member Functions
	NuclearDQM (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.
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.
virtual void	analyze (const Event &event)=0
	Process the event and make histograms or summaries.
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.

Protected Member Functions
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
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

Base class for nuclear interaction DQM analyzers.

Provides shared event classification, daughter finding, and kinematics methods reused by PhotoNuclearDQM and ElectroNuclearDQM.

Definition at line 24 of file NuclearDQM.h.

Member Enumeration Documentation

CompactEventType

enum class dqm::NuclearDQM::CompactEventType

strong

Compact classification focusing on very-high-energy single particles.

Definition at line 58 of file NuclearDQM.h.

                              {
    single_neutron = 0,
    single_charged_kaon = 1,
    single_neutral_kaon = 2,
    two_neutrons = 3,
    soft = 4,
    other = 5,
  };

EventType

enum class dqm::NuclearDQM::EventType

strong

Classification of PN/EN events by the hard particles produced above a kinetic-energy threshold.

Neutral pions are a separate category from charged pions throughout.

Definition at line 31 of file NuclearDQM.h.

                       {
    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,
  };

Constructor & Destructor Documentation

NuclearDQM()

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

Definition at line 6 of file NuclearDQM.cxx.

    : framework::Analyzer(name, process) {}

Member Function Documentation

classifyCompactEvent()

NuclearDQM::CompactEventType dqm::NuclearDQM::classifyCompactEvent ( const ldmx::SimParticle * initiator, const std::vector< const ldmx::SimParticle * > & daughters, double threshold )

protected

Compact classification: looks for a single particle carrying >= 80% of the initiator energy, or two neutrons each above threshold [MeV].

Definition at line 313 of file NuclearDQM.cxx.

                                                                          {
  short n{0}, n_t{0}, k0l{0}, kp{0}, k0s{0}, soft{0};
 
  for (const auto& daughter : daughters) {
    auto ke{daughter->getEnergy() - daughter->getMass()};
    auto pdg_id{std::abs(daughter->getPdgID())};
 
    if (ke < 500) {
      soft++;
      continue;
    }
 
    if (ke >= 0.8 * initiator->getEnergy()) {
      if (pdg_id == 2112)
        n++;
      else if (pdg_id == 130)
        k0l++;
      else if (pdg_id == 321)
        kp++;
      else if (pdg_id == 310)
        k0s++;
      continue;
    }
 
    if (pdg_id == 2112 && ke > threshold) n_t++;
  }
 
  int neutral_kaons{k0l + k0s};
  if (n != 0) return CompactEventType::single_neutron;
  if (kp != 0) return CompactEventType::single_charged_kaon;
  if (neutral_kaons != 0) return CompactEventType::single_neutral_kaon;
  if (n_t == 2) return CompactEventType::two_neutrons;
  if (soft == static_cast<short>(daughters.size()))
    return CompactEventType::soft;
  return CompactEventType::other;
}

References ldmx::SimParticle::getEnergy().

classifyEvent()

NuclearDQM::EventType dqm::NuclearDQM::classifyEvent ( const std::vector< const ldmx::SimParticle * > & daughters, double threshold )

protected

Classify the event by the number and type of hard daughters above threshold [MeV] of kinetic energy.

Assumes daughters sorted by KE.

Definition at line 240 of file NuclearDQM.cxx.

                                                                          {
  short n{0}, p{0}, pi{0}, pi0{0}, exotic{0}, k0l{0}, kp{0}, k0s{0};
 
  for (const auto& daughter : daughters) {
    auto ke{daughter->getEnergy() - daughter->getMass()};
    // daughters are sorted by KE descending; stop when below threshold
    if (ke <= threshold) break;
 
    auto pdg_id{std::abs(daughter->getPdgID())};
    if (pdg_id == 2112)
      n++;
    else if (pdg_id == 2212)
      p++;
    else if (pdg_id == 211)
      pi++;
    else if (pdg_id == 111)
      pi0++;
    else if (pdg_id == 130)
      k0l++;
    else if (pdg_id == 321)
      kp++;
    else if (pdg_id == 310)
      k0s++;
    else
      exotic++;
  }
 
  int kaons{k0l + kp + k0s};
  int nucleons{n + p};
  int pions{pi + pi0};
  int count{nucleons + pions + exotic + kaons};
 
  if (count == 0) return EventType::nothing_hard;
 
  if (count == 1) {
    if (n == 1) return EventType::single_neutron;
    if (p == 1) return EventType::single_proton;
    if (pi0 == 1) return EventType::single_neutral_pion;
    if (pi == 1) return EventType::single_charged_pion;
  }
  if (count == 2) {
    if (n == 2) return EventType::two_neutrons;
    if (n == 1 && p == 1) return EventType::proton_neutron;
    if (p == 2) return EventType::two_protons;
    if (pi == 2) return EventType::two_charged_pions;
    if (pi == 1 && nucleons == 1)
      return EventType::single_charged_pion_and_nucleon;
    if (pi0 == 1 && nucleons == 1)
      return EventType::single_neutral_pion_and_nucleon;
  }
  if (count == 3) {
    if (pi == 1 && nucleons == 2)
      return EventType::single_charged_pion_and_two_nucleons;
    if (pi == 2 && nucleons == 1)
      return EventType::two_charged_pions_and_nucleon;
    if (pi0 == 1 && nucleons == 2)
      return EventType::single_neutral_pion_and_two_nucleons;
    if (pi0 == 1 && nucleons == 1 && pi == 1)
      return EventType::single_neutral_pion_charged_pion_and_nucleon;
  }
  if (count >= 3 && count == n) return EventType::three_or_more_neutrons;
 
  if (kaons == 1) {
    if (k0l == 1) return EventType::klong;
    if (kp == 1) return EventType::charged_kaon;
    if (k0s == 1) return EventType::kshort;
  }
  if (exotic == count && count != 0) return EventType::exotics;
 
  return EventType::multibody;
}

configure()

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

overridevirtual

Read common configuration parameters: sim_particles_coll_name, sim_particles_passname, count_light_ions.

Reimplemented from framework::EventProcessor.

Reimplemented in dqm::PhotoNuclearDQM.

Definition at line 9 of file NuclearDQM.cxx.

                                                                {
  count_light_ions_ = parameters.get<bool>("count_light_ions", true);
  sim_particles_coll_name_ =
      parameters.get<std::string>("sim_particles_coll_name", "SimParticles");
  sim_particles_passname_ =
      parameters.get<std::string>("sim_particles_passname", "");
}

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

findDaughters()

std::vector< const ldmx::SimParticle * > dqm::NuclearDQM::findDaughters ( const std::map< int, ldmx::SimParticle > & particleMap, const ldmx::SimParticle * parent, int require_process_type = -1 ) const

protected

Return daughters of parent that pass PDG-based filtering:

• must be in the particle map
• not photons (PDG 22)
• not heavy nuclei (PDG > 10000) unless count_light_ions_ is true and the ion has Z <= 4

If require_process_type >= 0, only daughters whose processType matches are kept. Pass -1 (default) to disable process-type filtering.

Results are sorted by kinetic energy in descending order.

Definition at line 17 of file NuclearDQM.cxx.

                                                                   {
  std::vector<const ldmx::SimParticle*> daughters;
 
  for (const auto& daughter_track_id : parent->getDaughters()) {
    if (particleMap.count(daughter_track_id) == 0) continue;
 
    auto daughter{&(particleMap.at(daughter_track_id))};
 
    if (require_process_type >= 0 &&
        daughter->getProcessType() != require_process_type)
      continue;
 
    auto pdg_id{daughter->getPdgID()};
    if (pdg_id == 22 ||
        (pdg_id > 10000 && (!count_light_ions_ || !isLightIon(pdg_id))))
      continue;
 
    daughters.push_back(daughter);
  }
 
  std::sort(daughters.begin(), daughters.end(),
            [](const auto& lhs, const auto& rhs) {
              return (lhs->getEnergy() - lhs->getMass()) >
                     (rhs->getEnergy() - rhs->getMass());
            });
 
  return daughters;
}

References ldmx::SimParticle::getDaughters().

findExtendedKinematics()

void dqm::NuclearDQM::findExtendedKinematics ( const std::vector< const ldmx::SimParticle * > & daughters, const std::string & prefix )

protected

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.

leading_particle_type bins: 0=π±+X, 1=π⁰+X, 2=K±+X, 3=KS/KL+X, 4=p+X, 5=n+X, 6=other+X

Definition at line 109 of file NuclearDQM.cxx.

                             {
  // EN-specific kinematics: pi± and pi0 tracked separately, plus proton
  // multiplicity, leading-particle-type summary, and all the generic
  // hardest-particle quantities that findParticleKinematics would provide
  // for PN (so EN does not need to call findParticleKinematics at all).
  double hardest_ke{-1}, hardest_theta{-1};
  double hardest_n_ke{-1}, hardest_n_theta{-1};
  double hardest_p_ke{-1}, hardest_p_theta{-1};
  double hardest_pi0_ke{-1}, hardest_pi0_theta{-1};
  double total_ke{0}, total_neutron_ke{0};
  int neutron_multiplicity{0};
  int proton_multiplicity{0};
  int charged_pion_multiplicity{0};
  int neutral_pion_multiplicity{0};
 
  for (const auto* daughter : daughters) {
    auto pdg_id{daughter->getPdgID()};
    double ke{daughter->getEnergy() - daughter->getMass()};
    total_ke += ke;
 
    std::vector<double> vec{daughter->getMomentum()};
    ROOT::Math::XYZVector pvec(vec[0], vec[1], vec[2]);
    auto theta{pvec.Theta() * (180 / 3.14159)};
 
    if (hardest_ke < ke) {
      hardest_ke = ke;
      hardest_theta = theta;
    }
 
    if (pdg_id == 2112) {
      neutron_multiplicity++;
      total_neutron_ke += ke;
      if (hardest_n_ke < ke) {
        hardest_n_ke = ke;
        hardest_n_theta = theta;
      }
    } else if (pdg_id == 2212) {
      proton_multiplicity++;
      if (hardest_p_ke < ke) {
        hardest_p_ke = ke;
        hardest_p_theta = theta;
      }
    } else if (std::abs(pdg_id) == 211) {
      charged_pion_multiplicity++;
    } else if (pdg_id == 111) {
      neutral_pion_multiplicity++;
      if (hardest_pi0_ke < ke) {
        hardest_pi0_ke = ke;
        hardest_pi0_theta = theta;
      }
    }
  }
 
  // Leading-particle-type histogram:
  // bins: 0=pi±+X, 1=pi0+X, 2=K±+X, 3=KS/KL+X, 4=p+X, 5=n+X, 6=other+X
  if (!daughters.empty()) {
    auto leading_pdg{std::abs(daughters[0]->getPdgID())};
    int leading_type{6};
    if (leading_pdg == 211)
      leading_type = 0;
    else if (leading_pdg == 111)
      leading_type = 1;
    else if (leading_pdg == 321)
      leading_type = 2;
    else if (leading_pdg == 130 || leading_pdg == 310)
      leading_type = 3;
    else if (leading_pdg == 2212)
      leading_type = 4;
    else if (leading_pdg == 2112)
      leading_type = 5;
    histograms_.fill("leading_particle_type", leading_type);
  }
 
  histograms_.fill("hardest_ke", hardest_ke);
  histograms_.fill("hardest_theta", hardest_theta);
  histograms_.fill("h_ke_h_theta", hardest_ke, hardest_theta);
  histograms_.fill("hardest_n_ke", hardest_n_ke);
  histograms_.fill("hardest_n_theta", hardest_n_theta);
  histograms_.fill("hardest_p_ke", hardest_p_ke);
  histograms_.fill("hardest_p_theta", hardest_p_theta);
  histograms_.fill("hardest_pi0_ke", hardest_pi0_ke);
  histograms_.fill("hardest_pi0_theta", hardest_pi0_theta);
  histograms_.fill(prefix + "_neutron_mult", neutron_multiplicity);
  histograms_.fill(prefix + "_proton_mult", proton_multiplicity);
  histograms_.fill(prefix + "_charged_pion_mult", charged_pion_multiplicity);
  histograms_.fill(prefix + "_neutral_pion_mult", neutral_pion_multiplicity);
  histograms_.fill(prefix + "_total_ke", total_ke);
  histograms_.fill(prefix + "_total_neutron_ke", total_neutron_ke);
}

findParticleKinematics()

void dqm::NuclearDQM::findParticleKinematics ( const std::vector< const ldmx::SimParticle * > & daughters, const std::string & prefix )

protected

Fill kinematic histograms for the nuclear interaction products.

Generic (no-prefix) histograms filled: hardest_ke, hardest_theta, h_ke_h_theta, hardest_p_ke, hardest_p_theta, hardest_n_ke, hardest_n_theta, hardest_pi_ke, hardest_pi_theta, (charged pions only) hardest_pi0_ke, hardest_pi0_theta (neutral pions separately)

Prefixed histograms filled (using prefix, e.g. "pn" or "en"): {prefix}_neutron_mult, {prefix}_proton_mult, {prefix}_charged_pion_mult, {prefix}_neutral_pion_mult, {prefix}_total_ke, {prefix}_total_neutron_ke

Definition at line 48 of file NuclearDQM.cxx.

                             {
  double hardest_ke{-1}, hardest_theta{-1};
  double hardest_proton_ke{-1}, hardest_proton_theta{-1};
  double hardest_neutron_ke{-1}, hardest_neutron_theta{-1};
  double hardest_pion_ke{-1}, hardest_pion_theta{-1};
  double total_ke{0};
  double total_neutron_ke{0};
  int neutron_multiplicity{0};
 
  for (const auto* daughter : daughters) {
    auto pdg_id{daughter->getPdgID()};
    double ke{daughter->getEnergy() - daughter->getMass()};
    total_ke += ke;
 
    std::vector<double> vec{daughter->getMomentum()};
    ROOT::Math::XYZVector pvec(vec[0], vec[1], vec[2]);
    auto theta{pvec.Theta() * (180 / 3.14159)};
 
    if (hardest_ke < ke) {
      hardest_ke = ke;
      hardest_theta = theta;
    }
 
    if (pdg_id == 2112) {
      total_neutron_ke += ke;
      neutron_multiplicity++;
      if (hardest_neutron_ke < ke) {
        hardest_neutron_ke = ke;
        hardest_neutron_theta = theta;
      }
    }
 
    if (pdg_id == 2212 && hardest_proton_ke < ke) {
      hardest_proton_ke = ke;
      hardest_proton_theta = theta;
    }
 
    // charged and neutral pions grouped together, matching original PN logic
    if ((std::abs(pdg_id) == 211 || pdg_id == 111) && hardest_pion_ke < ke) {
      hardest_pion_ke = ke;
      hardest_pion_theta = theta;
    }
  }
 
  histograms_.fill("hardest_ke", hardest_ke);
  histograms_.fill("hardest_theta", hardest_theta);
  histograms_.fill("h_ke_h_theta", hardest_ke, hardest_theta);
  histograms_.fill("hardest_p_ke", hardest_proton_ke);
  histograms_.fill("hardest_p_theta", hardest_proton_theta);
  histograms_.fill("hardest_n_ke", hardest_neutron_ke);
  histograms_.fill("hardest_n_theta", hardest_neutron_theta);
  histograms_.fill("hardest_pi_ke", hardest_pion_ke);
  histograms_.fill("hardest_pi_theta", hardest_pion_theta);
 
  histograms_.fill(prefix + "_neutron_mult", neutron_multiplicity);
  histograms_.fill(prefix + "_total_ke", total_ke);
  histograms_.fill(prefix + "_total_neutron_ke", total_neutron_ke);
}

findSubleadingKinematics()

void dqm::NuclearDQM::findSubleadingKinematics ( const ldmx::SimParticle * initiator, const std::vector< const ldmx::SimParticle * > & daughters, EventType eventType )

protected

Fill subleading-kinematics histograms for 1n, 2n, charged-kaon and neutral-kaon event types.

Assumes daughters are sorted by KE descending.

initiator is the particle that underwent the nuclear reaction (pn gamma or en electron); its energy is the reference for fractions.

Definition at line 201 of file NuclearDQM.cxx.

                         {
  // Note: assumes daughters is sorted by kinetic energy descending
 
  double subleading_ke{-9999};
  double n_energy{-9999}, energy_diff{-9999}, energy_frac{-9999};
 
  n_energy = daughters[0]->getEnergy() - daughters[0]->getMass();
  if (daughters.size() > 1) {
    subleading_ke = daughters[1]->getEnergy() - daughters[1]->getMass();
  }
  energy_diff = initiator->getEnergy() - n_energy;
  energy_frac = n_energy / initiator->getEnergy();
 
  if (eventType == EventType::single_neutron) {
    histograms_.fill("1n_ke:2nd_h_ke", n_energy, subleading_ke);
    histograms_.fill("1n_neutron_energy", n_energy);
    histograms_.fill("1n_energy_diff", energy_diff);
    histograms_.fill("1n_energy_frac", energy_frac);
  } else if (eventType == EventType::two_neutrons) {
    histograms_.fill("2n_n2_energy", subleading_ke);
    auto energy_frac2n = (n_energy + subleading_ke) / initiator->getEnergy();
    histograms_.fill("2n_energy_frac", energy_frac2n);
    histograms_.fill("2n_energy_other", initiator->getEnergy() - energy_frac2n);
  } else if (eventType == EventType::charged_kaon) {
    histograms_.fill("1kp_ke:2nd_h_ke", n_energy, subleading_ke);
    histograms_.fill("1kp_energy", n_energy);
    histograms_.fill("1kp_energy_diff", energy_diff);
    histograms_.fill("1kp_energy_frac", energy_frac);
  } else if (eventType == EventType::klong || eventType == EventType::kshort) {
    histograms_.fill("1k0_ke:2nd_h_ke", n_energy, subleading_ke);
    histograms_.fill("1k0_energy", n_energy);
    histograms_.fill("1k0_energy_diff", energy_diff);
    histograms_.fill("1k0_energy_frac", energy_frac);
  }
}

References ldmx::SimParticle::getEnergy().

isLightIon()

bool dqm::NuclearDQM::isLightIon ( int pdgCode ) const

inlineconstexprprotected

Return true if pdgCode is a light ion (Z <= 4).

Nuclear PDG code convention: +-10LZZZAAAI

Definition at line 156 of file NuclearDQM.h.

                                               {
    if (pdgCode > 1000000000) {
      return ((pdgCode / 10) % 1000) <= 4;
    }
    return false;
  }

Member Data Documentation

count_light_ions_

bool dqm::NuclearDQM::count_light_ions_ {true}

protected

Definition at line 165 of file NuclearDQM.h.

{true};

sim_particles_coll_name_

std::string dqm::NuclearDQM::sim_particles_coll_name_

protected

Definition at line 163 of file NuclearDQM.h.

sim_particles_passname_

std::string dqm::NuclearDQM::sim_particles_passname_

protected

Definition at line 164 of file NuclearDQM.h.

---

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

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