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	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	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
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.
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_bField_
std::string	field_map_ {""}
	Path to the magnetic field map.
std::string	trk_coll_name_ {"Tracks"}
std::string	input_pass_name_ {""}
std::shared_ptr< VoidPropagator >	propagator_
double	processing_time_ {0.}
TH1F *	h_m_
TH1F *	h_m_truthFilter_
TH1F *	h_m_truth_

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 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 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.getParameter<std::string>("field_map");
 
  trk_coll_name_ =
      parameters.getParameter<std::string>("trk_coll_name", "Tracks");
 
  input_pass_name_ =
      parameters.getParameter<std::string>("input_pass_name", "");
}

References field_map_.

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 194 of file VertexProcessor.cxx.

                                   {
  TFile *outfile = new TFile("VertexingResults.root", "RECREATE");
  outfile->cd();
 
  h_m_->Write();
  h_m_truth_->Write();
  h_m_truthFilter_->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_truthFilter_ = 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_bField_ =
      std::make_shared<InterpolatedMagneticField3>(loadDefaultBField(
          field_map_, default_transformPos, default_transformBField));
 
  ldmx_log(info) << "Check if nullptr::" << sp_interpolated_bField_.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 54 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_bField_};
 
  // 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 linearizerConfig;
  linearizerConfig.bField = sp_interpolated_bField_;
  linearizerConfig.propagator = propagator_;
  Linearizer linearizer(linearizerConfig);
 
  // Set up Billoir Vertex Fitter
  using VertexFitter = Acts::FullBilloirVertexFitter;
 
  VertexFitter::Config vertexFitterCfg;
 
  VertexFitter billoirFitter(vertexFitterCfg);
 
  //  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 vfOptions(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>("RecoilTruthSeeds", 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> perigeeSurface =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
          tracks.front().getPerigeeX(), tracks.front().getPerigeeY(),
          tracks.front().getPerigeeZ()));
 
  for (unsigned int iTrack = 0; iTrack < tracks.size(); iTrack++) {
    Acts::BoundVector paramVec;
    paramVec << tracks.at(iTrack).getD0(), tracks.at(iTrack).getZ0(),
        tracks.at(iTrack).getPhi(), tracks.at(iTrack).getTheta(),
        tracks.at(iTrack).getQoP(), tracks.at(iTrack).getT();
 
    Acts::BoundSquareMatrix covMat =
        tracking::sim::utils::unpackCov(tracks.at(iTrack).getPerigeeCov());
    auto part{Acts::GenericParticleHypothesis(Acts::ParticleHypothesis(
        Acts::PdgParticle(tracks.at(iTrack).getPdgID())))};
    billoir_tracks.push_back(Acts::BoundTrackParameters(
        perigeeSurface, paramVec, std::move(covMat), 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 iSeed = 0; iSeed < seeds.size(); iSeed++) {
      std::shared_ptr<Acts::PerigeeSurface> perigeeSurface2 =
          Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
              seeds.at(iSeed).getPerigeeX(), seeds.at(iSeed).getPerigeeY(),
              seeds.at(iSeed).getPerigeeZ()));
 
      Acts::BoundVector paramVec;
      paramVec << seeds.at(iSeed).getD0(), seeds.at(iSeed).getZ0(),
          seeds.at(iSeed).getPhi(), seeds.at(iSeed).getTheta(),
          seeds.at(iSeed).getQoP(), seeds.at(iSeed).getT();
 
      Acts::BoundSquareMatrix covMat =
          tracking::sim::utils::unpackCov(seeds.at(iSeed).getPerigeeCov());
      int pionPdgId = 211;  // pi+
      if (seeds.at(iSeed).q() < 0) pionPdgId = -211;
      // BoundTrackParameters needs the particle hypothesis
      auto part{Acts::GenericParticleHypothesis(
          Acts::ParticleHypothesis(Acts::PdgParticle(pionPdgId)))};
      auto boundSeedParams = Acts::BoundTrackParameters(
          perigeeSurface, paramVec, std::move(covMat), part);
 
      TLorentzVector pion4v;
      pion4v.SetXYZM(boundSeedParams.momentum()(0),
                     boundSeedParams.momentum()(1),
                     boundSeedParams.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_truthFilter_->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 104 of file VertexProcessor.h.

h_m_truth_

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

private

Definition at line 106 of file VertexProcessor.h.

h_m_truthFilter_

TH1F* tracking::reco::VertexProcessor::h_m_truthFilter_

private

Definition at line 105 of file VertexProcessor.h.

input_pass_name_

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

private

Definition at line 96 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 102 of file VertexProcessor.h.

{0.};

propagator_

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

private

Definition at line 99 of file VertexProcessor.h.

sp_interpolated_bField_

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

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