dqm::EcalTrackAnalyzer Class Reference

DQM analyzer for ECAL tracks fitted with ACTS zero-B field CKF. More...

#include <EcalTrackAnalyzer.h>

Public Member Functions
	EcalTrackAnalyzer (const std::string &name, framework::Process &process)
	Constructor.
	~EcalTrackAnalyzer () override=default
	Destructor.
void	configure (framework::config::Parameters &ps) override
	Configure the analyzer.
void	analyze (const framework::Event &event) override
	Analyze the event.
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	track_collection_ {"EcalTracks"}
	ECAL track collection name.
std::string	track_pass_name_ {""}
	Pass name for tracks.
std::string	rec_hit_collection_ {"EcalRecHits"}
	ECAL RecHit collection (for layer occupancy)
std::string	rec_hit_pass_name_ {""}
	Pass name for RecHits.

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 ECAL tracks fitted with ACTS zero-B field CKF.

Creates histograms of track properties:

• Track multiplicity
• Number of hits per track
• Chi2 and NDF distributions
• Track parameters (d0, z0, phi, theta, p)
• Hit occupancy by layer

Definition at line 30 of file EcalTrackAnalyzer.h.

Constructor & Destructor Documentation

EcalTrackAnalyzer()

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

inline

Constructor.

Definition at line 35 of file EcalTrackAnalyzer.h.

      : Analyzer(name, process) {}

Member Function Documentation

analyze()

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

overridevirtual

Analyze the event.

Implements framework::Analyzer.

Definition at line 19 of file EcalTrackAnalyzer.cxx.

                                                           {
  // Check if track collection exists
  if (!event.exists(track_collection_, track_pass_name_)) {
    ldmx_log(debug) << "ECAL track collection does not exist";
    return;
  }
 
  // Get ECAL tracks
  const auto& ecal_tracks =
      event.getCollection<ldmx::Track>(track_collection_, track_pass_name_);
 
  int n_tracks = ecal_tracks.size();
  histograms_.fill("n_tracks", n_tracks);
 
  if (n_tracks == 0) {
    return;
  }
 
  // Loop over tracks
  for (size_t i_track = 0; i_track < ecal_tracks.size(); ++i_track) {
    const auto& track = ecal_tracks[i_track];
 
    // Track quality
    double chi2 = track.getChi2();
    int ndf = track.getNdf();
    int nhits = track.getNhits();
 
    histograms_.fill("track_chi2", chi2);
    histograms_.fill("track_ndf", ndf);
    histograms_.fill("track_nhits", nhits);
 
    if (ndf > 0) {
      histograms_.fill("track_chi2_ndf", chi2 / ndf);
    }
 
    // Track parameters
    double d0 = track.getD0();
    double z0 = track.getZ0();
    double phi = track.getPhi();
    double theta = track.getTheta();
    double qop = track.getQoP();
    int charge = track.getCharge();
 
    histograms_.fill("track_d0", d0);
    histograms_.fill("track_z0", z0);
    histograms_.fill("track_phi", phi);
    histograms_.fill("track_theta", theta);
    histograms_.fill("track_qop", qop);
    histograms_.fill("track_charge", charge);
 
    // Momentum
    double p = 0;
    if (std::abs(qop) > 1e-9) {
      p = 1.0 / std::abs(qop);
    }
    histograms_.fill("track_p", p);
 
    // Momentum components (approximate from angles and magnitude)
    double px = p * std::sin(theta) * std::cos(phi);
    double py = p * std::sin(theta) * std::sin(phi);
    double pz = p * std::cos(theta);
 
    double pt = std::sqrt(px * px + py * py);
    histograms_.fill("track_px", px);
    histograms_.fill("track_py", py);
    histograms_.fill("track_pz", pz);
    histograms_.fill("track_pt", pt);
 
    // Position at ECAL front (from d0, z0)
    // d0 and z0 are in the perigee frame
    double x = -d0 * std::sin(phi);  // Approximate x position
    double y = d0 * std::cos(phi);   // Approximate y position
 
    histograms_.fill("track_x", x);
    histograms_.fill("track_y", y);
    histograms_.fill("track_xy", x, y);
 
    // 2D correlations
    histograms_.fill("track_nhits_vs_chi2", nhits, chi2);
    histograms_.fill("track_nhits_vs_chi2_ndf", nhits, (ndf > 0) ? chi2 / ndf : 0.0);
    histograms_.fill("track_chi2_vs_nhits", chi2, nhits);
    histograms_.fill("track_p_vs_chi2", p, chi2);
    histograms_.fill("track_p_vs_nhits", p, nhits);
    histograms_.fill("track_p_vs_theta", p, theta);
 
    // If multiple tracks, fill special histograms
    if (n_tracks > 1) {
      histograms_.fill("track_p_multitracks", p);
 
      // Calculate angular separation between tracks
      for (size_t j_track = i_track + 1; j_track < ecal_tracks.size();
           ++j_track) {
        const auto& other_track = ecal_tracks[j_track];
 
        double phi1 = track.getPhi();
        double theta1 = track.getTheta();
        double phi2 = other_track.getPhi();
        double theta2 = other_track.getTheta();
 
        // Direction vectors
        double dx1 = std::sin(theta1) * std::cos(phi1);
        double dy1 = std::sin(theta1) * std::sin(phi1);
        double dz1 = std::cos(theta1);
 
        double dx2 = std::sin(theta2) * std::cos(phi2);
        double dy2 = std::sin(theta2) * std::sin(phi2);
        double dz2 = std::cos(theta2);
 
        // Dot product
        double dot = dx1 * dx2 + dy1 * dy2 + dz1 * dz2;
        double angle = std::acos(std::max(-1.0, std::min(1.0, dot)));
 
        histograms_.fill("track_separation", angle);
      }
    }
  }
 
  ldmx_log(debug) << "Analyzed " << n_tracks << " ECAL tracks";
}

