d3/d95/ActsEvaluator_8h_source.html

#ifndef ACTSEVALUATOR_H

#define ACTSEVALUATOR_H


#include <fun4all/SubsysReco.h>


#include <trackbase/TrkrDefs.h>

#include <trackbase/ActsTrackingGeometry.h>

#include <trackbase/ActsSurfaceMaps.h>


#include <Acts/Utilities/Helpers.hpp>


#include <ActsExamples/EventData/TrkrClusterMultiTrajectory.hpp>

#include <ActsExamples/EventData/TrkrClusterSourceLink.hpp>

#include <ActsExamples/Fitting/TrkrClusterFittingAlgorithm.hpp>


#include <boost/bimap.hpp>


class TTree;

class TFile;

class PHG4Particle;

class SvtxTrack;

class SvtxVertexMap;

class SvtxEvalStack;

class SvtxTrackMap;

class PHG4TruthInfoContainer;

class TrkrClusterContainer;

class SvtxEvaluator;


#include <map>

#include <string>

#include <vector>


using SourceLink = ActsExamples::TrkrClusterSourceLink;

using FitResult = Acts::KalmanFitterResult<SourceLink>;

using Trajectory = ActsExamples::TrkrClusterMultiTrajectory;

using Measurement = Acts::Measurement<ActsExamples::TrkrClusterSourceLink,

                                      Acts::BoundIndices,

                                      Acts::eBoundLoc0,

                                      Acts::eBoundLoc1>;

using Acts::VectorHelpers::eta;

using Acts::VectorHelpers::perp;

using Acts::VectorHelpers::phi;

using Acts::VectorHelpers::theta;


typedef boost::bimap<TrkrDefs::cluskey, unsigned int> CluskeyBimap;


class ActsEvaluator : public SubsysReco

{

 public:

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

                     SvtxEvaluator *svtxEvaluator = nullptr);

  ~ActsEvaluator() override;


  int Init(PHCompositeNode *topNode) override;

  int process_event(PHCompositeNode *topNode) override;

  int ResetEvent(PHCompositeNode *topNode) override;

  int End(PHCompositeNode *topNode) override;

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


 private:

  int getNodes(PHCompositeNode *topNode);


  void evaluateTrackFits(PHCompositeNode *topNode);


  void initializeTree();


  void fillG4Particle(PHG4Particle *part);


  void fillProtoTrack(SvtxTrack* track, PHCompositeNode *topNode);


  void fillFittedTrackParams(const Trajectory traj,

           const size_t &trackTip,

           const Acts::Vector3D vertex);


  void visitTrackStates(const Trajectory traj,

      const size_t &trackTip,

      PHCompositeNode *topNode);


  void clearTrackVariables();


  void calculateDCA(const Acts::BoundTrackParameters param,

        const Acts::Vector3D vertex);


  Surface getSurface(TrkrDefs::cluskey cluskey,TrkrDefs::subsurfkey surfkey);

  Surface getSiliconSurface(TrkrDefs::hitsetkey hitsetkey);

  Surface getTpcSurface(TrkrDefs::hitsetkey hitsetkey, TrkrDefs::subsurfkey surfkey);

  Surface getMMSurface(TrkrDefs::hitsetkey hitsetkey);


  Acts::Vector3D getGlobalTruthHit(PHCompositeNode *topNode,

           TrkrDefs::cluskey cluskey,

           float &_gt);


  ActsSurfaceMaps *m_surfMaps{nullptr};


  SvtxEvaluator *m_svtxEvaluator{nullptr};

  PHG4TruthInfoContainer *m_truthInfo{nullptr};

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

  SvtxEvalStack *m_svtxEvalStack{nullptr};

  std::map<const unsigned int, std::map<const size_t,

    const unsigned int>> *m_actsTrackKeyMap{nullptr};

  std::map<const unsigned int, Trajectory> *m_actsFitResults{nullptr};


  ActsTrackingGeometry *m_tGeometry{nullptr};

  SvtxVertexMap *m_vertexMap{nullptr};

  TrkrClusterContainer *m_clusterContainer{nullptr};


  bool m_evalCKF;


  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{-99.};

  float m_t_vy{-99.};

  float m_t_vz{-99.};

  float m_t_px{-99.};

  float m_t_py{-99.};

  float m_t_pz{-99.};

  float m_t_theta{-99.};

  float m_t_phi{-99.};

  float m_t_pT{-99.};

  float m_t_eta{-99.};


  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_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{-99.};

  float m_eLOC1_fit{-99.};

  float m_ePHI_fit{-99.};

  float m_eTHETA_fit{-99.};

  float m_eQOP_fit{-99.};

  float m_eT_fit{-99.};

  float m_err_eLOC0_fit{-99.};

  float m_err_eLOC1_fit{-99.};

  float m_err_ePHI_fit{-99.};

  float m_err_eTHETA_fit{-99.};

  float m_err_eQOP_fit{-99.};

  float m_err_eT_fit{-99.};

  float m_px_fit{-99.};

  float m_py_fit{-99.};

  float m_pz_fit{-99.};

  float m_x_fit{-99.};

  float m_y_fit{-99.};

  float m_z_fit{-99.};

  float m_chi2_fit{-99.};

  float m_quality{-99.};

  float m_ndf_fit{-99.};

  float m_dca3Dxy{-99.};

  float m_dca3Dz{-99.};

  float m_dca3DxyCov{-99.};

  float m_dca3DzCov{-99.};

  int m_charge_fit{-99};


  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{-9999.};

  float m_protoTrackPy{-9999.};

  float m_protoTrackPz{-9999.};

  float m_protoTrackX{-9999.};

  float m_protoTrackY{-9999.};

  float m_protoTrackZ{-9999.};

  float m_protoD0Cov{-9999.};

  float m_protoZ0Cov{-9999.};

  float m_protoPhiCov{-9999.};

  float m_protoThetaCov{-9999.};

  float m_protoQopCov{-9999.};


  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