TpcPrototypeGenFitTrkFitter.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TpcPrototypeGenFitTrkFitter.h

#ifndef TRACKRECO_TpcPrototypeGenFitTrkFitter_H
#define TRACKRECO_TpcPrototypeGenFitTrkFitter_H

#include <fun4all/SubsysReco.h>

#include <TMatrixFfwd.h>  // for TMatrixF
#include <TVector3.h>     // for TVector3

#include <cstddef>  // for NULL
#include <memory>   // for shared_ptr
#include <string>
#include <vector>

class TClonesArray;

namespace PHGenFit
{
class Track;
} /* namespace PHGenFit */

namespace genfit
{
class GFRaveVertex;
class GFRaveVertexFactory;
class Track;
} /* namespace genfit */

class SvtxTrack;
namespace PHGenFit
{
class Fitter;
} /* namespace PHGenFit */

class SvtxTrackMap;
class SvtxVertexMap;
class TrkrCluster;
class SvtxVertex;
class PHCompositeNode;
//class PHG4TruthInfoContainer;
class TrkrClusterContainer;
class TTree;
class TpcPrototypeTrack;

class TpcPrototypeGenFitTrkFitter : public SubsysReco
{
 public:
  enum OutPutMode
  {
    MakeNewNode,
    OverwriteOriginalNode,
    DebugMode
  };

  enum DetectorType
  {
    MIE,
    MAPS_TPC,
    MAPS_IT_TPC,
    LADDER_MAPS_TPC,
    LADDER_MAPS_IT_TPC,
    LADDER_MAPS_LADDER_IT_TPC,
    MAPS_LADDER_IT_TPC
  };

  TpcPrototypeGenFitTrkFitter(const std::string& name = "TpcPrototypeGenFitTrkFitter");

  ~TpcPrototypeGenFitTrkFitter();

  int Init(PHCompositeNode*);

  int InitRun(PHCompositeNode*);

  int process_event(PHCompositeNode*);

  int End(PHCompositeNode*);

  //Flags of different kinds of outputs
  enum Flag
  {
    //all disabled
    NONE = 0,
  };

  //Set the flag
  //Flags should be set like set_flag(TpcPrototypeGenFitTrkFitter::TRUTH, true) from macro
  void set_flag(const Flag& flag, const bool& value)
  {
    if (value)
      _flags |= flag;
    else
      _flags &= (~flag);
  }

  void set_eval_filename(const std::string& file)
  {
    _eval_outname = file;
  }
  std::string get_eval_filename() const
  {
    return _eval_outname;
  }

  void fill_eval_tree(PHCompositeNode*);
  void init_eval_tree();
  void reset_eval_variables();

  bool is_do_eval() const
  {
    return _do_eval;
  }

  void set_do_eval(bool doEval)
  {
    _do_eval = doEval;
  }

  bool is_do_evt_display() const
  {
    return _do_evt_display;
  }

  void set_do_evt_display(bool doEvtDisplay)
  {
    _do_evt_display = doEvtDisplay;
  }

  const std::string& get_vertexing_method() const
  {
    return _vertexing_method;
  }

  void set_vertexing_method(const std::string& vertexingMethod)
  {
    _vertexing_method = vertexingMethod;
  }

  bool is_fit_primary_tracks() const
  {
    return _fit_primary_tracks;
  }

  void set_fit_primary_tracks(bool fitPrimaryTracks)
  {
    _fit_primary_tracks = fitPrimaryTracks;
  }

  OutPutMode get_output_mode() const
  {
    return _output_mode;
  }

  void set_output_mode(OutPutMode outputMode)
  {
    _output_mode = outputMode;
  }

  const std::string& get_track_fitting_alg_name() const
  {
    return _track_fitting_alg_name;
  }

  void set_track_fitting_alg_name(const std::string& trackFittingAlgName)
  {
    _track_fitting_alg_name = trackFittingAlgName;
  }

  int get_primary_pid_guess() const
  {
    return _primary_pid_guess;
  }

  void set_primary_pid_guess(int primaryPidGuess)
  {
    _primary_pid_guess = primaryPidGuess;
  }

  double get_fit_min_pT() const
  {
    return _fit_min_pT;
  }

  void set_fit_min_pT(double cutMinPT)
  {
    _fit_min_pT = cutMinPT;
  }

  bool is_over_write_svtxtrackmap() const
  {
    return _over_write_svtxtrackmap;
  }

  void set_over_write_svtxtrackmap(bool overWriteSvtxtrackmap)
  {
    _over_write_svtxtrackmap = overWriteSvtxtrackmap;
  }

  bool is_over_write_svtxvertexmap() const
  {
    return _over_write_svtxvertexmap;
  }

