tracking::reco::VertexProcessor Class Reference

Public Member Functions
	VertexProcessor (const std::string &name, framework::Process &process)
	Constructor.
virtual	~VertexProcessor ()=default
	Destructor.
void	onProcessStart () override
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
void	onProcessEnd () override
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
void	configure (framework::config::Parameters &parameters) override
	Configure the processor using the given user specified parameters.
void	produce (framework::Event &event) override
	Run the processor.
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.
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
Acts::GeometryContext	gctx_
	The contexts - TODO: they should move to some global location, I guess.
Acts::MagneticFieldContext	bctx_
int	nevents_ {0}
std::shared_ptr< InterpolatedMagneticField3 >	sp_interpolated_b_field_
std::string	field_map_ {""}
	Path to the magnetic field map.
std::string	trk_coll_name_ {"Tracks"}
std::string	seeds_coll_name_ {"RecoilTruthSeeds"}
std::string	input_pass_name_ {""}
std::shared_ptr< VoidPropagator >	propagator_
double	processing_time_ {0.}
TH1F *	h_m_
TH1F *	h_m_truth_filter_
TH1F *	h_m_truth_

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

Definition at line 47 of file VertexProcessor.h.

Constructor & Destructor Documentation

VertexProcessor()

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

Constructor.

Parameters

name	The name of the instance of this object.
process	The process running this producer.

Definition at line 12 of file VertexProcessor.cxx.

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

Member Function Documentation

configure()

void tracking::reco::VertexProcessor::configure ( framework::config::Parameters & parameters )

overridevirtual

Configure the processor using the given user specified parameters.

Parameters

parameters

Set of parameters used to configure this processor.

Reimplemented from framework::EventProcessor.

Definition at line 43 of file VertexProcessor.cxx.

                                                                     {
  // TODO:: the bfield map should be taken automatically
  field_map_ = parameters.get<std::string>("field_map");
 
  trk_coll_name_ = parameters.get<std::string>("trk_coll_name", "Tracks");
 
  seeds_coll_name_ =
      parameters.get<std::string>("seeds_coll_name", "RecoilTruthSeeds");
 
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
}

References field_map_, and framework::config::Parameters::get().

onProcessEnd()

void tracking::reco::VertexProcessor::onProcessEnd ( )

overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Reimplemented from framework::EventProcessor.

Definition at line 195 of file VertexProcessor.cxx.

                                   {
  TFile *outfile = new TFile("VertexingResults.root", "RECREATE");
  outfile->cd();
 
  h_m_->Write();
  h_m_truth_->Write();
  h_m_truth_filter_->Write();
  outfile->Close();
  delete outfile;
 
  ldmx_log(info) << "AVG Time/Event: " << std::fixed << std::setprecision(3)
                 << processing_time_ / nevents_ << " ms";
}

onProcessStart()

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

                                     {
  gctx_ = Acts::GeometryContext();
  bctx_ = Acts::MagneticFieldContext();
 
  h_m_ = new TH1F("m", "m", 100, 0., 1.);
  h_m_truth_filter_ = new TH1F("m_filter", "m", 100, 0., 1.);
  h_m_truth_ = new TH1F("m_truth", "m_truth", 100, 0., 1.);
 
  /*
   * this is unused, should it be? FIXME
  auto localToGlobalBin_xyz = [](std::array<size_t, 3> bins,
                                 std::array<size_t, 3> sizes) {
    return (bins[0] * (sizes[1] * sizes[2]) + bins[1] * sizes[2] +
            bins[2]);  // xyz - field space
    // return (bins[1] * (sizes[2] * sizes[0]) + bins[2] * sizes[0] + bins[0]);
    // //zxy
  };
  */
 
  // Setup a interpolated bfield map
  sp_interpolated_b_field_ =
      std::make_shared<InterpolatedMagneticField3>(loadDefaultBField(
          field_map_, defaultTransformPos, defaultTransformBField));
 
  ldmx_log(info) << "Check if nullptr::" << sp_interpolated_b_field_.get();
}

References field_map_, and gctx_.

produce()

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

overridevirtual

Run the processor.

Parameters

event

The event to process.

Implements framework::Producer.

