d3/d95/ActsEvaluator_8h_source.html

#ifndef ACTSEVALUATOR_H

#define ACTSEVALUATOR_H


#include <fun4all/SubsysReco.h>


#include <trackbase/ActsGeometry.h>

#include <trackbase/ActsSourceLink.h>

#include <trackbase/ActsTrackFittingAlgorithm.h>

#include <trackbase/TrkrDefs.h>


#include <Acts/Utilities/Helpers.hpp>


#include <ActsExamples/EventData/Trajectories.hpp>


class TTree;

class TFile;

class PHG4Particle;

class SvtxTrack;

class SvtxVertexMap;

class SvtxEvalStack;

class SvtxTrackMap;

class PHG4TruthInfoContainer;

class TrkrClusterContainer;

class SvtxEvaluator;

class TrackSeed;

class TrackSeedContainer;


#include <map>

#include <string>

#include <vector>


using SourceLink = ActsSourceLink;

using Trajectory = ActsExamples::Trajectories;

using Measurement = Acts::Measurement<Acts::BoundIndices, 2>;

using Acts::VectorHelpers::eta;

using Acts::VectorHelpers::perp;

using Acts::VectorHelpers::phi;

using Acts::VectorHelpers::theta;


class ActsEvaluator

{

 public:

  ActsEvaluator(const std::string& name = "ActsEvaluator.root");

  ~ActsEvaluator();


  void Init(PHCompositeNode* topNode);

  void process_track(const ActsTrackFittingAlgorithm::TrackContainer& tracks,

                     std::vector<Acts::MultiTrajectoryTraits::IndexType>& trackTips,

                     Trajectory::IndexedParameters& paramsMap,

                     SvtxTrack* track,

                     const TrackSeed* seed,

                     const ActsTrackFittingAlgorithm::MeasurementContainer& measurements);

  void End();

  void setEvalCKF(bool evalCKF) { m_evalCKF = evalCKF; }

  void verbosity(int verb) { m_verbosity = verb; }

  void next_event(PHCompositeNode* topNode);


  void evaluateTrackFit(const ActsTrackFittingAlgorithm::TrackContainer& trackContainer,

                        std::vector<Acts::MultiTrajectoryTraits::IndexType>& trackTips,

                        Trajectory::IndexedParameters& paramsMap,

                        SvtxTrack* track,

                        const TrackSeed* seed,

                        const ActsTrackFittingAlgorithm::MeasurementContainer& measurements);


 private:

  int getNodes(PHCompositeNode* topNode);


  void initializeTree();


  void fillG4Particle(PHG4Particle* part);


  void fillProtoTrack(const TrackSeed* seed);


  void fillFittedTrackParams(const Trajectory::IndexedParameters& paramsMap,

                             const size_t& trackTip);


  void visitTrackStates(const Acts::ConstVectorMultiTrajectory& traj,

                        const size_t& trackTip,

                        const ActsTrackFittingAlgorithm::MeasurementContainer& measurements);


  void clearTrackVariables();


  Surface getSurface(TrkrDefs::cluskey cluskey, TrkrCluster* cluster);


  Acts::Vector3 getGlobalTruthHit(TrkrDefs::cluskey cluskey,

                                  float& _gt);


  SvtxEvaluator* m_svtxEvaluator{nullptr};

  PHG4TruthInfoContainer* m_truthInfo{nullptr};

  SvtxTrackMap *m_trackMap{nullptr}, *m_actsProtoTrackMap{nullptr};

  SvtxEvalStack* m_svtxEvalStack{nullptr};


  ActsGeometry* m_tGeometry{nullptr};

  TrkrClusterContainer* m_clusterContainer{nullptr};

  TrackSeedContainer *m_tpcSeeds{nullptr}, *m_siliconSeeds{nullptr};


  bool m_evalCKF = false;

  int m_verbosity = 0;

  std::string m_filename;

  TFile* m_trackFile{nullptr};

  TTree* m_trackTree{nullptr};


  int m_eventNr{0};

  int m_trajNr{0};

  int m_trackNr{0};


  unsigned long m_t_barcode{0};

  int m_t_charge{0};

  float m_t_time{0};

  float m_t_vx{NAN};

  float m_t_vy{NAN};

  float m_t_vz{NAN};

  float m_t_px{NAN};

  float m_t_py{NAN};

