Clusters fitted silicon-strip hits and produces Measurement objects. More...

#include <StripClusterProcessor.h>

Public Member Functions
	StripClusterProcessor (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	onProcessStart () override
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

void	produce (framework::Event &event) override
	Process the event and put new data products into it.

Public Member Functions inherited from tracking::reco::TrackingGeometryUser
	TrackingGeometryUser (const std::string &name, framework::Process &p)

Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.

virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.

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	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.

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	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	in_collection_ {"FittedSiStripHits"}

std::string	in_pass_ {""}

std::string	out_collection_ {"StripMeasurements"}

std::string	daq_map_file_ {""}

std::map< int, int >	layer_n_strips_
	layer_id -> n_strips (from DAQ map)

double	seed_threshold_ {4.0}

double	neighbor_threshold_ {3.0}

double	cluster_threshold_ {4.0}

double	mean_time_ns_ {0.0}

double	time_window_ns_ {-1.0}

double	neighbor_delta_t_ns_ {-1.0}

double	max_chi2_ndf_ {-1.0}

std::unique_ptr< tracking::digitization::StripClusterer >	clusterer_

Additional Inherited Members
Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
const Acts::GeometryContext &	geometryContext ()

const Acts::MagneticFieldContext &	magneticFieldContext ()

const Acts::CalibrationContext &	calibrationContext ()

const geo::TrackersTrackingGeometry &	geometry ()

void	loadBField (const std::string &path, const BFieldDistortion &distortion={})
	Load the interpolated B-field map from `path` and cache it.

void	loadBField (const BFieldDistortion &distortion={})
	Load B-field from the path recorded in the detector GDML.

std::shared_ptr< Acts::MagneticFieldProvider >	bField () const
	Return the loaded B-field provider.

Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Static Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
static BFieldDistortion	bFieldDistortion (const framework::config::Parameters &parameters)
	Build a BFieldDistortion from processor configuration.

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

Clusters fitted silicon-strip hits and produces Measurement objects.

Groups FittedSiStripHit objects by sensor layer, runs the nearest-neighbour clustering algorithm on each layer, then converts each accepted cluster into an ldmx::Measurement using the Acts tracking geometry for the local → global position transform.

This processor runs on both real data (after pulse fitting) and simulation.

Input : collection of ldmx::FittedSiStripHit Output : collection of ldmx::Measurement

Configuration parameters

in_collection FittedSiStripHit input collection (default "FittedSiStripHits"). in_pass Pass name for the input collection (default ""). out_collection Measurement output collection (default "StripMeasurements"). seed_threshold Minimum amplitude/noise to seed a cluster (default 4.0). neighbor_threshold Minimum amplitude/noise for a strip to join a cluster (default 3.0). cluster_threshold Minimum Σamp / √Σnoise² for cluster acceptance (default 4.0). mean_time_ns Expected hit time for seed timing cut [ns] (default 0.0). time_window_ns Half-width of seed timing window [ns]; ≤ 0 disables (default -1). neighbor_delta_t_ns Max |t0_nb − cluster_t| [ns] for a neighbour to join; ≤ 0 disables (default -1). max_chi2_ndf Max chi2/ndf for a hit to be clustered; ≤ 0 disables (default -1).

Detector geometry and noise (readout pitch, n_strips, noise_sigma_adc, sigma_v, etc.) are fixed constants from SiStripConstants.h and are not configurable.

Definition at line 49 of file StripClusterProcessor.h.

Constructor & Destructor Documentation

◆ StripClusterProcessor()

tracking::reco::StripClusterProcessor::StripClusterProcessor	(	const std::string &	name,
		framework::Process &	process )

Definition at line 15 of file StripClusterProcessor.cxx.

17 : TrackingGeometryUser(name, process) {}

framework::Producer::process

virtual void process(Event &event) final

Processing an event for a Producer is calling produce.

Definition EventProcessor.h:278

Member Function Documentation

◆ configure()

void tracking::reco::StripClusterProcessor::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 21 of file StripClusterProcessor.cxx.

                                           {
  in_collection_ =
      parameters.get<std::string>("in_collection", "FittedSiStripHits");
  in_pass_ = parameters.get<std::string>("in_pass", "");
  out_collection_ =
      parameters.get<std::string>("out_collection", "StripMeasurements");
 
  seed_threshold_ = parameters.get<double>("seed_threshold", 4.0);
  neighbor_threshold_ = parameters.get<double>("neighbor_threshold", 3.0);
  cluster_threshold_ = parameters.get<double>("cluster_threshold", 4.0);
  mean_time_ns_ = parameters.get<double>("mean_time_ns", 0.0);
  time_window_ns_ = parameters.get<double>("time_window_ns", -1.0);
  neighbor_delta_t_ns_ = parameters.get<double>("neighbor_delta_t_ns", -1.0);
  max_chi2_ndf_ = parameters.get<double>("max_chi2_ndf", -1.0);
  daq_map_file_ = parameters.get<std::string>("daq_map_file", "");
}

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

◆ onProcessStart()

void tracking::reco::StripClusterProcessor::onProcessStart ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

Reimplemented from framework::EventProcessor.

Definition at line 41 of file StripClusterProcessor.cxx.

                                           {
  using namespace tracking::digitization;
 
  clusterer_ = std::make_unique<tracking::digitization::StripClusterer>(
      seed_threshold_, neighbor_threshold_, cluster_threshold_, NOISE_SIGMA_ADC,
      mean_time_ns_, time_window_ns_, neighbor_delta_t_ns_, max_chi2_ndf_);
 
  // Optional DAQ map: build a layer_id -> n_strips lookup so the local-U centre
  // offset can use the real per-sensor strip count for real data.  Left empty
  // for MC, in which case the fixed N_READOUT_STRIPS constant is used below.
  layer_n_strips_.clear();
  if (!daq_map_file_.empty()) {
    const auto map = TrackerDaqMap::fromJsonFile(daq_map_file_);
    for (const auto& [key, sensor] : map.sensors()) {
      layer_n_strips_[sensor.layer_id_] = sensor.n_strips_;
    }
    ldmx_log(info) << "StripClusterProcessor loaded DAQ map from '"
                   << daq_map_file_ << "' (" << layer_n_strips_.size()
                   << " layers) for centre-strip offsets";
  }
 
  ldmx_log(info) << "StripClusterProcessor configured:" << "  seed_thr="
                 << seed_threshold_ << "  nbr_thr=" << neighbor_threshold_
                 << "  cls_thr=" << cluster_threshold_
                 << "  noise=" << NOISE_SIGMA_ADC << " ADC"
                 << "  pitch=" << READOUT_PITCH_MM << " mm"
                 << "  sigma_v=" << SIGMA_V_MM << " mm";
}

◆ produce()

void tracking::reco::StripClusterProcessor::produce ( framework::Event & event )

overridevirtual

Process the event and put new data products into it.

Parameters

event The Event to process.

Implements framework::Producer.

Definition at line 72 of file StripClusterProcessor.cxx.

                                                         {
  const auto& fitted_hits =
      event.getCollection<ldmx::FittedSiStripHit>(in_collection_, in_pass_);
 
  ldmx_log(debug) << "Clustering " << fitted_hits.size()
                  << " FittedSiStripHits";
 
  // -------------------------------------------------------------------------
  // Group fitted hits by layer.
  // -------------------------------------------------------------------------
  std::map<int, std::vector<ldmx::FittedSiStripHit>> hits_by_layer;
  for (const auto& h : fitted_hits) {
    hits_by_layer[h.getLayerID()].push_back(h);
  }
 
  // -------------------------------------------------------------------------
  // Cluster each layer and convert to Measurements.
  // -------------------------------------------------------------------------
  std::vector<ldmx::Measurement> measurements;
 
  for (const auto& [layer_id, layer_hits] : hits_by_layer) {
    auto hit_surface = geometry().getSurface(layer_id);
    if (!hit_surface) {
      ldmx_log(warn) << "No surface found for layer_id=" << layer_id
                     << " — skipping " << layer_hits.size() << " hits";
      continue;
    }
 
    // Build a strip-index → FittedSiStripHit map for truth lookup.
    std::map<int, const ldmx::FittedSiStripHit*> strip_hit_map;
    for (const auto& h : layer_hits) {
      strip_hit_map[h.getStripID()] = &h;
    }
 
    const auto clusters = clusterer_->findClusters(layer_hits);
    ldmx_log(debug) << "  layer " << layer_id << ": " << layer_hits.size()
                    << " hits → " << clusters.size() << " clusters";
 
    for (const auto& cl : clusters) {
      // -------------------------------------------------------------------
      // Local position: U from charge-weighted centroid, V unmeasured (= 0).
      // With AC-coupled transfer efficiencies, each readout strip r is anchored
      // at the position of its paired sense strip (position_in_group == 0),
      // which is at U = (r - N_int) * readout_pitch where N_int = N/2
      // (integer). For N=767: offset = 383, so readout 383 → U=0, 384 → U=60
      // µm, etc.
      // -------------------------------------------------------------------
      using namespace tracking::digitization;
      // Center-strip offset: N/2 (integer division).  For MC this is the fixed
      // N_READOUT_STRIPS constant; for real data, if a DAQ map was supplied,
      // use that sensor's real strip count so the local origin sits at its
      // centre.
      int n_strips = N_READOUT_STRIPS;
      auto it_ns = layer_n_strips_.find(layer_id);
      if (it_ns != layer_n_strips_.end()) n_strips = it_ns->second;
      const int n_int = n_strips / 2;
      const double offset = static_cast<double>(n_int);
      const double local_u = (cl.centroid_strip - offset) * READOUT_PITCH_MM;
 
      // Cluster-size-dependent position uncertainty using sense pitch (30 µm).
      // Divisors follow the HPS convention: 1/√12 for single-strip (binary
      // resolution), 1/5 for 2-strip (best charge-sharing), then degrading.
      double sigma_u;
      switch (cl.n_strips) {
        case 1:
          sigma_u = SENSE_PITCH_MM / std::sqrt(12.0);
          break;  // 8.7 µm
        case 2:
          sigma_u = SENSE_PITCH_MM / 5.0;
          break;  // 6.0 µm
        case 3:
          sigma_u = SENSE_PITCH_MM / 3.0;
          break;  // 10.0 µm
        case 4:
          sigma_u = SENSE_PITCH_MM / 2.0;
          break;  // 15.0 µm
        default:
          sigma_u = SENSE_PITCH_MM;
          break;  // 30.0 µm
      }
      constexpr double local_v = 0.0;
 
      // -------------------------------------------------------------------
      // Global position via Acts surface transform.
      // -------------------------------------------------------------------
      Acts::Vector3 dummy_momentum;
      const Acts::Vector3 global_pos = hit_surface->localToGlobal(
          geometryContext(), Acts::Vector2(local_u, local_v), dummy_momentum);
 
      // -------------------------------------------------------------------
      // Build the Measurement.
      // -------------------------------------------------------------------
      ldmx::Measurement meas;
      meas.setLayerID(layer_id);
      meas.setLocalPosition(static_cast<float>(local_u),
                            static_cast<float>(local_v));
      meas.setLocalCovariance(
          static_cast<float>(sigma_u * sigma_u),
          static_cast<float>(tracking::digitization::SIGMA_V_MM *
                             tracking::digitization::SIGMA_V_MM));
      meas.setGlobalPosition(static_cast<float>(global_pos[0]),
                             static_cast<float>(global_pos[1]),
                             static_cast<float>(global_pos[2]));
      meas.setTime(static_cast<float>(cl.time_ns));
      meas.setNStrips(cl.n_strips);
      meas.setClusterAmplitude(static_cast<float>(cl.total_amplitude));
 
      // -------------------------------------------------------------------
      // Reconstructed energy: convert total cluster amplitude to edep using
      // the fixed detector constants from SiStripConstants.h.
      //   edep = total_amplitude [ADC] × ADC_ELECTRONS_PER_COUNT [e/ADC]
      //                                × ENERGY_PER_EHP_MEV [MeV/e]
      // -------------------------------------------------------------------
      const float reco_edep = static_cast<float>(
          cl.total_amplitude * ADC_ELECTRONS_PER_COUNT * ENERGY_PER_EHP_MEV);
      meas.setEdep(reco_edep);
 
      // -------------------------------------------------------------------
      // Truth matching: collect unique track IDs from constituent strips.
      // -------------------------------------------------------------------
      std::unordered_set<int> seen_track_ids;
      for (const int strip : cl.strip_ids) {
        auto it = strip_hit_map.find(strip);
        if (it != strip_hit_map.end()) {
          const int tid = it->second->getTrackID();
          if (tid >= 0 && seen_track_ids.insert(tid).second) {
            meas.addTrackId(tid);
          }
        }
      }
 
      ldmx_log(trace) << "  cluster: layer=" << layer_id
                      << " strips=" << cl.n_strips << " u=" << local_u << " mm"
                      << " sigma_u=" << sigma_u << " mm" << " t=" << cl.time_ns
                      << " ns" << " amp=" << cl.total_amplitude << " ADC"
                      << " n_track_ids=" << seen_track_ids.size();
 
      measurements.push_back(meas);
    }
  }
 
  ldmx_log(debug) << "Produced " << measurements.size() << " Measurements";
  event.add(out_collection_, measurements);
}

References ldmx::Measurement::addTrackId(), ldmx::Measurement::setClusterAmplitude(), ldmx::Measurement::setEdep(), ldmx::Measurement::setGlobalPosition(), ldmx::Measurement::setLayerID(), ldmx::Measurement::setLocalCovariance(), ldmx::Measurement::setLocalPosition(), ldmx::Measurement::setNStrips(), and ldmx::Measurement::setTime().

Member Data Documentation

◆ cluster_threshold_

double tracking::reco::StripClusterProcessor::cluster_threshold_ {4.0}

private

Definition at line 74 of file StripClusterProcessor.h.

74{4.0};

◆ clusterer_

std::unique_ptr<tracking::digitization::StripClusterer> tracking::reco::StripClusterProcessor::clusterer_

private

Definition at line 80 of file StripClusterProcessor.h.

◆ daq_map_file_

std::string tracking::reco::StripClusterProcessor::daq_map_file_ {""}

private

Definition at line 68 of file StripClusterProcessor.h.

68{""};

◆ in_collection_

std::string tracking::reco::StripClusterProcessor::in_collection_ {"FittedSiStripHits"}

private

Definition at line 60 of file StripClusterProcessor.h.

60{"FittedSiStripHits"};

◆ in_pass_

std::string tracking::reco::StripClusterProcessor::in_pass_ {""}

private

Definition at line 61 of file StripClusterProcessor.h.

61{""};

◆ layer_n_strips_

std::map<int, int> tracking::reco::StripClusterProcessor::layer_n_strips_

private

layer_id -> n_strips (from DAQ map)

Definition at line 69 of file StripClusterProcessor.h.

◆ max_chi2_ndf_

double tracking::reco::StripClusterProcessor::max_chi2_ndf_ {-1.0}

private

Definition at line 78 of file StripClusterProcessor.h.

78{-1.0};

◆ mean_time_ns_

double tracking::reco::StripClusterProcessor::mean_time_ns_ {0.0}

private

Definition at line 75 of file StripClusterProcessor.h.

75{0.0};

◆ neighbor_delta_t_ns_

double tracking::reco::StripClusterProcessor::neighbor_delta_t_ns_ {-1.0}

private

Definition at line 77 of file StripClusterProcessor.h.

77{-1.0};

◆ neighbor_threshold_

double tracking::reco::StripClusterProcessor::neighbor_threshold_ {3.0}

private

Definition at line 73 of file StripClusterProcessor.h.

73{3.0};

◆ out_collection_

std::string tracking::reco::StripClusterProcessor::out_collection_ {"StripMeasurements"}

private

Definition at line 62 of file StripClusterProcessor.h.

62{"StripMeasurements"};

◆ seed_threshold_

double tracking::reco::StripClusterProcessor::seed_threshold_ {4.0}

private

Definition at line 72 of file StripClusterProcessor.h.

72{4.0};

◆ time_window_ns_

double tracking::reco::StripClusterProcessor::time_window_ns_ {-1.0}

private

Definition at line 76 of file StripClusterProcessor.h.

76{-1.0};

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

Tracking/include/Tracking/Reco/StripClusterProcessor.h
Tracking/src/Tracking/Reco/StripClusterProcessor.cxx

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Configuration parameters

Constructor & Destructor Documentation

◆ StripClusterProcessor()

Member Function Documentation

◆ configure()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ cluster_threshold_

◆ clusterer_

◆ daq_map_file_

◆ in_collection_

◆ in_pass_

◆ layer_n_strips_

◆ max_chi2_ndf_

◆ mean_time_ns_

◆ neighbor_delta_t_ns_

◆ neighbor_threshold_

◆ out_collection_

◆ seed_threshold_

◆ time_window_ns_