Definition at line 55 of file VertexProcessor.cxx.

                                                   {
  // TODO:: Move this to an external file
  // And move all this to a single time per processor not for each event!!
 
  nevents_++;
  auto start = std::chrono::high_resolution_clock::now();
  auto &&stepper = Acts::EigenStepper<>{sp_interpolated_b_field_};
 
  // Set up propagator with void navigator
  propagator_ = std::make_shared<VoidPropagator>(stepper);
 
  // Track linearizer in the proximity of the vertex location
  using Linearizer = Acts::HelicalTrackLinearizer;
  Linearizer::Config linearizer_config;
  linearizer_config.bField = sp_interpolated_b_field_;
  linearizer_config.propagator = propagator_;
  Linearizer linearizer(linearizer_config);
 
  // Set up Billoir Vertex Fitter
  using VertexFitter = Acts::FullBilloirVertexFitter;
 
  VertexFitter::Config vertex_fitter_cfg;
 
  VertexFitter billoir_fitter(vertex_fitter_cfg);
 
  //  VertexFitter::State state(sp_interpolated_bField_->makeCache(bctx_));
 
  // Unconstrained fit
  // See
  // https://github.com/acts-project/acts/blob/main/Tests/UnitTests/Core/Vertexing/FullBilloirVertexFitterTests.cpp#L149
  // For constraint implementation
 
  Acts::VertexingOptions vf_options(gctx_, bctx_);
 
  // Retrieve the track collection
  const std::vector<ldmx::Track> tracks =
      event.getCollection<ldmx::Track>(trk_coll_name_, input_pass_name_);
 
  // Retrieve the truth seeds
  const std::vector<ldmx::Track> seeds =
      event.getCollection<ldmx::Track>(seeds_coll_name_, input_pass_name_);
 
  if (tracks.size() < 1) return;
 
  // Transform the EDM ldmx::tracks to the format needed by ACTS
  std::vector<Acts::BoundTrackParameters> billoir_tracks;
 
  // TODO:: The perigee surface should be common between all tracks.
  // So should only be created once in principle.
  // There should be no perigeeSurface2
 
  std::shared_ptr<Acts::PerigeeSurface> perigee_surface =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
          tracks.front().getPerigeeX(), tracks.front().getPerigeeY(),
          tracks.front().getPerigeeZ()));
 
  for (unsigned int i_track = 0; i_track < tracks.size(); i_track++) {
    Acts::BoundVector param_vec;
    param_vec << tracks.at(i_track).getD0(), tracks.at(i_track).getZ0(),
        tracks.at(i_track).getPhi(), tracks.at(i_track).getTheta(),
        tracks.at(i_track).getQoP(), tracks.at(i_track).getT();
 
    Acts::BoundSquareMatrix cov_mat =
        tracking::sim::utils::unpackCov(tracks.at(i_track).getPerigeeCov());
    auto part{Acts::GenericParticleHypothesis(Acts::ParticleHypothesis(
        Acts::PdgParticle(tracks.at(i_track).getPdgID())))};
    billoir_tracks.push_back(Acts::BoundTrackParameters(
        perigee_surface, param_vec, std::move(cov_mat), part));
  }
 
  // Select exactly 2 tracks
  if (billoir_tracks.size() != 2) {
    return;
  }
 
  if (billoir_tracks.at(0).charge() * billoir_tracks.at(1).charge() > 0) return;
 
  // Pion mass hypothesis
  double pion_mass = 139.570 * Acts::UnitConstants::MeV;
 
  TLorentzVector p1, p2;
  p1.SetXYZM(billoir_tracks.at(0).momentum()(0),
             billoir_tracks.at(0).momentum()(1),
             billoir_tracks.at(0).momentum()(2), pion_mass);
 
  p2.SetXYZM(billoir_tracks.at(1).momentum()(0),
             billoir_tracks.at(1).momentum()(1),
             billoir_tracks.at(1).momentum()(2), pion_mass);
 
  std::vector<TLorentzVector> pion_seeds;
 
  if (seeds.size() == 2) {
    for (int i_seed = 0; i_seed < seeds.size(); i_seed++) {
      std::shared_ptr<Acts::PerigeeSurface> perigee_surface2 =
          Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
              seeds.at(i_seed).getPerigeeX(), seeds.at(i_seed).getPerigeeY(),
              seeds.at(i_seed).getPerigeeZ()));
 
      Acts::BoundVector param_vec;
      param_vec << seeds.at(i_seed).getD0(), seeds.at(i_seed).getZ0(),
          seeds.at(i_seed).getPhi(), seeds.at(i_seed).getTheta(),
          seeds.at(i_seed).getQoP(), seeds.at(i_seed).getT();
 
      Acts::BoundSquareMatrix cov_mat =
          tracking::sim::utils::unpackCov(seeds.at(i_seed).getPerigeeCov());
      int pion_pdg_id = 211;  // pi+
      if (seeds.at(i_seed).q() < 0) pion_pdg_id = -211;
      // BoundTrackParameters needs the particle hypothesis
      auto part{Acts::GenericParticleHypothesis(
          Acts::ParticleHypothesis(Acts::PdgParticle(pion_pdg_id)))};
      auto bound_seed_params = Acts::BoundTrackParameters(
          perigee_surface, param_vec, std::move(cov_mat), part);
 
      TLorentzVector pion4v;
      pion4v.SetXYZM(bound_seed_params.momentum()(0),
                     bound_seed_params.momentum()(1),
                     bound_seed_params.momentum()(2), pion_mass);
 
      pion_seeds.push_back(pion4v);
    }  // loops on seeds
 
    h_m_truth_->Fill((pion_seeds.at(0) + pion_seeds.at(1)).M());
  }
 
  if ((pion_seeds.size() == 2) &&
      (pion_seeds.at(0) + pion_seeds.at(1)).M() > 0.490 &&
      (pion_seeds.at(0) + pion_seeds.at(1)).M() < 0.510) {
    // Check if the tracks have opposite charge
    h_m_truth_filter_->Fill((p1 + p2).M());
  }
 
  h_m_->Fill((p1 + p2).M());
 
  auto end = std::chrono::high_resolution_clock::now();
  // long long microseconds =
  // std::chrono::duration_cast<std::chrono::microseconds>(end-start).count();
  auto diff = end - start;
  processing_time_ += std::chrono::duration<double, std::milli>(diff).count();
}

