PHActsTrkFitter.h

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

#ifndef TRACKRECO_ACTSTRKFITTER_H
#define TRACKRECO_ACTSTRKFITTER_H

#include <fun4all/SubsysReco.h>

#include <trackbase/ActsTrackingGeometry.h>
#include <trackbase/TrkrDefs.h>
#include <trackbase/ActsSurfaceMaps.h>

#include <Acts/Utilities/BinnedArray.hpp>
#include <Acts/Utilities/Definitions.hpp>
#include <Acts/Utilities/Logger.hpp>

#include <Acts/EventData/MeasurementHelpers.hpp>
#include <Acts/Geometry/TrackingGeometry.hpp>
#include <Acts/MagneticField/MagneticFieldContext.hpp>
#include <Acts/Utilities/CalibrationContext.hpp>

#include <ActsExamples/Fitting/TrkrClusterFittingAlgorithm.hpp>
#include <ActsExamples/EventData/TrkrClusterMultiTrajectory.hpp>

#include <boost/bimap.hpp>

#include <memory>
#include <string>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>

namespace ActsExamples
{
  class TrkrClusterSourceLink;
}

class MakeActsGeometry;
class SvtxTrack;
class SvtxTrackMap;
class TrkrClusterContainer;
class TrkrClusterIterationMapv1;

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 SurfacePtrVec = std::vector<const Acts::Surface*>;
using SourceLinkVec = std::vector<SourceLink>;

class PHActsTrkFitter : public SubsysReco
{
 public:
  PHActsTrkFitter(const std::string& name = "PHActsTrkFitter");

  ~PHActsTrkFitter() override = default;

  int End(PHCompositeNode *topNode) override;

  int InitRun(PHCompositeNode* topNode) override;

  int process_event(PHCompositeNode *topNode) override;

  int ResetEvent(PHCompositeNode *topNode) override;

  void doTimeAnalysis(bool timeAnalysis){m_timeAnalysis = timeAnalysis;}

  void fitSiliconMMs(bool fitSiliconMMs)
       {m_fitSiliconMMs = fitSiliconMMs;}

  void setUseMicromegas( bool value )
  { m_useMicromegas = value; }

  void setUpdateSvtxTrackStates(bool fillSvtxTrackStates)
       { m_fillSvtxTrackStates = fillSvtxTrackStates; }   

  void useActsEvaluator(bool actsEvaluator)
  { m_actsEvaluator = actsEvaluator; }
  
  void setFieldMap(std::string& fieldMap)
  { m_fieldMap = fieldMap; }

  void setAbsPdgHypothesis(unsigned int pHypothesis)
  { m_pHypothesis = pHypothesis; }

  void SetIteration(int iter){_n_iteration = iter;}
  void set_track_map_name(const std::string &map_name) { _track_map_name = map_name; }
  void set_seed_track_map_name(const std::string &map_name) { _seed_track_map_name = map_name; }

 private:

  int getNodes(PHCompositeNode *topNode);

  int createNodes(PHCompositeNode *topNode);

  void loopTracks(Acts::Logging::Level logLevel);
  SourceLinkVec getSourceLinks(SvtxTrack *track);

  void updateSvtxTrack(Trajectory traj, SvtxTrack* track);

  ActsExamples::TrkrClusterFittingAlgorithm::FitterResult fitTrack(
           const SourceLinkVec& sourceLinks, 
     const ActsExamples::TrackParameters& seed,
     const Acts::KalmanFitterOptions<Acts::VoidOutlierFinder>& 
           kfOptions,
     const SurfacePtrVec& surfSequence);

  SourceLinkVec getSurfaceVector(const SourceLinkVec& sourceLinks, 
         SurfacePtrVec& surfaces) const;
  void checkSurfaceVec(SurfacePtrVec& surfaces) const;
  void getTrackFitResult(const FitResult& fitOutput, 
       SvtxTrack* track);

  Surface getSurface(TrkrDefs::cluskey cluskey,TrkrDefs::subsurfkey surfkey) const;
  Surface getSiliconSurface(TrkrDefs::hitsetkey hitsetkey) const;
  Surface getTpcSurface(TrkrDefs::hitsetkey hitsetkey, TrkrDefs::subsurfkey surfkey) const;
  Surface getMMSurface(TrkrDefs::hitsetkey hitsetkey) const;

  Acts::BoundSymMatrix setDefaultCovariance() const;
  void printTrackSeed(const SvtxTrack* seed) const;

  int m_event = 0;

  ActsTrackingGeometry *m_tGeometry = nullptr;

  ActsExamples::TrkrClusterFittingAlgorithm::Config m_fitCfg;

  SvtxTrackMap *m_trackMap = nullptr;
  SvtxTrackMap *m_directedTrackMap = nullptr;
  TrkrClusterContainer *m_clusterContainer = nullptr;
  ActsSurfaceMaps *m_surfMaps = nullptr;
  
  int m_nBadFits = 0;

  bool m_fitSiliconMMs = false;

  bool m_useMicromegas = true;
  
  bool m_fillSvtxTrackStates = true;

  bool m_actsEvaluator = false;
  std::map<const unsigned int, Trajectory> *m_trajectories = nullptr;
  SvtxTrackMap *m_seedTracks = nullptr;

  std::string m_fieldMap = "";
  TrkrClusterIterationMapv1* _iteration_map = nullptr;
  int _n_iteration = 0;
  std::string _track_map_name = "SvtxTrackMap";
  std::string _seed_track_map_name = "SeedTrackMap";

  unsigned int m_pHypothesis = 211;

  bool m_timeAnalysis = false;
  TFile *m_timeFile = nullptr;
  TH1 *h_eventTime = nullptr;
  TH2 *h_fitTime = nullptr;
  TH1 *h_updateTime = nullptr;
  TH1 *h_stateTime = nullptr;
  TH1 *h_rotTime = nullptr;
};

#endif