Public Member Functions
	DigitizationProcessor (const std::string &name, framework::Process &process)

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

void	configure (framework::config::Parameters &parameters) override
	Callback for the EventProcessor to configure itself from the given set of parameters.

void	onNewRun (const ldmx::RunHeader &header) override
	Before the run starts (but after the conditions are configured) set up the random seeds for this run.

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

std::vector< ldmx::Measurement >	digitizeHits (const std::vector< ldmx::SimTrackerHit > &sim_hits)
	Does basic digitization of SimTrackerHits.

bool	mergeSimHits (const std::vector< ldmx::SimTrackerHit > &sim_hits, std::vector< ldmx::SimTrackerHit > &merged_hits)

bool	mergeHits (const std::vector< ldmx::SimTrackerHit > &sihits, std::vector< ldmx::SimTrackerHit > &mergedHits)

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	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	hit_collection_
	The path to the GDML description of the detector Input hit collection to smear.

std::string	out_collection_
	Output hit collection name.

double	min_e_dep_
	Minimum energy deposition cut.

int	track_id_
	Select a particular track ID.

bool	merge_hits_ {false}
	Merge the sim hits before digitizing.

bool	do_smearing_ {true}
	Flag to enable/disable smearing.

double	sigma_u_ {0}
	u-direction sigma

double	sigma_v_ {0}
	v-direction sigma

std::string	tracker_hit_passname_
	Pass Name.

std::default_random_engine	generator_

std::shared_ptr< std::normal_distribution< float > >	normal_

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 ()

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

Definition at line 28 of file DigitizationProcessor.h.

Constructor & Destructor Documentation

◆ DigitizationProcessor()

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

Definition at line 11 of file DigitizationProcessor.cxx.

13 : 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::DigitizationProcessor::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 className equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 19 of file DigitizationProcessor.cxx.

                                           {
  hit_collection_ =
      parameters.get<std::string>("hit_collection", "TaggerSimHits");
 
  tracker_hit_passname_ = parameters.get<std::string>("tracker_hit_passname");
  out_collection_ =
      parameters.get<std::string>("out_collection", "OutputMeasuements");
  min_e_dep_ = parameters.get<double>("min_e_dep", 0.05);
  track_id_ = parameters.get<int>("track_id", -1);
  do_smearing_ = parameters.get<bool>("do_smearing", true);
  sigma_u_ = parameters.get<double>("sigma_u", 0.01);
  sigma_v_ = parameters.get<double>("sigma_v", 0.);
  merge_hits_ = parameters.get<bool>("merge_hits", false);
}

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

◆ digitizeHits()

std::vector< ldmx::Measurement > tracking::reco::DigitizationProcessor::digitizeHits ( const std::vector< ldmx::SimTrackerHit > & sim_hits )

Does basic digitization of SimTrackerHits.

For now, this simply uses the global coordinates (SimTrackerHit position) and hit surface to extract the local coordinates. If specified, the local coordinates are smeared and the global coordinates are updated.

Parameters

sim_hits The collection of SimTrackerHits to digitize.

Definition at line 172 of file DigitizationProcessor.cxx.

                                                  {
  ldmx_log(debug) << "Found: " << sim_hits.size() << " sim hits in the '"
                  << hit_collection_ << "' with passname '"
                  << tracker_hit_passname_ << "'";
 
  std::vector<ldmx::Measurement> measurements;
 
  // Loop over all SimTrackerHits and
  // * Use the position of the SimTrackerHit (global position) and the surface
  //   the hit was created on to extract the local coordinates.
  // * If specified, smear the local coordinates and update the global
  //   coordinates.
  // * Create a Measurement object.
  for (auto& sim_hit : sim_hits) {
    // Remove low energy deposit hits
    if (sim_hit.getEdep() > min_e_dep_) {
      if (track_id_ > 0 && sim_hit.getTrackID() != track_id_) continue;
 
      ldmx::Measurement measurement(sim_hit);
 
      // Get the layer_ ID.
      auto layer_id = tracking::sim::utils::getSensorID(sim_hit);
      measurement.setLayerID(layer_id);
 
      // Get the surface
      auto hit_surface{geometry().getSurface(layer_id)};
 
      if (hit_surface) {
        // Transform from global to local coordinates.
        // hit_surface->toStream(geometry_context(), std::cout);
        ldmx_log(trace)
            << "Local to global\n"
            << hit_surface->transform(geometryContext()).rotation() << "\n"
            << hit_surface->transform(geometryContext()).translation();
 
        Acts::Vector3 dummy_momentum;
        Acts::Vector2 local_pos;
        // TODO: where is 0.320 mm coming from?
        double surface_thickness = 0.320 * Acts::UnitConstants::mm;
        Acts::Vector3 global_pos(measurement.getGlobalPosition()[0],
                                 measurement.getGlobalPosition()[1],
                                 measurement.getGlobalPosition()[2]);
 
        try {
          local_pos = hit_surface
                          ->globalToLocal(geometryContext(), global_pos,
                                          dummy_momentum, surface_thickness)
                          .value();
        } catch (const std::exception& e) {
          ldmx_log(warn) << "hit not on surface... Skipping.";
          continue;
        }
 
        // Smear the local position
        if (do_smearing_) {
          float smear_factor{(*normal_)(generator_)};
 
          local_pos[0] += smear_factor * sigma_u_;
          smear_factor = (*normal_)(generator_);
          local_pos[1] += smear_factor * sigma_v_;
 
          // update covariance
          measurement.setLocalCovariance(sigma_u_ * sigma_u_,
                                         sigma_v_ * sigma_v_);
 
          // transform to global
          auto transf_global_pos{hit_surface->localToGlobal(
              geometryContext(), local_pos, dummy_momentum)};
          measurement.setGlobalPosition(measurement.getGlobalPosition()[0],
                                        transf_global_pos(1),
                                        transf_global_pos(2));
 
        }  // do smearing
        measurement.setLocalPosition(local_pos(0), local_pos(1));
        measurements.push_back(measurement);
      }  // hit_surface exists
 
    }  // energy cut
  }  // loop on sim-hits
 
  return measurements;
 
}  // digitizeHits

