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	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_

Acts::MagneticFieldContext	bctx_

int	nevents_ {0}

int	nvertices_ {0}

int	nreconstructable_ {0}

std::shared_ptr< InterpolatedMagneticField3 >	sp_interpolated_bField_

std::shared_ptr< Acts::ConstantBField >	bField_

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

Constructor & Destructor Documentation

◆ Vertexer()

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

Definition at line 17 of file Vertexer.cxx.

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

framework::Producer

Base class for a module which produces a data product.

Definition EventProcessor.h:252

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 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 80 of file Vertexer.cxx.

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

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

◆ 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 200 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 20 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);
 
  gctx_ = Acts::GeometryContext();
  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_bField_ =
      std::make_shared<InterpolatedMagneticField3>(loadDefaultBField(
          field_map_, default_transformPos, default_transformBField));
 
  // There is a sign issue between the vertexing and the perigee representation
  Acts::Vector3 b_field(0., 0., -1.5 * Acts::UnitConstants::T);
  bField_ = std::make_shared<Acts::ConstantBField>(b_field);
 
  std::cout << "Check if nullptr::" << sp_interpolated_bField_.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<>{bField_};
  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();
 
  // Track linearizer in the proximity of the vertex location
  using Linearizer = Acts::HelicalTrackLinearizer;
  Linearizer::Config linearizerConfig;
  linearizerConfig.bField = bField_;
  linearizerConfig.propagator = propagator_;
  Linearizer linearizer(linearizerConfig);
 
  // Set up Billoir Vertex Fitter
  using VertexFitter = Acts::FullBilloirVertexFitter;
 
  // Alternatively one can use
  // using VertexFitter =
  //  Acts::FullBilloirVertexFitter<tracking::sim::utils::boundTrackParameters,Linearizer>;
 
  VertexFitter::Config vertexFitterCfg;
  VertexFitter billoirFitter(vertexFitterCfg);
  //  mg Aug 2024 .. State doesn't exist in v36 and isn't used here anyway
  //  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<Acts::BoundTrackParameters> vfOptions(gctx_,
  //  bctx_);
  // mg Aug 2024 ... VertexingOptions template change in v36
  Acts::VertexingOptions vfOptions(gctx_, bctx_);
 
  // Retrive the two track collections
 
  const std::vector<ldmx::Track> tracks_1 =
      event.getCollection<ldmx::Track>(trk_c_name_1);
  const std::vector<ldmx::Track> tracks_2 =
      event.getCollection<ldmx::Track>(trk_c_name_2);
 
  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.
 
  std::shared_ptr<Acts::PerigeeSurface> perigeeSurface =
      Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3(
          tracks_1.front().getPerigeeX(), tracks_1.front().getPerigeeY(),
          tracks_1.front().getPerigeeZ()));
 
  // 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, perigeeSurface));
  }
 
  for (auto& trk : tracks_2) {
    billoir_tracks_2.push_back(
        tracking::sim::utils::boundTrackParameters(trk, perigeeSurface));
  }
 
  //  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 223 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.q() / t_trk.getQoP();
  r_p = r_trk.q() / 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

◆ bctx_

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

private

Definition at line 66 of file Vertexer.h.

◆ bField_

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

private

Definition at line 72 of file Vertexer.h.

◆ field_map_

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

private

Path to the magnetic field map.

Definition at line 75 of file Vertexer.h.

◆ gctx_

Acts::GeometryContext tracking::reco::Vertexer::gctx_

private

Definition at line 65 of file Vertexer.h.

◆ h_delta_d0

TH1F* tracking::reco::Vertexer::h_delta_d0

private

Definition at line 82 of file Vertexer.h.

◆ h_delta_d0_vs_recoil_p

TH2F* tracking::reco::Vertexer::h_delta_d0_vs_recoil_p

private

Definition at line 89 of file Vertexer.h.

◆ h_delta_p

TH1F* tracking::reco::Vertexer::h_delta_p

private

Definition at line 84 of file Vertexer.h.

◆ h_delta_phi

TH1F* tracking::reco::Vertexer::h_delta_phi

private

Definition at line 86 of file Vertexer.h.

◆ h_delta_theta

TH1F* tracking::reco::Vertexer::h_delta_theta

private

Definition at line 87 of file Vertexer.h.

◆ h_delta_z0

TH1F* tracking::reco::Vertexer::h_delta_z0

private

Definition at line 83 of file Vertexer.h.

◆ h_delta_z0_vs_recoil_p

TH2F* tracking::reco::Vertexer::h_delta_z0_vs_recoil_p

private

Definition at line 90 of file Vertexer.h.

◆ h_td0_vs_rd0

TH2F* tracking::reco::Vertexer::h_td0_vs_rd0

private

Definition at line 92 of file Vertexer.h.

◆ h_tz0_vs_rz0

TH2F* tracking::reco::Vertexer::h_tz0_vs_rz0

private

Definition at line 93 of file Vertexer.h.

◆ nevents_

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

private

Definition at line 68 of file Vertexer.h.

68{0};

◆ nreconstructable_

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

private

Definition at line 70 of file Vertexer.h.

70{0};

◆ nvertices_

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

private

Definition at line 69 of file Vertexer.h.

69{0};

◆ propagator_

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

private

Definition at line 79 of file Vertexer.h.

◆ sp_interpolated_bField_

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

private

Definition at line 71 of file Vertexer.h.

◆ trk_c_name_1

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

private

Definition at line 77 of file Vertexer.h.

77{"TaggerTracks"};

◆ trk_c_name_2

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

private

Definition at line 78 of file Vertexer.h.

78{"RecoilTracks"};

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Vertexer()

Member Function Documentation

◆ configure()

◆ onProcessEnd()

◆ onProcessStart()

◆ produce()

◆ TaggerRecoilMonitoring()

Member Data Documentation

◆ bctx_

◆ bField_

◆ field_map_

◆ gctx_

◆ h_delta_d0

◆ h_delta_d0_vs_recoil_p

◆ h_delta_p

◆ h_delta_phi

◆ h_delta_theta

◆ h_delta_z0

◆ h_delta_z0_vs_recoil_p

◆ h_td0_vs_rd0

◆ h_tz0_vs_rz0

◆ nevents_

◆ nreconstructable_

◆ nvertices_

◆ propagator_

◆ sp_interpolated_bField_

◆ trk_c_name_1

◆ trk_c_name_2