PHActsSiliconSeeding.h

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

#ifndef TRACKRECO_PHACTSSILICONSEEDING_H
#define TRACKRECO_PHACTSSILICONSEEDING_H

#include <fun4all/SubsysReco.h>
#include <trackbase/TrkrDefs.h>
#include <trackbase/ActsGeometry.h>
#include <trackbase/ClusterErrorPara.h>

#include <Acts/Definitions/Algebra.hpp>
#include <Acts/Geometry/GeometryIdentifier.hpp>
#include <Acts/Seeding/SeedFinder.hpp>
#include <Acts/Definitions/Units.hpp>

#include <Acts/Seeding/BinFinder.hpp>
#include <Acts/Seeding/SpacePointGrid.hpp>

#include <trackbase/SpacePoint.h>

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

class PHCompositeNode;
class PHG4CylinderGeomContainer;
class TrackSeed;
class TrackSeedContainer;
class TrkrCluster;
class TrkrClusterContainer;
class TrkrClusterIterationMapv1;

using GridSeeds = std::vector<std::vector<Acts::Seed<SpacePoint>>>;

class PHActsSiliconSeeding : public SubsysReco
{
 public:
  PHActsSiliconSeeding(const std::string& name = "PHActsSiliconSeeding");
  int Init(PHCompositeNode *topNode) override;
  int InitRun(PHCompositeNode *topNode) override;
  int process_event(PHCompositeNode *topNode) override;
  int End(PHCompositeNode *topNode) override;

  void setunc(float unc) { m_uncfactor = unc; }
  void useTruthClusters(bool useTruthClusters)
    { m_useTruthClusters = useTruthClusters; }

  void seedAnalysis(bool seedAnalysis)
    { m_seedAnalysis = seedAnalysis; }


  void setRPhiSearchWindow(const float win) 
  { 
    m_rPhiSearchWin = win; 
    std::cout << "Search window is " << m_rPhiSearchWin<<std::endl;
  }


  void cleanSeeds(bool cleanSeeds)
    { m_cleanSeeds = cleanSeeds;}
 
  void rMax(const float rMax)
  { m_rMax = rMax; }
  void rMin(const float rMin)
  { m_rMin = rMin; }
  void zMax(const float zMax)
  {m_zMax = zMax; }
  void zMin(const float zMin)
  {m_zMin = zMin; }
  void deltaRMax(const float deltaRMax)
  {m_deltaRMax = deltaRMax;}
  void cotThetaMax(const float cotThetaMax)
  {m_cotThetaMax = cotThetaMax;}
  void gridFactor(const float gridFactor)
  {m_gridFactor = gridFactor;}
  void sigmaScattering(const float sigma)
  { m_sigmaScattering = sigma; }
  void maxPtScattering(const float pt)
  { m_maxPtScattering = pt; }
  void sigmaError(const float sigma)
  { m_sigmaError = sigma; }
  void zalign(const float z)
  { m_zalign = z; }
  void ralign(const float r) 
  { m_ralign = r; }
  void tolerance(const float tolerance)
  { m_tolerance = tolerance; }
  void helixcut(const float cut)
  { m_helixcut = cut; }

  
  void largeGridSpacing(const bool spacing);

  void set_track_map_name(const std::string &map_name) { _track_map_name = map_name; }
  void iteration(int iter){m_nIteration = iter;}
  void searchInIntt() { m_searchInIntt = true; }

 private:

  int getNodes(PHCompositeNode *topNode);
  int createNodes(PHCompositeNode *topNode);

  GridSeeds runSeeder(std::vector<const SpacePoint*>& spVec);

  void configureSeeder();
  void configureSPGrid();
  Acts::SeedFilterConfig configureSeedFilter();

  void makeSvtxTracks(GridSeeds& seedVector);
  
  SpacePointPtr makeSpacePoint(
    const Surface& surf,
    const TrkrDefs::cluskey,
    //    const TrkrCluster* clus);
    TrkrCluster* clus);
  
  std::vector<const SpacePoint*> getSiliconSpacePoints(Acts::Extent& rRangeSPExtent);
  void printSeedConfigs(Acts::SeedFilterConfig &sfconfig);