  void set_over_write_svtxvertexmap(bool overWriteSvtxvertexmap)
  {
    _over_write_svtxvertexmap = overWriteSvtxvertexmap;
  }

  bool is_use_truth_vertex() const
  {
    return _use_truth_vertex;
  }

  void set_use_truth_vertex(bool useTruthVertex)
  {
    _use_truth_vertex = useTruthVertex;
  }

  double get_vertex_min_ndf() const
  {
    return _vertex_min_ndf;
  }

  void set_vertex_min_ndf(double vertexMinPT)
  {
    _vertex_min_ndf = vertexMinPT;
  }

 private:
  int _event;

  int GetNodes(PHCompositeNode*);

  int CreateNodes(PHCompositeNode*);

  /*
         * fit track with SvtxTrack as input seed.
         * \param intrack Input SvtxTrack
         * \param invertex Input Vertex, if fit track as a primary vertex
         */
  std::shared_ptr<PHGenFit::Track> ReFitTrack(PHCompositeNode*, const SvtxTrack* intrack, const SvtxVertex* invertex = NULL);

  // build a track as a container displaying unused clusters
  std::shared_ptr<PHGenFit::Track> DisplayCluster(const TrkrCluster* cluster);

  std::shared_ptr<SvtxTrack> MakeSvtxTrack(const SvtxTrack* svtxtrack, const std::shared_ptr<PHGenFit::Track>& genfit_track, const SvtxVertex* vertex = NULL);

  std::shared_ptr<TpcPrototypeTrack> MakeTpcPrototypeTrack(const SvtxTrack* svtxtrack);

  bool FillSvtxVertexMap(
      const std::vector<genfit::GFRaveVertex*>& rave_vertices,
      const std::vector<genfit::Track*>& gf_tracks);

  bool pos_cov_uvn_to_rz(
      const TVector3& u,
      const TVector3& v,
      const TVector3& n,
      const TMatrixF& pos_in,
      const TMatrixF& cov_in,
      TMatrixF& pos_out,
      TMatrixF& cov_out) const;

  bool get_vertex_error_uvn(
      const TVector3& u,
      const TVector3& v,
      const TVector3& n,
      const TMatrixF& cov_in,
      TMatrixF& cov_out) const;

  bool pos_cov_XYZ_to_RZ(
      const TVector3& n,
      const TMatrixF& pos_in,
      const TMatrixF& cov_in,
      TMatrixF& pos_out,
      TMatrixF& cov_out) const;

  TMatrixF get_rotation_matrix(
      const TVector3 x,
      const TVector3 y,
      const TVector3 z,
      const TVector3 xp = TVector3(1., 0., 0.),
      const TVector3 yp = TVector3(0., 1., 0.),
      const TVector3 zp = TVector3(0., 0., 1.)) const;

  unsigned int _flags;

  //bool _make_separate_nodes;
  OutPutMode _output_mode;

  bool _over_write_svtxtrackmap;
  bool _over_write_svtxvertexmap;

  bool _fit_primary_tracks;

  bool _use_truth_vertex;

  PHGenFit::Fitter* _fitter;

  std::string _track_fitting_alg_name;

  int _primary_pid_guess;
  double _fit_min_pT;
  double _vertex_min_ndf;

  genfit::GFRaveVertexFactory* _vertex_finder;

  std::string _vertexing_method;

  //PHRaveVertexFactory* _vertex_finder;

  //  PHG4TruthInfoContainer* _truth_container;
  TrkrClusterContainer* _clustermap;
  SvtxTrackMap* _trackmap;
  SvtxVertexMap* _vertexmap;

  SvtxTrackMap* _trackmap_refit;
  SvtxTrackMap* _primary_trackmap;
  SvtxVertexMap* _vertexmap_refit;

  bool _do_eval;

  std::string _eval_outname;

  TTree* _eval_tree;
  int _tca_ntrack;
  TClonesArray* _tca_particlemap;
  TClonesArray* _tca_vtxmap;
  TClonesArray* _tca_trackmap;
  TClonesArray* _tca_tpctrackmap;
  TClonesArray* _tca_vertexmap;
  TClonesArray* _tca_trackmap_refit;
  TClonesArray* _tca_primtrackmap;
  TClonesArray* _tca_vertexmap_refit;

  TTree* _cluster_eval_tree;
  float _cluster_eval_tree_x;
  float _cluster_eval_tree_y;
  float _cluster_eval_tree_z;
  float _cluster_eval_tree_gx;
  float _cluster_eval_tree_gy;
  float _cluster_eval_tree_gz;

  bool _do_evt_display;
};

#endif