References ldmx::Measurement::getGlobalPosition(), ldmx::Measurement::setGlobalPosition(), ldmx::Measurement::setLayerID(), ldmx::Measurement::setLocalCovariance(), and ldmx::Measurement::setLocalPosition().

◆ mergeHits()

bool tracking::reco::DigitizationProcessor::mergeHits	(	const std::vector< ldmx::SimTrackerHit > &	sihits,
		std::vector< ldmx::SimTrackerHit > &	mergedHits )

Definition at line 70 of file DigitizationProcessor.cxx.

                                              {
  if (sihits.size() < 1) return false;
 
  if (sihits.size() == 1) {
    mergedHits.push_back(sihits[0]);
    return true;
  }
 
  ldmx::SimTrackerHit merged_hit;
  // Since all the hits will be on the same sensor, just use the ID of the
  // first
  merged_hit.setLayerID(sihits[0].getLayerID());
  merged_hit.setModuleID(sihits[0].getModuleID());
  merged_hit.setID(sihits[0].getID());
  merged_hit.setTrackID(sihits[0].getTrackID());
 
  double x{0}, y{0}, z{0}, px{0}, py{0}, pz{0};
  double t{0}, e{0}, edep{0}, path{0};
  int pdg_id{0};
 
  pdg_id = sihits[0].getPdgID();
 
  for (auto hit : sihits) {
    double edep_hit = hit.getEdep();
    edep += edep_hit;
    e += hit.getEnergy();
    t += edep_hit * hit.getTime();
    x += edep_hit * hit.getPosition()[0];
    y += edep_hit * hit.getPosition()[1];
    z += edep_hit * hit.getPosition()[2];
    px += edep_hit * hit.getMomentum()[0];
    py += edep_hit * hit.getMomentum()[1];
    pz += edep_hit * hit.getMomentum()[2];
    path += edep_hit * hit.getPathLength();
 
    if (hit.getPdgID() != pdg_id) {
      ldmx_log(error)
          << "ERROR:: Found hits with compatible sensorID and track_id "
             "but different PDGID";
      ldmx_log(error) << "TRACKID ==" << hit.getTrackID() << " vs "
                      << sihits[0].getTrackID();
      ldmx_log(error) << "PDGID== " << hit.getPdgID() << " vs " << pdg_id;
      return false;
    }
  }
 
  merged_hit.setTime(t / edep);
  merged_hit.setPosition(x / edep, y / edep, z / edep);
  merged_hit.setMomentum(px / edep, py / edep, pz / edep);
  merged_hit.setPathLength(path / edep);
  merged_hit.setEnergy(e);
  merged_hit.setEdep(edep);
  merged_hit.setPdgID(pdg_id);
 
  mergedHits.push_back(merged_hit);
 
  return true;
}

◆ mergeSimHits()

bool tracking::reco::DigitizationProcessor::mergeSimHits	(	const std::vector< ldmx::SimTrackerHit > &	sim_hits,
		std::vector< ldmx::SimTrackerHit > &	merged_hits )

