tracking::dqm::DigiDQM Class Reference

DQM analyzer for silicon-strip digitization and clustering. More...

#include <DigiDQM.h>

Public Member Functions
	DigiDQM (const std::string &name, framework::Process &process)
void	configure (framework::config::Parameters &parameters) override
	Callback for the EventProcessor to configure itself from the given set of parameters.
void	analyze (const framework::Event &event) override
	Process the event and make histograms or summaries.
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 Attributes
std::string	sim_coll_name_ {"TaggerSimHits"}
std::string	sim_pass_name_ {""}
std::string	digi_coll_name_ {""}
std::string	digi_pass_name_ {""}
std::string	fitted_coll_name_ {"TaggerFittedSiStripHits"}
std::string	fitted_pass_name_ {""}
std::string	cluster_coll_name_ {"TaggerClusterMeasurements"}
std::string	cluster_pass_name_ {""}
int	n_sensors_ {14}

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
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

DQM analyzer for silicon-strip digitization and clustering.

Per-sensor histograms are produced for:

Sim hits (from SimTrackerHit collection) sim_n_sN — number of sim hits per event sim_edep_sN — energy deposition [MeV]

Fitted strips (from FittedSiStripHit collection) strip_n_sN — number of fitted strips per event strip_amp_sN — fitted amplitude [ADC counts] strip_t0_sN — fitted hit time [ns] strip_chi2ndf_sN — chi2/ndf of the pulse fit

Clusters (from StripClusterProcessor Measurement collection) cluster_n_sN — number of clusters per event cluster_u_sN — cluster centroid local U [mm] cluster_amp_sN — total cluster amplitude [ADC counts] cluster_nstrips_sN — number of strips per cluster cluster_time_sN — cluster hit time [ns] sim_cluster_du_sN — truth U minus cluster U [mm] (requires digi_coll_name)

Configuration parameters

sim_coll_name SimTrackerHit collection (default "TaggerSimHits") sim_pass_name pass name (default "") digi_coll_name digi Measurement coll. for truth_u lookup (default "" = disabled) digi_pass_name pass name (default "") fitted_coll_name FittedSiStripHit coll. (default "TaggerFittedSiStripHits") fitted_pass_name pass name (default "") cluster_coll_name cluster Measurement coll. (default "TaggerClusterMeasurements") cluster_pass_name pass name (default "") n_sensors number of sensors (default 14)

Definition at line 46 of file DigiDQM.h.

Constructor & Destructor Documentation

DigiDQM()

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

inline

Definition at line 48 of file DigiDQM.h.

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

Member Function Documentation

analyze()

void tracking::dqm::DigiDQM::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 29 of file DigiDQM.cxx.

                                                 {
  // -------------------------------------------------------------------------
  // Sim hits — one entry per hit
  // -------------------------------------------------------------------------
  if (event.exists(sim_coll_name_, sim_pass_name_)) {
    const auto sim_hits = event.getCollection<ldmx::SimTrackerHit>(
        sim_coll_name_, sim_pass_name_);
 
    // Count per sensor for the multiplicity histograms
    std::map<int, int> sim_count;  // layer → count
 
    for (const auto& hit : sim_hits) {
      // getSensorID maps the G4 layer/module IDs to the same compact index
      // that DigitizationProcessor stores in Measurement::layer_id_.
      int layer =
          ldmx::Measurement::layerIndex(tracking::sim::utils::getSensorID(hit));
      if (layer < 0 || layer >= n_sensors_) continue;
 
      const std::string s = std::to_string(layer);
      histograms_.fill("sim_edep_s" + s, hit.getEdep());
      sim_count[layer]++;
    }
 
    for (int i = 0; i < n_sensors_; ++i) {
      histograms_.fill("sim_n_s" + std::to_string(i),
                       static_cast<double>(sim_count[i]));
    }
  }
 
  // -------------------------------------------------------------------------
  // Fitted strips (from StripFitProcessor)
  // -------------------------------------------------------------------------
  if (event.exists(fitted_coll_name_, fitted_pass_name_)) {
    const auto fitted_hits = event.getCollection<ldmx::FittedSiStripHit>(
        fitted_coll_name_, fitted_pass_name_);
 
    std::map<int, int> strip_count;
 
    for (const auto& hit : fitted_hits) {
      // FittedSiStripHit::getLayerID() stores the same raw sensor index
      // as Measurement::layer_id_ (set by getSensorID in
      // DigitizationProcessor).
      int layer = ldmx::Measurement::layerIndex(hit.getLayerID());
      if (layer < 0 || layer >= n_sensors_) continue;
 
      const std::string s = std::to_string(layer);
      histograms_.fill("strip_amp_s" + s, hit.getAmplitude());
      histograms_.fill("strip_t0_s" + s, hit.getT0());
      if (hit.getNDF() > 0)
        histograms_.fill("strip_chi2ndf_s" + s, hit.getChi2() / hit.getNDF());
      strip_count[layer]++;
    }
 
    for (int i = 0; i < n_sensors_; ++i) {
      histograms_.fill("strip_n_s" + std::to_string(i),
                       static_cast<double>(strip_count[i]));
    }
  }
 
  // -------------------------------------------------------------------------
  // Build truth_u lookup from digi Measurements (optional).
  // layer → track_id → truth_u
  // -------------------------------------------------------------------------
  std::map<int, std::map<int, float>> truth_u_by_layer;
  if (!digi_coll_name_.empty() &&
      event.exists(digi_coll_name_, digi_pass_name_)) {
    const auto digi_meas = event.getCollection<ldmx::Measurement>(
        digi_coll_name_, digi_pass_name_);
    for (const auto& m : digi_meas) {
      int layer = m.getLayer();
      if (layer < 0 || layer >= n_sensors_) continue;
      if (std::isnan(m.getTruthU())) continue;
      int tid =
          m.getTrackIds().empty() ? -1 : static_cast<int>(m.getTrackIds()[0]);
      truth_u_by_layer[layer][tid] = m.getTruthU();
    }
  }
 
  // -------------------------------------------------------------------------
  // Cluster measurements (from StripClusterProcessor)
  // -------------------------------------------------------------------------
  if (event.exists(cluster_coll_name_, cluster_pass_name_)) {
    const auto cluster_meas = event.getCollection<ldmx::Measurement>(
        cluster_coll_name_, cluster_pass_name_);
 
    std::map<int, int> cluster_count;
 
    for (const auto& meas : cluster_meas) {
      int layer = meas.getLayer();
      if (layer < 0 || layer >= n_sensors_) continue;
 
      const std::string s = std::to_string(layer);
      const float u = meas.getLocalPosition()[0];
      histograms_.fill("cluster_u_s" + s, u);
      histograms_.fill("cluster_amp_s" + s, meas.getClusterAmplitude());
      histograms_.fill("cluster_time_s" + s, meas.getTime());
      if (meas.getNStrips() > 0)
        histograms_.fill("cluster_nstrips_s" + s, meas.getNStrips());
      cluster_count[layer]++;
 
      // sim_cluster_du: truth U (from digi Measurement) minus cluster U
      int tid = meas.getTrackIds().empty()
                    ? -1
                    : static_cast<int>(meas.getTrackIds()[0]);
      auto layer_it = truth_u_by_layer.find(layer);
      if (layer_it != truth_u_by_layer.end()) {
        auto tid_it = layer_it->second.find(tid);
        if (tid_it != layer_it->second.end())
          histograms_.fill("sim_cluster_du_s" + s, tid_it->second - u);
      }
    }
 
    for (int i = 0; i < n_sensors_; ++i) {
      histograms_.fill("cluster_n_s" + std::to_string(i),
                       static_cast<double>(cluster_count[i]));
    }
  }
}