References gctx_.

Member Data Documentation

bctx_

Acts::MagneticFieldContext tracking::reco::VertexProcessor::bctx_

private

Definition at line 81 of file VertexProcessor.h.

field_map_

std::string tracking::reco::VertexProcessor::field_map_ {""}

private

Path to the magnetic field map.

Definition at line 90 of file VertexProcessor.h.

{""};

Referenced by configure(), and onProcessStart().

gctx_

Acts::GeometryContext tracking::reco::VertexProcessor::gctx_

private

The contexts - TODO: they should move to some global location, I guess.

Definition at line 80 of file VertexProcessor.h.

Referenced by onProcessStart(), and produce().

h_m_

TH1F* tracking::reco::VertexProcessor::h_m_

private

Definition at line 106 of file VertexProcessor.h.

h_m_truth_

TH1F* tracking::reco::VertexProcessor::h_m_truth_

private

Definition at line 108 of file VertexProcessor.h.

h_m_truth_filter_

TH1F* tracking::reco::VertexProcessor::h_m_truth_filter_

private

Definition at line 107 of file VertexProcessor.h.

input_pass_name_

std::string tracking::reco::VertexProcessor::input_pass_name_ {""}

private

Definition at line 98 of file VertexProcessor.h.

{""};

nevents_

int tracking::reco::VertexProcessor::nevents_ {0}

private

Definition at line 84 of file VertexProcessor.h.

{0};

processing_time_

double tracking::reco::VertexProcessor::processing_time_ {0.}

private

Definition at line 104 of file VertexProcessor.h.

{0.};

propagator_

std::shared_ptr<VoidPropagator> tracking::reco::VertexProcessor::propagator_

private

Definition at line 101 of file VertexProcessor.h.

seeds_coll_name_

std::string tracking::reco::VertexProcessor::seeds_coll_name_ {"RecoilTruthSeeds"}

private

Definition at line 96 of file VertexProcessor.h.

{"RecoilTruthSeeds"};

sp_interpolated_b_field_

std::shared_ptr<InterpolatedMagneticField3> tracking::reco::VertexProcessor::sp_interpolated_b_field_

private

Definition at line 87 of file VertexProcessor.h.

trk_coll_name_

std::string tracking::reco::VertexProcessor::trk_coll_name_ {"Tracks"}

private

Definition at line 94 of file VertexProcessor.h.

{"Tracks"};

---

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

• Tracking/include/Tracking/Reco/VertexProcessor.h
• Tracking/src/Tracking/Reco/VertexProcessor.cxx