  float m_t_pz{NAN};

  float m_t_theta{NAN};

  float m_t_phi{NAN};

  float m_t_pT{NAN};

  float m_t_eta{NAN};


  std::vector<float> m_t_x;

  std::vector<float> m_t_y;

  std::vector<float> m_t_z;

  std::vector<float> m_t_r;

  std::vector<float>

      m_t_dx;

  std::vector<float>

      m_t_dy;

  std::vector<float>

      m_t_dz;


  std::vector<float> m_t_eLOC0;

  std::vector<float> m_t_eLOC1;

  std::vector<float> m_t_ePHI;

  std::vector<float> m_t_eTHETA;

  std::vector<float> m_t_eQOP;

  std::vector<float> m_t_eT;


  int m_nSharedHits{0};

  int m_nHoles{0};

  int m_nOutliers{0};

  int m_nStates{0};

  int m_nMeasurements{0};

  std::vector<int> m_volumeID;

  std::vector<int> m_layerID;

  std::vector<int> m_moduleID;

  std::vector<float> m_lx_hit;

  std::vector<float> m_ly_hit;

  std::vector<float> m_x_hit;

  std::vector<float> m_y_hit;

  std::vector<float> m_z_hit;

  std::vector<float> m_res_x_hit;

  std::vector<float> m_res_y_hit;

  std::vector<float> m_err_x_hit;

  std::vector<float> m_err_y_hit;

  std::vector<float> m_pull_x_hit;

  std::vector<float> m_pull_y_hit;

  std::vector<int> m_dim_hit;


  bool m_hasFittedParams{false};

  float m_eLOC0_fit{NAN};

  float m_eLOC1_fit{NAN};

  float m_ePHI_fit{NAN};

  float m_eTHETA_fit{NAN};

  float m_eQOP_fit{NAN};

  float m_eT_fit{NAN};

  float m_err_eLOC0_fit{NAN};

  float m_err_eLOC1_fit{NAN};

  float m_err_ePHI_fit{NAN};

  float m_err_eTHETA_fit{NAN};

  float m_err_eQOP_fit{NAN};

  float m_err_eT_fit{NAN};

  float m_px_fit{NAN};

  float m_py_fit{NAN};

  float m_pz_fit{NAN};

  float m_x_fit{NAN};

  float m_y_fit{NAN};

  float m_z_fit{NAN};

  float m_chi2_fit{NAN};

  float m_quality{NAN};

  float m_ndf_fit{NAN};

  float m_dca3Dxy{NAN};

  float m_dca3Dz{NAN};

  float m_dca3DxyCov{NAN};

  float m_dca3DzCov{NAN};

  int m_charge_fit{-9999999};


  int m_nPredicted{0};

  std::vector<bool> m_prt;

  std::vector<float> m_eLOC0_prt;

  std::vector<float> m_eLOC1_prt;

  std::vector<float> m_ePHI_prt;

  std::vector<float> m_eTHETA_prt;

  std::vector<float> m_eQOP_prt;

  std::vector<float> m_eT_prt;

  std::vector<float> m_res_eLOC0_prt;

  std::vector<float> m_res_eLOC1_prt;

  std::vector<float> m_res_ePHI_prt;

  std::vector<float> m_res_eTHETA_prt;

  std::vector<float> m_res_eQOP_prt;

  std::vector<float> m_res_eT_prt;

  std::vector<float> m_err_eLOC0_prt;

  std::vector<float> m_err_eLOC1_prt;

  std::vector<float> m_err_ePHI_prt;

  std::vector<float> m_err_eTHETA_prt;

  std::vector<float> m_err_eQOP_prt;

  std::vector<float> m_err_eT_prt;

  std::vector<float> m_pull_eLOC0_prt;

  std::vector<float> m_pull_eLOC1_prt;

  std::vector<float> m_pull_ePHI_prt;

  std::vector<float> m_pull_eTHETA_prt;

  std::vector<float> m_pull_eQOP_prt;

  std::vector<float> m_pull_eT_prt;

  std::vector<float> m_x_prt;

  std::vector<float> m_y_prt;

  std::vector<float> m_z_prt;

  std::vector<float> m_px_prt;

  std::vector<float> m_py_prt;

  std::vector<float> m_pz_prt;

  std::vector<float> m_eta_prt;

