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	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.

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

virtual	~EventProcessor ()
	Class destructor.

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.

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::default_random_engine	generator_

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

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::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.

Protected Member Functions inherited from tracking::reco::TrackingGeometryUser
const Acts::GeometryContext &	geometry_context ()

const Acts::MagneticFieldContext &	magnetic_field_context ()

const Acts::CalibrationContext &	calibration_context ()

const geo::TrackersTrackingGeometry &	geometry ()

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 26 of file DigitizationProcessor.h.

Constructor & Destructor Documentation

◆ DigitizationProcessor()

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

Definition at line 16 of file DigitizationProcessor.cxx.

18 : TrackingGeometryUser(name, process) {}

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 25 of file DigitizationProcessor.cxx.

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

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

◆ 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 171 of file DigitizationProcessor.cxx.

                                                  {
  ldmx_log(debug) << "Found:" << sim_hits.size() << " sim hits in the "
                  << hit_collection_;
 
  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(debug)
            << "Local to global" << std::endl
            << hit_surface->transform(geometry_context()).rotation()
            << std::endl
            << hit_surface->transform(geometry_context()).translation();
 
        Acts::Vector3 dummy_momentum;
        Acts::Vector2 local_pos;
        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(geometry_context(), 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(
              geometry_context(), 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 75 of file DigitizationProcessor.cxx.

                                              {
  if (sihits.size() < 1) return false;
 
  if (sihits.size() == 1) {
    mergedHits.push_back(sihits[0]);
    return true;
  }
 
  ldmx::SimTrackerHit mergedHit;
  // Since all the hits will be on the same sensor, just use the ID of the first
  mergedHit.setLayerID(sihits[0].getLayerID());
  mergedHit.setModuleID(sihits[0].getModuleID());
  mergedHit.setID(sihits[0].getID());
  mergedHit.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 pdgID{0};
 
  pdgID = 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() != pdgID) {
      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 " << pdgID;
      return false;
    }
  }
 
  mergedHit.setTime(T / EDEP);
  mergedHit.setPosition(X / EDEP, Y / EDEP, Z / EDEP);
  mergedHit.setMomentum(PX / EDEP, PY / EDEP, PZ / EDEP);
  mergedHit.setPathLength(path / EDEP);
  mergedHit.setEnergy(E);
  mergedHit.setEdep(EDEP);
  mergedHit.setPdgID(pdgID);
 
  mergedHits.push_back(mergedHit);
 
  return true;
}

◆ mergeSimHits()

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

Definition at line 136 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 (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(debug) << "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 (auto hit : sim_hits) hit.Print();
  // for (auto mhit : merged_hits) mhit.Print();
 
  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 39 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 20 of file DigitizationProcessor.cxx.

                                           {
  normal_ = std::make_shared<std::normal_distribution<float>>(0., 1.);
  ldmx_log(info) << "Initialization done" << std::endl;
}

◆ 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 45 of file DigitizationProcessor.cxx.

                                                         {
  ldmx_log(debug) << " 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_);
 
  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 75 of file DigitizationProcessor.h.

75{true};

◆ generator_

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

private

Definition at line 83 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 65 of file DigitizationProcessor.h.

◆ merge_hits_

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

private

Merge the sim hits before digitizing.

Definition at line 73 of file DigitizationProcessor.h.

73{false};

◆ min_e_dep_

double tracking::reco::DigitizationProcessor::min_e_dep_

private

Minimum energy deposition cut.

Definition at line 69 of file DigitizationProcessor.h.

◆ normal_

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

private

Definition at line 84 of file DigitizationProcessor.h.

◆ out_collection_

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

private

Output hit collection name.

Definition at line 67 of file DigitizationProcessor.h.

◆ sigma_u_

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

private

u-direction sigma

Definition at line 77 of file DigitizationProcessor.h.

77{0};

◆ sigma_v_

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

private

v-direction sigma

Definition at line 79 of file DigitizationProcessor.h.

79{0};

◆ track_id_

int tracking::reco::DigitizationProcessor::track_id_

private

Select a particular track ID.

Definition at line 71 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_