d9/d89/PHActsSiliconSeeding_8h_source.html

#ifndef TRACKRECO_PHACTSSILICONSEEDING_H

#define TRACKRECO_PHACTSSILICONSEEDING_H


#include <trackbase/ActsTrackingGeometry.h>


#include <fun4all/SubsysReco.h>

#include <trackbase/TrkrDefs.h>

#include <trackbase/ActsSurfaceMaps.h>


#include <Acts/Utilities/Definitions.hpp>

#include <Acts/Geometry/GeometryIdentifier.hpp>

#include <Acts/Seeding/Seedfinder.hpp>

#include <Acts/Utilities/Units.hpp>


#include <Acts/Seeding/BinFinder.hpp>

#include <Acts/Seeding/SpacePointGrid.hpp>


#include <ActsExamples/EventData/TrkrClusterSourceLink.hpp>


#include <boost/bimap.hpp>


#include <string>

#include <map>

#include <TFile.h>

#include <TH1.h>

#include <TH2.h>


class PHCompositeNode;

class PHG4CylinderGeomContainer;

class SvtxTrackMap;

class SvtxVertexMap;

class TrkrCluster;

class TrkrClusterContainer;

class TrkrHitSetContainer;

class TrkrClusterIterationMapv1;


using SourceLink = ActsExamples::TrkrClusterSourceLink;

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


struct SpacePoint {

  TrkrDefs::cluskey m_clusKey;

  float m_x;

  float m_y;

  float m_z;

  float m_r;

  Acts::GeometryIdentifier m_geoId;

  float m_varianceRphi;

  float m_varianceZ;


  TrkrDefs::cluskey Id() const { return m_clusKey; }


  float x() const { return m_x; }

  float y() const { return m_y; }

  float z() const { return m_z; }

  float r() const { return m_r; }


};


inline bool operator==(SpacePoint a, SpacePoint b) {

  return (a.m_clusKey == b.m_clusKey);

}


using SpacePointPtr = std::unique_ptr<SpacePoint>;

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 useTruthClusters(bool useTruthClusters)

    { m_useTruthClusters = useTruthClusters; }


  void seedAnalysis(bool seedAnalysis)

    { m_seedAnalysis = seedAnalysis; }


  void fieldMapName(const std::string& fieldmap)

    { m_fieldMapName = fieldmap; }


  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 largeGridSpacing(const bool spacing);


  void set_track_map_name(const std::string &map_name) { _track_map_name = map_name; }

  void SetIteration(int iter){_n_iteration = iter;}


 private:


  int getNodes(PHCompositeNode *topNode);

  int createNodes(PHCompositeNode *topNode);


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


  Acts::SeedfinderConfig<SpacePoint> configureSeeder();

  Acts::SpacePointGridConfig configureSPGrid();


  void makeSvtxTracks(GridSeeds& seedVector);


  SpacePointPtr makeSpacePoint(const TrkrDefs::cluskey cluskey,

             const SourceLink& sl);


  std::vector<const SpacePoint*> getMvtxSpacePoints();


  int circleFitSeed(std::vector<TrkrCluster*>& clusters,

        std::vector<Acts::Vector3D>& clusGlobPos,

        double& x, double& y, double& z,

        double& px, double& py, double& pz);


  void circleFitByTaubin(const std::vector<Acts::Vector3D>& globalPositions,

       double& R, double& X0, double& Y0);

  void lineFit(const std::vector<Acts::Vector3D>& globPos,

         double& A, double& B);

  void findRoot(const double R, const double X0, const double Y0,

    double& x, double& y);

  int getCharge(const std::vector<Acts::Vector3D>& globalPos,

    const double circPhi);


  std::vector<TrkrDefs::cluskey> findInttMatches(

            std::vector<Acts::Vector3D>& clusters,

      const double R,

      const double X0,

      const double Y0,

      const double B,

      const double m);


  std::vector<TrkrDefs::cluskey> matchInttClusters(std::vector<Acts::Vector3D>& clusters,

               const double xProj[],

               const double yProj[],

               const double zProj[]);

  void circleCircleIntersection(const double layerRadius,

        const double circRadius,

        const double circX0,

        const double circY0,

        double& xplus,

        double& yplus,

        double& xminus,

        double& yminus);


  void createSvtxTrack(const double x,

           const double y,

           const double z,

           const double px,

           const double py,

           const double pz,

           const int charge,

           std::vector<TrkrCluster*>& clusters,

           std::vector<Acts::Vector3D>& clusGlobPos);

  std::map<const unsigned int, std::pair<std::vector<TrkrCluster*>,std::vector<Acts::Vector3D>>>

    makePossibleStubs(std::vector<TrkrCluster*>& allClusters,

          std::vector<Acts::Vector3D>& clusGlobPos);


  Surface getSurface(TrkrDefs::hitsetkey hitsetkey);


  std::map<const unsigned int, std::pair<std::vector<TrkrCluster*>,std::vector<Acts::Vector3D>>>

    identifyBestSeed(std::map<const unsigned int,

         std::pair<std::vector<TrkrCluster*>,

                   std::vector<Acts::Vector3D>>>);


  void createHistograms();

  void writeHistograms();

  double normPhi2Pi(const double phi);


  ActsTrackingGeometry *m_tGeometry = nullptr;

  SvtxTrackMap *m_trackMap = nullptr;

  TrkrClusterContainer *m_clusterMap = nullptr;

  TrkrHitSetContainer  *m_hitsets = nullptr;

  PHG4CylinderGeomContainer *m_geomContainerIntt = nullptr;

  ActsSurfaceMaps *m_surfMaps = nullptr;


  Acts::SeedfinderConfig<SpacePoint> m_seedFinderCfg;

  Acts::SpacePointGridConfig m_gridCfg;


  float m_minSeedPt = 100;


  int m_maxSeedsPerSpM = 1;


  float m_rMax = 200.;

  float m_rMin = 23.;

  float m_zMax = 300.;

  float m_zMin = -300.;


  float m_gridFactor = 2.3809;


  float m_deltaRMax = 15;


  float m_cotThetaMax = 2.9;


  float m_bField = 1.4 / 1000.;


  std::shared_ptr<Acts::BinFinder<SpacePoint>>

    m_bottomBinFinder, m_topBinFinder;


  int m_event = 0;


  double m_maxSeedPCA = 2.;


  const static unsigned int m_nInttLayers = 4;

  const double m_nInttLayerRadii[m_nInttLayers] =

    {7.188, 7.732, 9.680,10.262};


  double m_rPhiSearchWin = 0.1;


  bool m_useTruthClusters = false;


  bool m_cleanSeeds = false;


  int m_nBadUpdates = 0;

  int m_nBadInitialFits = 0;

  std::string m_fieldMapName = "";

  TrkrClusterIterationMapv1* _iteration_map = nullptr;

  int _n_iteration = 0;

  std::string _track_map_name = "SvtxSiliconTrackMap";


  bool m_seedAnalysis = false;

  TFile *m_file = nullptr;

  TH2 *h_nInttProj = nullptr;

  TH1 *h_nMvtxHits = nullptr;

  TH1 *h_nInttHits = 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