  std::vector<float> m_pT_prt;


  int m_nFiltered{0};

  std::vector<bool> m_flt;

  std::vector<float> m_eLOC0_flt;

  std::vector<float> m_eLOC1_flt;

  std::vector<float> m_ePHI_flt;

  std::vector<float> m_eTHETA_flt;

  std::vector<float> m_eQOP_flt;

  std::vector<float> m_eT_flt;

  std::vector<float> m_res_eLOC0_flt;

  std::vector<float> m_res_eLOC1_flt;

  std::vector<float> m_res_ePHI_flt;

  std::vector<float> m_res_eTHETA_flt;

  std::vector<float> m_res_eQOP_flt;

  std::vector<float> m_res_eT_flt;

  std::vector<float> m_err_eLOC0_flt;

  std::vector<float> m_err_eLOC1_flt;

  std::vector<float> m_err_ePHI_flt;

  std::vector<float> m_err_eTHETA_flt;

  std::vector<float> m_err_eQOP_flt;

  std::vector<float> m_err_eT_flt;

  std::vector<float> m_pull_eLOC0_flt;

  std::vector<float> m_pull_eLOC1_flt;

  std::vector<float> m_pull_ePHI_flt;

  std::vector<float> m_pull_eTHETA_flt;

  std::vector<float> m_pull_eQOP_flt;

  std::vector<float> m_pull_eT_flt;

  std::vector<float> m_x_flt;

  std::vector<float> m_y_flt;

  std::vector<float> m_z_flt;

  std::vector<float> m_px_flt;

  std::vector<float> m_py_flt;

  std::vector<float> m_pz_flt;

  std::vector<float> m_eta_flt;

  std::vector<float> m_pT_flt;

  std::vector<float> m_chi2;


  int m_nSmoothed{0};

  std::vector<bool> m_smt;

  std::vector<float> m_eLOC0_smt;

  std::vector<float> m_eLOC1_smt;

  std::vector<float> m_ePHI_smt;

  std::vector<float> m_eTHETA_smt;

  std::vector<float> m_eQOP_smt;

  std::vector<float> m_eT_smt;

  std::vector<float> m_res_eLOC0_smt;

  std::vector<float> m_res_eLOC1_smt;

  std::vector<float> m_res_ePHI_smt;

  std::vector<float> m_res_eTHETA_smt;

  std::vector<float> m_res_eQOP_smt;

  std::vector<float> m_res_eT_smt;

  std::vector<float> m_err_eLOC0_smt;

  std::vector<float> m_err_eLOC1_smt;

  std::vector<float> m_err_ePHI_smt;

  std::vector<float> m_err_eTHETA_smt;

  std::vector<float> m_err_eQOP_smt;

  std::vector<float> m_err_eT_smt;

  std::vector<float> m_pull_eLOC0_smt;

  std::vector<float> m_pull_eLOC1_smt;

  std::vector<float> m_pull_ePHI_smt;

  std::vector<float> m_pull_eTHETA_smt;

  std::vector<float> m_pull_eQOP_smt;

  std::vector<float> m_pull_eT_smt;

  std::vector<float> m_x_smt;

  std::vector<float> m_y_smt;

  std::vector<float> m_z_smt;

  std::vector<float> m_px_smt;

  std::vector<float> m_py_smt;

  std::vector<float> m_pz_smt;

  std::vector<float> m_eta_smt;

  std::vector<float> m_pT_smt;


  float m_protoTrackPx{NAN};

  float m_protoTrackPy{NAN};

  float m_protoTrackPz{NAN};

  float m_protoTrackX{NAN};

  float m_protoTrackY{NAN};

  float m_protoTrackZ{NAN};

  float m_protoD0Cov{NAN};

  float m_protoZ0Cov{NAN};

  float m_protoPhiCov{NAN};

  float m_protoThetaCov{NAN};

  float m_protoQopCov{NAN};


  std::vector<float> m_SL_lx;

  std::vector<float> m_SL_ly;

  std::vector<float> m_SLx;

  std::vector<float> m_SLy;

  std::vector<float> m_SLz;

  std::vector<float> m_t_SL_lx;

  std::vector<float> m_t_SL_ly;

  std::vector<float> m_t_SL_gx;

  std::vector<float> m_t_SL_gy;

  std::vector<float> m_t_SL_gz;

};


#endif