  std::vector<TrkrDefs::cluskey> findInttMatches(
                        std::vector<Acts::Vector3>& clusters,
                        TrackSeed& seed);

  std::vector<TrkrDefs::cluskey> matchInttClusters(std::vector<Acts::Vector3>& clusters,
                                                   TrackSeed& seed,
               const double xProj[],
                                                   const double yProj[],
                                                   const double zProj[]);

  void createHistograms();
  void writeHistograms();
  double normPhi2Pi(const double phi);

  ActsGeometry *m_tGeometry = nullptr;
  TrackSeedContainer *m_seedContainer = nullptr;
  TrkrClusterContainer *m_clusterMap = nullptr;
  PHG4CylinderGeomContainer *m_geomContainerIntt = nullptr;
  
  Acts::SeedFinderConfig<SpacePoint> m_seedFinderCfg;
  Acts::SpacePointGridConfig m_gridCfg;
  Acts::SpacePointGridOptions m_gridOptions;
  Acts::SeedFinderOptions m_seedFinderOptions;

  bool m_searchInIntt = false;

  float m_minSeedPt = 100 * Acts::UnitConstants::MeV;
  float m_uncfactor = 3.18;
    
  int m_maxSeedsPerSpM = 1;

  float m_rMax = 200. * Acts::UnitConstants::mm;
  float m_rMin = 23. * Acts::UnitConstants::mm;
  float m_zMax = 500. * Acts::UnitConstants::mm;
  float m_zMin = -500. * Acts::UnitConstants::mm;

  float m_helixcut = 1;
  float m_tolerance = 1.1 * Acts::UnitConstants::mm;
  float m_ralign = 0;
  float m_zalign = 0;
  float m_maxPtScattering = 10;
  float m_sigmaScattering = 5.;
  float m_sigmaError = 5;

  float m_gridFactor = 2.3809;

  float m_deltaRMax = 15 * Acts::UnitConstants::mm;
  float m_deltaRMin = 1. * Acts::UnitConstants::mm;
  float m_cotThetaMax = 2.9;
  
  float m_impactMax = 20 * Acts::UnitConstants::mm;

  int m_numPhiNeighbors = 1;

  float m_bField = 1.4 * Acts::UnitConstants::T;
  std::vector<std::pair<int, int> > zBinNeighborsTop;
  std::vector<std::pair<int, int> > zBinNeighborsBottom;
  int nphineighbors = 1;
  std::shared_ptr<const Acts::BinFinder<SpacePoint>> 
    m_bottomBinFinder, m_topBinFinder;

  int m_event = 0;

  double m_maxSeedPCA = 2.;
  
  const static unsigned int m_nInttLayers = 4;
  double m_nInttLayerRadii[m_nInttLayers] = {0};
  
  double m_rPhiSearchWin = 0.1;

  bool m_useTruthClusters = false;

  bool m_cleanSeeds = false;

  int m_nBadUpdates = 0;
  int m_nBadInitialFits = 0;
  TrkrClusterIterationMapv1* _iteration_map = nullptr;
  int m_nIteration = 0;
  std::string _track_map_name = "SiliconTrackSeedContainer";
  ClusterErrorPara _ClusErrPara;

  bool m_seedAnalysis = false;
  TFile *m_file = nullptr;
  TH2 *h_nInttProj = nullptr;
  TH1 *h_nMvtxHits = nullptr;
  TH1 *h_nInttHits = nullptr;
  TH1 *h_nMatchedClusters = nullptr;
  TH2 *h_nHits = nullptr;
  TH1 *h_nSeeds = nullptr;
  TH1 *h_nActsSeeds = nullptr;
  TH1 *h_nTotSeeds = nullptr;
  TH1 *h_nInputMeas = nullptr;
  TH1 *h_nInputMvtxMeas = nullptr;
  TH1 *h_nInputInttMeas = nullptr;
  TH2 *h_hits = nullptr;
  TH2 *h_zhits = nullptr;
  TH2 *h_projHits = nullptr;
  TH2 *h_zprojHits = nullptr;
  TH2 *h_resids = nullptr;

};


#endif