Definition at line 131 of file DigitizationProcessor.cxx.

                                               {
  // The first key is the index_ of the sensitive element ID, second key is the
  // track_id
  std::map<int, std::map<int, std::vector<ldmx::SimTrackerHit>>> hitmap;
 
  for (const auto& hit : sim_hits) {
    unsigned int index = tracking::sim::utils::getSensorID(hit);
    unsigned int trackid = hit.getTrackID();
    hitmap[index][trackid].push_back(hit);
 
    ldmx_log(trace) << "hitmap being filled, size::[" << index << "]["
                    << trackid << "] size " << hitmap[index][trackid].size();
  }
 
  typedef std::map<int,
                   std::map<int, std::vector<ldmx::SimTrackerHit>>>::iterator
      hitmap_it1;
  typedef std::map<int, std::vector<ldmx::SimTrackerHit>>::iterator hitmap_it2;
 
  for (hitmap_it1 it = hitmap.begin(); it != hitmap.end(); it++) {
    for (hitmap_it2 it2 = it->second.begin(); it2 != it->second.end(); it2++) {
      mergeHits(it2->second, merged_hits);
    }
  }
 
  ldmx_log(debug) << "Sim_hits Size = " << sim_hits.size()
                  << " Merged_hits Size = " << merged_hits.size();
 
  for (const auto& hit : sim_hits) {
    ldmx_log(trace) << hit;
  }
 
  for (const auto& mhit : merged_hits) {
    ldmx_log(trace) << mhit;
  }
 
  return true;
}

◆ onNewRun()

void tracking::reco::DigitizationProcessor::onNewRun ( const ldmx::RunHeader & header )

overridevirtual

Before the run starts (but after the conditions are configured) set up the random seeds for this run.

Parameters

[in] header RunHeader for this run, unused

Reimplemented from framework::EventProcessor.

Definition at line 35 of file DigitizationProcessor.cxx.

                                                                   {
  const auto& rseed = getCondition<framework::RandomNumberSeedService>(
      framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
  generator_.seed(rseed.getSeed("Tracking::DigitizationProcessor"));
}

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME.

◆ onProcessStart()

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

                                           {
  normal_ = std::make_shared<std::normal_distribution<float>>(0., 1.);
}

◆ produce()

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

                                                         {
  ldmx_log(trace) << " Getting the tracking geometry:" << geometry().getTG();
 
  // Mode 0: Load simulated hits and produce smeared 1d measurements
  // Mode 1: Load simulated hits and produce digitized 1d measurements
 
  const std::vector<ldmx::SimTrackerHit> sim_hits =
      event.getCollection<ldmx::SimTrackerHit>(hit_collection_,
                                               tracker_hit_passname_);
 
  std::vector<ldmx::SimTrackerHit> merged_hits;
 
  std::vector<ldmx::Measurement> measurements;
  if (merge_hits_) {
    mergeSimHits(sim_hits, merged_hits);
    measurements = digitizeHits(merged_hits);
  } else {
    measurements = digitizeHits(sim_hits);
  }
 
  event.add(out_collection_, measurements);
}

Member Data Documentation

◆ do_smearing_

bool tracking::reco::DigitizationProcessor::do_smearing_ {true}

private

Flag to enable/disable smearing.

Definition at line 78 of file DigitizationProcessor.h.

78{true};

◆ generator_

std::default_random_engine tracking::reco::DigitizationProcessor::generator_

private

Definition at line 88 of file DigitizationProcessor.h.

◆ hit_collection_

std::string tracking::reco::DigitizationProcessor::hit_collection_

private

The path to the GDML description of the detector Input hit collection to smear.

Definition at line 67 of file DigitizationProcessor.h.

◆ merge_hits_

bool tracking::reco::DigitizationProcessor::merge_hits_ {false}

private

Merge the sim hits before digitizing.

Definition at line 76 of file DigitizationProcessor.h.

76{false};

◆ min_e_dep_

double tracking::reco::DigitizationProcessor::min_e_dep_

private

Minimum energy deposition cut.

Definition at line 72 of file DigitizationProcessor.h.

◆ normal_

std::shared_ptr<std::normal_distribution<float> > tracking::reco::DigitizationProcessor::normal_

private

Definition at line 89 of file DigitizationProcessor.h.

◆ out_collection_

std::string tracking::reco::DigitizationProcessor::out_collection_

private

Output hit collection name.

Definition at line 69 of file DigitizationProcessor.h.

◆ sigma_u_

double tracking::reco::DigitizationProcessor::sigma_u_ {0}

private

u-direction sigma

Definition at line 80 of file DigitizationProcessor.h.

80{0};

◆ sigma_v_

double tracking::reco::DigitizationProcessor::sigma_v_ {0}

private

v-direction sigma

Definition at line 82 of file DigitizationProcessor.h.

82{0};

◆ track_id_

int tracking::reco::DigitizationProcessor::track_id_

private

Select a particular track ID.

Definition at line 74 of file DigitizationProcessor.h.

◆ tracker_hit_passname_

std::string tracking::reco::DigitizationProcessor::tracker_hit_passname_

private

Pass Name.

Definition at line 84 of file DigitizationProcessor.h.

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DigitizationProcessor()

Member Function Documentation

◆ configure()

◆ digitizeHits()

◆ mergeHits()

◆ mergeSimHits()

◆ onNewRun()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ do_smearing_

◆ generator_

◆ hit_collection_

◆ merge_hits_

◆ min_e_dep_

◆ normal_

◆ out_collection_

◆ sigma_u_

◆ sigma_v_

◆ track_id_

◆ tracker_hit_passname_