References framework::Event::exists(), framework::HistogramPool::fill(), framework::EventProcessor::histograms_, and ldmx::Measurement::layerIndex().

configure()

void tracking::dqm::DigiDQM::configure ( framework::config::Parameters & parameters )

overridevirtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters

Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 14 of file DigiDQM.cxx.

                                                             {
  sim_coll_name_ =
      parameters.get<std::string>("sim_coll_name", "TaggerSimHits");
  sim_pass_name_ = parameters.get<std::string>("sim_pass_name", "");
  digi_coll_name_ = parameters.get<std::string>("digi_coll_name", "");
  digi_pass_name_ = parameters.get<std::string>("digi_pass_name", "");
  fitted_coll_name_ = parameters.get<std::string>("fitted_coll_name",
                                                  "TaggerFittedSiStripHits");
  fitted_pass_name_ = parameters.get<std::string>("fitted_pass_name", "");
  cluster_coll_name_ = parameters.get<std::string>("cluster_coll_name",
                                                   "TaggerClusterMeasurements");
  cluster_pass_name_ = parameters.get<std::string>("cluster_pass_name", "");
  n_sensors_ = parameters.get<int>("n_sensors", 14);
}

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

Member Data Documentation

cluster_coll_name_

std::string tracking::dqm::DigiDQM::cluster_coll_name_ {"TaggerClusterMeasurements"}

private

Definition at line 63 of file DigiDQM.h.

{"TaggerClusterMeasurements"};

cluster_pass_name_

std::string tracking::dqm::DigiDQM::cluster_pass_name_ {""}

private

Definition at line 64 of file DigiDQM.h.

{""};

digi_coll_name_

std::string tracking::dqm::DigiDQM::digi_coll_name_ {""}

private

Definition at line 59 of file DigiDQM.h.

{""};

digi_pass_name_

std::string tracking::dqm::DigiDQM::digi_pass_name_ {""}

private

Definition at line 60 of file DigiDQM.h.

{""};

fitted_coll_name_

std::string tracking::dqm::DigiDQM::fitted_coll_name_ {"TaggerFittedSiStripHits"}

private

Definition at line 61 of file DigiDQM.h.

{"TaggerFittedSiStripHits"};

fitted_pass_name_

std::string tracking::dqm::DigiDQM::fitted_pass_name_ {""}

private

Definition at line 62 of file DigiDQM.h.

{""};

n_sensors_

int tracking::dqm::DigiDQM::n_sensors_ {14}

private

Definition at line 65 of file DigiDQM.h.

{14};

sim_coll_name_

std::string tracking::dqm::DigiDQM::sim_coll_name_ {"TaggerSimHits"}

private

Definition at line 57 of file DigiDQM.h.

{"TaggerSimHits"};

sim_pass_name_

std::string tracking::dqm::DigiDQM::sim_pass_name_ {""}

private

Definition at line 58 of file DigiDQM.h.

{""};

---

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

• Tracking/include/Tracking/dqm/DigiDQM.h
• Tracking/src/Tracking/dqm/DigiDQM.cxx