References framework::Event::exists(), framework::HistogramPool::fill(), framework::EventProcessor::histograms_, track_collection_, and track_pass_name_.

configure()

void dqm::EcalTrackAnalyzer::configure ( framework::config::Parameters & ps )

overridevirtual

Configure the analyzer.

Reimplemented from framework::EventProcessor.

Definition at line 12 of file EcalTrackAnalyzer.cxx.

                                                               {
  track_collection_ = ps.get<std::string>("track_collection");
  track_pass_name_ = ps.get<std::string>("track_pass_name");
  rec_hit_collection_ = ps.get<std::string>("rec_hit_collection");
  rec_hit_pass_name_ = ps.get<std::string>("rec_hit_pass_name");
}

References framework::config::Parameters::get(), rec_hit_collection_, rec_hit_pass_name_, track_collection_, and track_pass_name_.

Member Data Documentation

rec_hit_collection_

std::string dqm::EcalTrackAnalyzer::rec_hit_collection_ {"EcalRecHits"}

private

ECAL RecHit collection (for layer occupancy)

Definition at line 61 of file EcalTrackAnalyzer.h.

{"EcalRecHits"};

Referenced by configure().

rec_hit_pass_name_

std::string dqm::EcalTrackAnalyzer::rec_hit_pass_name_ {""}

private

Pass name for RecHits.

Definition at line 64 of file EcalTrackAnalyzer.h.

{""};

Referenced by configure().

track_collection_

std::string dqm::EcalTrackAnalyzer::track_collection_ {"EcalTracks"}

private

ECAL track collection name.

Definition at line 55 of file EcalTrackAnalyzer.h.

{"EcalTracks"};

Referenced by analyze(), and configure().

track_pass_name_

std::string dqm::EcalTrackAnalyzer::track_pass_name_ {""}

private

Pass name for tracks.

Definition at line 58 of file EcalTrackAnalyzer.h.

{""};

Referenced by analyze(), and configure().

---

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

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