dqm::PhotoNuclearDQM Class Reference

Public Member Functions
	PhotoNuclearDQM (const std::string &name, framework::Process &process)
	Constructor.
virtual	~PhotoNuclearDQM ()=default
	Destructor.
void	configure (framework::config::Parameters &parameters) override
	Configure this analyzer using the user specified parameters.
void	analyze (const framework::Event &event) override
	Process the event and create the histogram summaries.
void	setHistLabels (const std::string &name, const std::vector< std::string > &labels)
	Helper function to label categorical histos.
void	onProcessStart () override
	Method executed before processing of events begins.
constexpr bool	isLightIon (const int pdgCode) const
	Check if the PDG code corresponds to a light ion.
Public Member Functions inherited from framework::Analyzer
	Analyzer (const std::string &name, Process &process)
	Class constructor.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
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.

Public Attributes
bool	count_light_ions_

Private Types
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 }

Private Member Functions
EventType	classifyEvent (const std::vector< const ldmx::SimParticle * > daughters, double threshold)
	Method used to classify events.
CompactEventType	classifyCompactEvent (const ldmx::SimParticle *pnGamma, const std::vector< const ldmx::SimParticle * > daughters, double threshold)
	Method used to classify events in a compact manner.
void	findRecoilProperties (const ldmx::SimParticle *recoil)
	Fill the recoil electron-histograms.
std::vector< const ldmx::SimParticle * >	findDaughters (const std::map< int, ldmx::SimParticle > &particleMap, const ldmx::SimParticle *parent) const
	Find all daughter particles of a parent.
void	findParticleKinematics (const std::vector< const ldmx::SimParticle * > &pnDaughters)
	Fill histograms related to kinematics of PN products.
void	findSubleadingKinematics (const ldmx::SimParticle *pnGamma, const std::vector< const ldmx::SimParticle * > &pnDaughters, const EventType eventType)
	Fill histograms related to the kinematics and subleading particles for 1n, kaon, and 2n type events.

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Analyzer
static const int	CLASSTYPE {2}
	Constant used to track EventProcessor types by the PluginFactory.
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

Definition at line 22 of file PhotoNuclearDQM.h.

Member Enumeration Documentation

CompactEventType

enum class dqm::PhotoNuclearDQM::CompactEventType

strongprivate

Definition at line 24 of file PhotoNuclearDQM.h.

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

EventType

enum class dqm::PhotoNuclearDQM::EventType

strongprivate

Definition at line 32 of file PhotoNuclearDQM.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

PhotoNuclearDQM()

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

Constructor.

Definition at line 6 of file PhotoNuclearDQM.cxx.

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

Member Function Documentation

analyze()

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

overridevirtual

Process the event and create the histogram summaries.

Parameters

event

The event to analyze.

Implements framework::Analyzer.

