tracking::reco::Vertexer Class Reference

Public Member Functions
	Vertexer (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	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
	Callback for the EventProcessor to configure itself from the given set of parameters.
void	produce (framework::Event &event) override
	Process the event and put new data products into it.
void	taggerRecoilMonitoring (const std::vector< ldmx::Track > &tagger_tracks, const std::vector< ldmx::Track > &recoil_tracks)
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::MagneticFieldContext	bctx_
int	nevents_ {0}
int	nvertices_ {0}
int	nreconstructable_ {0}
std::shared_ptr< InterpolatedMagneticField3 >	sp_interpolated_b_field_
std::shared_ptr< Acts::ConstantBField >	b_field_
std::string	field_map_
	Path to the magnetic field map.
std::string	trk_c_name_1_ {"TaggerTracks"}
std::string	trk_c_name_2_ {"RecoilTracks"}
std::string	input_pass_name_ {""}
std::shared_ptr< VoidPropagator >	propagator_
TH1F *	h_delta_d0_
TH1F *	h_delta_z0_
TH1F *	h_delta_p_
TH1F *	h_delta_phi_
TH1F *	h_delta_theta_
TH2F *	h_delta_d0_vs_recoil_p_
TH2F *	h_delta_z0_vs_recoil_p_
TH2F *	h_td0_vs_rd0_
TH2F *	h_tz0_vs_rz0_

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 40 of file Vertexer.h.

Constructor & Destructor Documentation

Vertexer()

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

Definition at line 19 of file Vertexer.cxx.

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

Member Function Documentation

configure()

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

                                                              {
  // TODO:: the bfield map should be taken automatically
  field_map_ = parameters.get<std::string>("field_map");
 
  trk_c_name_1_ = parameters.get<std::string>("trk_c_name_1", "TaggerTracks");
  trk_c_name_2_ = parameters.get<std::string>("trk_c_name_2", "RecoilTracks");
  input_pass_name_ = parameters.get<std::string>("input_pass_name");
}

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

onProcessEnd()

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

                            {
  ldmx_log(info) << "Reconstructed " << nvertices_ << " vertices over "
                 << nreconstructable_ << " reconstructable" << std::endl;
 
  TFile* outfile = new TFile((getName() + ".root").c_str(), "RECREATE");
  outfile->cd();
 
  h_delta_d0_->Write();
  h_delta_z0_->Write();
  h_delta_p_->Write();
  h_delta_phi_->Write();
  h_delta_theta_->Write();
 
  h_delta_d0_vs_recoil_p_->Write();
  h_delta_z0_vs_recoil_p_->Write();
 
  h_td0_vs_rd0_->Write();
  h_tz0_vs_rz0_->Write();
 
  outfile->Close();
  delete outfile;
}

onProcessStart()

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

                              {
  // Monitoring plots
 
  double d0min = -2;
  double d0max = 2;
  double z0min = -2;
  double z0max = 2;
 
  h_delta_d0_ = new TH1F("h_delta_d0", "h_delta_d0", 400, d0min, d0max);
  h_delta_z0_ = new TH1F("h_delta_z0", "h_delta_z0", 200, z0min, z0max);
  h_delta_p_ = new TH1F("h_delta_p", "h_delta_p", 200, -1, 4);
  // h_delta_pT_vsP    = new TH2D("h_delta_pT_vs_p","h_delta_pT_v_p",200,)
  h_delta_phi_ = new TH1F("h_delta_phi", "h_delta_phi", 400, -0.2, 0.2);
  h_delta_theta_ = new TH1F("h_delta_theta", "h_delta_theta", 200, -0.1, 0.1);
 
  h_delta_d0_vs_recoil_p_ =
      new TH2F("h_delta_d0_vs_recoil_p", "h_delta_d0_vs_recoil_p", 200, 0, 5,
               400, -1, 1);
  h_delta_z0_vs_recoil_p_ =
      new TH2F("h_delta_z0_vs_recoil_p", "h_delta_z0_vs_recoil_p", 200, 0, 5,
               400, -1, 1);
 
  h_td0_vs_rd0_ =
      new TH2F("h_td0_vs_rd0", "h_td0_vs_rd0", 100, -40, 40, 100, -40, 40);
  h_tz0_vs_rz0_ =
      new TH2F("h_tz0_vs_rz0", "h_tz0_vs_rz0", 100, -40, 40, 100, -40, 40);
 
  bctx_ = Acts::MagneticFieldContext();
 
  /*
   * This is unused now, should it be?
  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
  };
  */
 
  sp_interpolated_b_field_ =
      std::make_shared<InterpolatedMagneticField3>(loadDefaultBField(
          field_map_, defaultTransformPos, defaultTransformBField));
 
  // There is a sign issue between the vertexing and the perigee representation
  Acts::Vector3 b_field(0., 0., -1.5 * Acts::UnitConstants::T);
  b_field_ = std::make_shared<Acts::ConstantBField>(b_field);
 
  std::cout << "Check if nullptr::" << sp_interpolated_b_field_.get()
            << std::endl;
 
  // Set up propagator with void navigator
  // auto&& stepper = Acts::EigenStepper<>{sp_interpolated_bField_};
  // propagator_ = std::make_shared<VoidPropagator>(stepper);
 
  auto&& stepper_const = Acts::EigenStepper<>{b_field_};
  propagator_ = std::make_shared<VoidPropagator>(stepper_const);
}

produce()

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

                                            {
  nevents_++;
  // auto start = std::chrono::high_resolution_clock::now();
 
  // Note: FullBilloirVertexFitter setup commented out — fit() is not called
  // and v46 Config now requires extractParameters/trackLinearizer delegates.
  // Acts::VertexingOptions vf_options(gctx_, bctx_);
 
  // Retrive the two track collections
 
  const auto& tracks_1 =
      event.getCollection<ldmx::Track>(trk_c_name_1_, input_pass_name_);
  const auto& tracks_2 =
      event.getCollection<ldmx::Track>(trk_c_name_2_, input_pass_name_);
 
  ldmx_log(debug) << "Retrieved track collections" << std::endl
                  << "Track 1 size:" << tracks_1.size() << std::endl
                  << "Track 2 size:" << tracks_2.size() << std::endl;
 
  if (tracks_1.size() < 1 || tracks_2.size() < 1) return;
 
  std::vector<Acts::BoundTrackParameters> billoir_tracks_1, billoir_tracks_2;
 
  // TODO:: The perigee surface should be common between all tracks.
 
  Acts::Vector3 perigee_acts = tracking::sim::utils::ldmx2Acts(Acts::Vector3(
      tracks_1.front().getPerigeeX(), tracks_1.front().getPerigeeY(),
      tracks_1.front().getPerigeeZ()));
  std::shared_ptr<Acts::PerigeeSurface> perigee_surface =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(perigee_acts);
 
  // Monitoring of tagger and recoil tracks
  taggerRecoilMonitoring(tracks_1, tracks_2);
 
  // Start the vertex formation
  // Form a vertex for each combination of tracks found in the same event
  // between the two track collections
 
  for (auto& trk : tracks_1) {
    billoir_tracks_1.push_back(
        tracking::sim::utils::boundTrackParameters(trk, perigee_surface));
  }
 
  for (auto& trk : tracks_2) {
    billoir_tracks_2.push_back(
        tracking::sim::utils::boundTrackParameters(trk, perigee_surface));
  }
 
  //  std::vector<Acts::Vertex<Acts::BoundTrackParameters> > fit_vertices;
  std::vector<Acts::Vertex> fit_vertices;
 
  for (auto& b_trk_1 : billoir_tracks_1) {
    std::vector<const Acts::BoundTrackParameters*> fit_tracks_ptr;
 
    for (auto& b_trk_2 : billoir_tracks_2) {
      fit_tracks_ptr.push_back(&b_trk_1);
      fit_tracks_ptr.push_back(&b_trk_2);
 
      ldmx_log(debug) << "Calling vertex fitter" << std::endl
                      << "Track 1 parameters" << std::endl
                      << b_trk_1 << std::endl
                      << "Track 2 parameters" << std::endl
                      << b_trk_2 << std::endl;
 
      //  std::cout << "Perigee Surface" << std::endl;
      //  perigeeSurface->toStream(gctx_, std::cout);
      //  std::cout << std::endl;
 
    }  // loop on second set of tracks
 
    nreconstructable_++;
    try {
      // Acts::Vertex<Acts::BoundTrackParameters> fitVtx =
      // billoirFitter.fit(fit_tracks_ptr, linearizer, vfOptions,
      // state).value(); fit_vertices.push_back(fitVtx);
      nvertices_++;
 
    } catch (...) {
      ldmx_log(warn) << "Vertex fit failed" << std::endl;
    }
 
  }  // loop on first set
 
  // Convert the vertices in the ldmx EDM and store them
}

taggerRecoilMonitoring()

void tracking::reco::Vertexer::taggerRecoilMonitoring	(	const std::vector< ldmx::Track > &	tagger_tracks,
		const std::vector< ldmx::Track > &	recoil_tracks )

Definition at line 199 of file Vertexer.cxx.

                                               {
  // For the moment only check that I have 1 tagger track and one recoil track
  // To avoid trying to match them
  // TODO update this logic
 
  if (tagger_tracks.size() != 1 || recoil_tracks.size() != 1) return;
 
  ldmx::Track t_trk = tagger_tracks.at(0);
  ldmx::Track r_trk = recoil_tracks.at(0);
 
  double t_p, r_p;
  // these are unsed, should they be? FIXME
  // double t_d0, r_d0;
  // double tt_p_phi, r_phi;
  // double t_theta, r_theta;
  // double t_z0, r_z0;
 
  t_p = t_trk.getCharge() / t_trk.getQoP();
  r_p = r_trk.getCharge() / r_trk.getQoP();
 
  h_delta_d0_->Fill(t_trk.getD0() - r_trk.getD0());
  h_delta_z0_->Fill(t_trk.getZ0() - r_trk.getZ0());
  h_delta_p_->Fill(t_p - r_p);
  h_delta_phi_->Fill(t_trk.getPhi() - r_trk.getPhi());
  h_delta_theta_->Fill(t_trk.getTheta() - r_trk.getTheta());
 
  // differential plots
 
  h_delta_d0_vs_recoil_p_->Fill(r_p, t_trk.getD0() - r_trk.getD0());
  h_delta_z0_vs_recoil_p_->Fill(r_p, t_trk.getZ0() - r_trk.getZ0());
 
  //"beamspot"
  h_td0_vs_rd0_->Fill(r_trk.getD0(), t_trk.getD0());
  h_tz0_vs_rz0_->Fill(r_trk.getZ0(), t_trk.getZ0());
 
  //"pT"
  // TODO Transverse momentum should obtained orthogonal to the B-Field
  // direction This assumes to be along Z (which is not very accurate)
 
  // std::vector<double> r_mom = r_trk.getMomentum();
  // std::vector<double> t_mom = t_trk.getMomentum();
 
  // I assume to have a single photon being emitted in the target: I use
  // momentum conservation p_photon = p_beam - p_recoil
 
  // h_gamma_px->Fill(t_mom[0] - r_mom[0]);
  // h_gamma_py->Fill(t_mom[1] - r_mom[1]);
  // h_gamma_pz->Fill(t_mom[2] - r_mom[2]);
}

Member Data Documentation

b_field_

std::shared_ptr<Acts::ConstantBField> tracking::reco::Vertexer::b_field_

private

Definition at line 63 of file Vertexer.h.

bctx_

Acts::MagneticFieldContext tracking::reco::Vertexer::bctx_

private

Definition at line 57 of file Vertexer.h.

field_map_

std::string tracking::reco::Vertexer::field_map_

private

Path to the magnetic field map.

Definition at line 66 of file Vertexer.h.

h_delta_d0_

TH1F* tracking::reco::Vertexer::h_delta_d0_

private

Definition at line 74 of file Vertexer.h.

h_delta_d0_vs_recoil_p_

TH2F* tracking::reco::Vertexer::h_delta_d0_vs_recoil_p_

private

Definition at line 81 of file Vertexer.h.

h_delta_p_

TH1F* tracking::reco::Vertexer::h_delta_p_

private

Definition at line 76 of file Vertexer.h.

h_delta_phi_

TH1F* tracking::reco::Vertexer::h_delta_phi_

private

Definition at line 78 of file Vertexer.h.

h_delta_theta_

TH1F* tracking::reco::Vertexer::h_delta_theta_

private

Definition at line 79 of file Vertexer.h.

h_delta_z0_

TH1F* tracking::reco::Vertexer::h_delta_z0_

private

Definition at line 75 of file Vertexer.h.

h_delta_z0_vs_recoil_p_

TH2F* tracking::reco::Vertexer::h_delta_z0_vs_recoil_p_

private

Definition at line 82 of file Vertexer.h.

h_td0_vs_rd0_

TH2F* tracking::reco::Vertexer::h_td0_vs_rd0_

private

Definition at line 84 of file Vertexer.h.

h_tz0_vs_rz0_

TH2F* tracking::reco::Vertexer::h_tz0_vs_rz0_

private

Definition at line 85 of file Vertexer.h.

input_pass_name_

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

private

Definition at line 70 of file Vertexer.h.

{""};

nevents_

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

private

Definition at line 59 of file Vertexer.h.

{0};

nreconstructable_

int tracking::reco::Vertexer::nreconstructable_ {0}

private

Definition at line 61 of file Vertexer.h.

{0};

nvertices_

int tracking::reco::Vertexer::nvertices_ {0}

private

Definition at line 60 of file Vertexer.h.

{0};

propagator_

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

private

Definition at line 71 of file Vertexer.h.

sp_interpolated_b_field_

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

private

Definition at line 62 of file Vertexer.h.

trk_c_name_1_

std::string tracking::reco::Vertexer::trk_c_name_1_ {"TaggerTracks"}

private

Definition at line 68 of file Vertexer.h.

{"TaggerTracks"};

trk_c_name_2_

std::string tracking::reco::Vertexer::trk_c_name_2_ {"RecoilTracks"}

private

Definition at line 69 of file Vertexer.h.

{"RecoilTracks"};

---

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

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