Definition at line 224 of file PhotoNuclearDQM.cxx.

                                                         {
  // Get the particle map from the event.  If the particle map is empty,
  // don't process the event.
  auto particleMap{event.getMap<int, ldmx::SimParticle>("SimParticles")};
  if (particleMap.size() == 0) {
    return;
  }
 
  // Get the recoil electron
  auto [trackID, recoil] = Analysis::getRecoil(particleMap);
  findRecoilProperties(recoil);
 
  // Use the recoil electron to retrieve the gamma that underwent a
  // photo-nuclear reaction.
  auto pnGamma{Analysis::getPNGamma(particleMap, recoil, 2500.)};
  if (pnGamma == nullptr) {
    ldmx_log(warn) << "PN Daughter is lost, skipping";
    return;
  }
 
  const auto pnDaughters{findDaughters(particleMap, pnGamma)};
 
  if (!pnDaughters.empty()) {
    auto pn_vertex_volume{pnDaughters[0]->getVertexVolume()};
    auto pn_interaction_material{pnDaughters[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("G4_Si") != std::string::npos) {
      histograms_.fill("pn_interaction_material", 2);
    } else if (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("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(pnDaughters);
 
  histograms_.fill("pn_particle_mult", pnGamma->getDaughters().size());
  histograms_.fill("pn_gamma_energy", pnGamma->getEnergy());
  histograms_.fill("pn_gamma_int_x", pnGamma->getEndPoint()[0]);
  histograms_.fill("pn_gamma_int_y", pnGamma->getEndPoint()[1]);
  histograms_.fill("pn_gamma_int_x:pn_gamma_int_y", pnGamma->getEndPoint()[0],
                   pnGamma->getEndPoint()[1]);
  histograms_.fill("pn_gamma_int_z", pnGamma->getEndPoint()[2]);
  histograms_.fill("pn_gamma_vertex_x", pnGamma->getVertex()[0]);
  histograms_.fill("pn_gamma_vertex_y", pnGamma->getVertex()[1]);
  histograms_.fill("pn_gamma_vertex_z", pnGamma->getVertex()[2]);
 
  // Classify the event
  auto eventType{classifyEvent(pnDaughters, 200)};
  auto eventType500MeV{classifyEvent(pnDaughters, 500)};
  auto eventType2000MeV{classifyEvent(pnDaughters, 2000)};
 
  auto eventTypeComp{classifyCompactEvent(pnGamma, pnDaughters, 200)};
  auto eventTypeComp500MeV{classifyCompactEvent(pnGamma, pnDaughters, 500)};
  auto eventTypeComp2000MeV{classifyCompactEvent(pnGamma, pnDaughters, 2000)};
 
  histograms_.fill("event_type", static_cast<int>(eventType));
  histograms_.fill("event_type_500mev", static_cast<int>(eventType500MeV));
  histograms_.fill("event_type_2000mev", static_cast<int>(eventType2000MeV));
 
  histograms_.fill("event_type_compact", static_cast<int>(eventTypeComp));
  histograms_.fill("event_type_compact_500mev",
                   static_cast<int>(eventTypeComp500MeV));
  histograms_.fill("event_type_compact_2000mev",
                   static_cast<int>(eventTypeComp2000MeV));
 
  switch (eventType) {
    case EventType::single_neutron:
      if (pnDaughters.size() > 1) {
        auto secondHardestPdgID{abs(pnDaughters[1]->getPdgID())};
        auto nEventType{-10};
        if (secondHardestPdgID == 2112) {
          nEventType = 0;  // n + n
        } else if (secondHardestPdgID == 2212) {
          nEventType = 1;  // p + n
        } else if (secondHardestPdgID == 211) {
          nEventType = 2;  // Pi+/- + n
        } else if (secondHardestPdgID == 111) {
          nEventType = 3;  // Pi0 + n
        } else {
          nEventType = 4;  // other
        }
        histograms_.fill("1n_event_type", nEventType);
      }
      [[fallthrough]];  // Remaining code is important for 1n as well
    case EventType::two_neutrons:
    case EventType::charged_kaon:
    case EventType::klong:
    case EventType::kshort:
      findSubleadingKinematics(pnGamma, pnDaughters, eventType);
      break;
    default:  // Nothing to do
      break;
  }
}

References classifyCompactEvent(), classifyEvent(), framework::HistogramHelper::fill(), findDaughters(), findParticleKinematics(), findRecoilProperties(), findSubleadingKinematics(), and framework::EventProcessor::histograms_.

classifyCompactEvent()

PhotoNuclearDQM::CompactEventType dqm::PhotoNuclearDQM::classifyCompactEvent ( const ldmx::SimParticle * pnGamma, const std::vector< const ldmx::SimParticle * > daughters, double threshold )

private

Method used to classify events in a compact manner.

Definition at line 481 of file PhotoNuclearDQM.cxx.

                                                                          {
  short n{0}, n_t{0}, k0l{0}, kp{0}, k0s{0}, soft{0};
 
  // Loop through all of the PN daughters and extract kinematic
  // information.
  for (const auto &daughter : daughters) {
    // Calculate the kinetic energy
    auto ke{daughter->getEnergy() - daughter->getMass()};
 
    // Get the PDG ID
    auto pdgID{abs(daughter->getPdgID())};
 
    if (ke < 500) {
      soft++;
      continue;
    }
 
    if (ke >= 0.8 * pnGamma->getEnergy()) {
      if (pdgID == 2112) {
        n++;
      } else if (pdgID == 130) {
        k0l++;
      } else if (pdgID == 321) {
        kp++;
      } else if (pdgID == 310) {
        k0s++;
      }
      continue;
    }
 
    if ((pdgID == 2112) && ke > threshold) {
      n_t++;
    }
  }
 
  int neutral_kaons{k0l + k0s};
 
  if (n != 0) {
    return PhotoNuclearDQM::CompactEventType::single_neutron;
  }
  if (kp != 0) {
    return PhotoNuclearDQM::CompactEventType::single_charged_kaon;
  }
  if (neutral_kaons != 0) {
    return PhotoNuclearDQM::CompactEventType::single_neutral_kaon;
  }
  if (n_t == 2) {
    return PhotoNuclearDQM::CompactEventType::two_neutrons;
  }
  if (soft == daughters.size()) {
    return PhotoNuclearDQM::CompactEventType::soft;
  }
 
  return PhotoNuclearDQM::CompactEventType::other;
}

References ldmx::SimParticle::getEnergy().

Referenced by analyze().

classifyEvent()

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

private

Method used to classify events.

Note: Assumes that daughters is sorted by kinetic energy.

Definition at line 375 of file PhotoNuclearDQM.cxx.

                                                                          {
  short n{0}, p{0}, pi{0}, pi0{0}, exotic{0}, k0l{0}, kp{0}, k0s{0};
 
  // Loop through all of the PN daughters and extract kinematic
  // information.
  for (const auto &daughter : daughters) {
    // Calculate the kinetic energy
    auto ke{daughter->getEnergy() - daughter->getMass()};
 
    // Assuming the daughters are sorted by kinetic energy, if the kinetic
    // energy is below threshold, we don't need to look at any further
    // particles.
    if (ke <= threshold) {
      break;
    }
 
    // Get the PDG ID
    auto pdgID{abs(daughter->getPdgID())};
 
    if (pdgID == 2112) {
      n++;
    } else if (pdgID == 2212) {
      p++;
    } else if (pdgID == 211) {
      pi++;
    } else if (pdgID == 111) {
      pi0++;
    } else if (pdgID == 130) {
      k0l++;
    } else if (pdgID == 321) {
      kp++;
    } else if (pdgID == 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;
    } else if (p == 1) {
      return EventType::single_proton;
    } else if (pi0 == 1) {
      return EventType::single_neutral_pion;
    } else if (pi == 1) {
      return EventType::single_charged_pion;
    }
  }
  if (count == 2) {
    if (n == 2) {
      return EventType::two_neutrons;
    } else if (n == 1 && p == 1) {
      return EventType::proton_neutron;
    } else if (p == 2) {
      return EventType::two_protons;
    } else if (pi == 2) {
      return EventType::two_charged_pions;
    } else if (pi == 1 && nucleons == 1) {
      return EventType::single_charged_pion_and_nucleon;
    } else 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;
    } else if (pi == 2 && nucleons == 1) {
      return EventType::two_charged_pions_and_nucleon;
    }  // else
    else if (pi0 == 1 && nucleons == 2) {
      return EventType::single_neutral_pion_and_two_nucleons;
    } else 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;
    } else if (kp == 1) {
      return EventType::charged_kaon;
    } else if (k0s == 1) {
      return EventType::kshort;
    }
  }
  if (exotic == count && count != 0) {
    return EventType::exotics;
  }
 
  return EventType::multibody;
}

Referenced by analyze().

configure()

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

overridevirtual

Configure this analyzer using the user specified parameters.

Parameters

parameters

Set of parameters used to configure this analyzer.

Reimplemented from framework::EventProcessor.

Definition at line 220 of file PhotoNuclearDQM.cxx.

                                                                     {
  count_light_ions_ = parameters.getParameter<bool>("count_light_ions", true);
}

findDaughters()

std::vector< const ldmx::SimParticle * > dqm::PhotoNuclearDQM::findDaughters ( const std::map< int, ldmx::SimParticle > & particleMap, const ldmx::SimParticle * parent ) const

private

Find all daughter particles of a parent.

Particles are included if they>

• Are in the particle map,
• Are not photons or nuclear fragment, and
• Are not a light ion (Z < 4) if the count_light_ions_ parameter is set to false

The products are sorted by kinetic energy, in descending order.

Definition at line 10 of file PhotoNuclearDQM.cxx.

                                         {
  std::vector<const ldmx::SimParticle *> pnDaughters;
  for (const auto &daughterTrackID : parent->getDaughters()) {
    // skip daughters that weren't saved
    if (particleMap.count(daughterTrackID) == 0) {
      continue;
    }
 
    auto daughter{&(particleMap.at(daughterTrackID))};
 
    // Get the PDG ID
    auto pdgID{daughter->getPdgID()};
 
    // Ignore photons and nuclei
    if (pdgID == 22 ||
        (pdgID > 10000 && (!count_light_ions_ || !isLightIon(pdgID)))) {
      continue;
    }
    pnDaughters.push_back(daughter);
  }
 
  std::sort(pnDaughters.begin(), pnDaughters.end(),
            [](const auto &lhs, const auto &rhs) {
              double lhs_ke = lhs->getEnergy() - lhs->getMass();
              double rhs_ke = rhs->getEnergy() - rhs->getMass();
              return lhs_ke > rhs_ke;
            });
 
  return pnDaughters;
}

References ldmx::SimParticle::getDaughters(), and isLightIon().

Referenced by analyze().

findParticleKinematics()

void dqm::PhotoNuclearDQM::findParticleKinematics ( const std::vector< const ldmx::SimParticle * > & pnDaughters )

private

Fill histograms related to kinematics of PN products.

Definition at line 49 of file PhotoNuclearDQM.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};
  // Loop through all of the PN daughters and extract kinematic
  // information.
  for (const auto *daughter : pnDaughters) {
    // skip daughters that weren't saved
 
    // Get the PDG ID
    auto pdgID{daughter->getPdgID()};
 
    // Calculate the kinetic energy
    double ke{daughter->getEnergy() - daughter->getMass()};
    total_ke += ke;
 
    std::vector<double> vec{daughter->getMomentum()};
    TVector3 pvec(vec[0], vec[1], vec[2]);
 
    //  Calculate the polar angle
    auto theta{pvec.Theta() * (180 / 3.14159)};
 
    if (hardest_ke < ke) {
      hardest_ke = ke;
      hardest_theta = theta;
    }
 
    if (pdgID == 2112) {
      total_neutron_ke += ke;
      neutron_multiplicity++;
      if (hardest_neutron_ke < ke) {
        hardest_neutron_ke = ke;
        hardest_neutron_theta = theta;
      }
    }
 
    if ((pdgID == 2212) && (hardest_proton_ke < ke)) {
      hardest_proton_ke = ke;
      hardest_proton_theta = theta;
    }
 
    if (((std::abs(pdgID) == 211) || (pdgID == 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("pn_neutron_mult", neutron_multiplicity);
  histograms_.fill("pn_total_ke", total_ke);
  histograms_.fill("pn_total_neutron_ke", total_neutron_ke);
}

References framework::HistogramHelper::fill(), and framework::EventProcessor::histograms_.

Referenced by analyze().

findRecoilProperties()

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

private

Fill the recoil electron-histograms.

Definition at line 42 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 framework::HistogramHelper::fill(), ldmx::SimParticle::getVertex(), and framework::EventProcessor::histograms_.

Referenced by analyze().

findSubleadingKinematics()

void dqm::PhotoNuclearDQM::findSubleadingKinematics ( const ldmx::SimParticle * pnGamma, const std::vector< const ldmx::SimParticle * > & pnDaughters, const EventType eventType )

private

Fill histograms related to the kinematics and subleading particles for 1n, kaon, and 2n type events.

Note: This assumes that the daughter particles are sorted by energy.

Definition at line 116 of file PhotoNuclearDQM.cxx.

                                              {
  // Note: Assumes sorted by energy
 
  double subleading_ke{-9999};
  double nEnergy{-9999}, energyDiff{-9999}, energyFrac{-9999};
 
  nEnergy = pnDaughters[0]->getEnergy() - pnDaughters[0]->getMass();
  subleading_ke = -9999;
  if (pnDaughters.size() > 1) {
    subleading_ke = pnDaughters[1]->getEnergy() - pnDaughters[1]->getMass();
  }
  energyDiff = pnGamma->getEnergy() - nEnergy;
  energyFrac = nEnergy / pnGamma->getEnergy();
 
  if (eventType == EventType::single_neutron) {
    histograms_.fill("1n_ke:2nd_h_ke", nEnergy, subleading_ke);
    histograms_.fill("1n_neutron_energy", nEnergy);
    histograms_.fill("1n_energy_diff", energyDiff);
    histograms_.fill("1n_energy_frac", energyFrac);
  } else if (eventType == EventType::two_neutrons) {
    histograms_.fill("2n_n2_energy", subleading_ke);
    auto energyFrac2n = (nEnergy + subleading_ke) / pnGamma->getEnergy();
    histograms_.fill("2n_energy_frac", energyFrac2n);
    histograms_.fill("2n_energy_other", pnGamma->getEnergy() - energyFrac2n);
 
  } else if (eventType == EventType::charged_kaon) {
    histograms_.fill("1kp_ke:2nd_h_ke", nEnergy, subleading_ke);
    histograms_.fill("1kp_energy", nEnergy);
    histograms_.fill("1kp_energy_diff", energyDiff);
    histograms_.fill("1kp_energy_frac", energyFrac);
  } else if (eventType == EventType::klong || eventType == EventType::kshort) {
    histograms_.fill("1k0_ke:2nd_h_ke", nEnergy, subleading_ke);
    histograms_.fill("1k0_energy", nEnergy);
    histograms_.fill("1k0_energy_diff", energyDiff);
    histograms_.fill("1k0_energy_frac", energyFrac);
  }
}

References framework::HistogramHelper::fill(), ldmx::SimParticle::getEnergy(), and framework::EventProcessor::histograms_.

Referenced by analyze().

isLightIon()

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

inlineconstexpr

Check if the PDG code corresponds to a light ion.

Nuclear PDG codes are given by ±10LZZZAAAI So to find the atomic number, we first divide by 10 (to lose the I-component) and then take the modulo with 1000.

TODO: Repeated code from SimCore, could probably live elsewhere.

Definition at line 149 of file PhotoNuclearDQM.h.

                                                     {
    if (pdgCode > 1000000000) {
      // Check if the atomic number is less than or equal to 4
      return ((pdgCode / 10) % 1000) <= 4;
    }
    return false;
  }

Referenced by findDaughters().

onProcessStart()

void dqm::PhotoNuclearDQM::onProcessStart ( )

overridevirtual

Method executed before processing of events begins.

Reimplemented from framework::EventProcessor.

Definition at line 165 of file PhotoNuclearDQM.cxx.

                                     {
  std::vector<std::string> labels = {"",
                                     "Nothing hard",   // 0
                                     "1 n",            // 1
                                     "2 n",            // 2
                                     "#geq 3 n",       // 3
                                     "1 #pi",          // 4
                                     "2 #pi",          // 5
                                     "1 #pi_{0}",      // 6
                                     "1 #pi A",        // 7
                                     "1 #pi 2 A",      // 8
                                     "2 #pi A",        // 9
                                     "1 #pi_{0} A",    // 10
                                     "1 #pi_{0} 2 A",  // 11
                                     "#pi_{0} #pi A",  // 12
                                     "1 p",            // 13
                                     "2 p",            // 14
                                     "pn",             // 15
                                     "K^{0}_{L} X",    // 16
                                     "K X",            // 17
                                     "K^{0}_{S} X",    // 18
                                     "exotics",        // 19
                                     "multi-body",     // 20
                                     ""};
 
  setHistLabels("event_type", labels);
  setHistLabels("event_type_500mev", labels);
  setHistLabels("event_type_2000mev", labels);
 
  labels = {"",
            "1 n",      // 0
            "K#pm X",   // 1
            "1 K^{0}",  // 2
            "2 n",      // 3
            "Soft",     // 4
            "Other",    // 5
            ""};
 
  setHistLabels("event_type_compact", labels);
  setHistLabels("event_type_compact_500mev", labels);
  setHistLabels("event_type_compact_2000mev", labels);
 
  setHistLabels("1n_event_type", {"nn", "pn", "#pi^{+}n", "#pi^{0}n", "other"});
 
  setHistLabels(
      "pn_vertex_volume",
      {"Didn't happen", "Else", "W Cooling", "C Cooling", "PCB",
       "CarbonBasePlate", "Absorber", "Sensor", "Glue", "Motherboard"});
 
  setHistLabels("pn_interaction_material",
                {"Didn't happen", "Else", "Si", "W", "FR4", "Steel", "Epoxy",
                 "PVT", "Glue", "Air"});
 
}  // end of onProcessStart

References setHistLabels().

setHistLabels()

void dqm::PhotoNuclearDQM::setHistLabels	(	const std::string &	name,
		const std::vector< std::string > &	labels )

Helper function to label categorical histos.

Parameters

name	: Name of the histo for the labels to set
labels	: Labels on the X axis

Definition at line 157 of file PhotoNuclearDQM.cxx.

                                                                        {
  auto histo{histograms_.get(name)};
  for (std::size_t ibin{1}; ibin <= labels.size(); ibin++) {
    histo->GetXaxis()->SetBinLabel(ibin, labels[ibin - 1].c_str());
  }
}

References framework::HistogramHelper::get(), and framework::EventProcessor::histograms_.

Referenced by onProcessStart().

Member Data Documentation

count_light_ions_

bool dqm::PhotoNuclearDQM::count_light_ions_

Definition at line 157 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