StFwdTrackMaker.h

#ifndef ST_FWD_TRACK_MAKER_H
#define ST_FWD_TRACK_MAKER_H

#include "StChain/StMaker.h"

#ifndef __CINT__
#include "GenFit/Track.h"
#include "StFwdTrackMaker/include/Tracker/FwdHit.h"
#endif

#include "FwdTrackerConfig.h"
#include "TVector3.h"
#include "TMatrix.h"

namespace KiTrack {
class IHit;
};

namespace genfit {
  class Track;
  class GFRaveVertex;
}

class ForwardTracker;
class ForwardTrackMaker;
class FwdDataSource;
class FwdHit;
class StarFieldAdaptor;

class StGlobalTrack;
class StRnDHitCollection;
class StTrack;
class StTrackDetectorInfo;
class SiRasterizer;
class McTrack;

class StFcsDb;

// ROOT includes
#include "TNtuple.h"
#include "TTree.h"
// STL includes
#include <vector>
#include <memory>
class StFwdTrack;
class GenfitTrackResult;


class StFwdTrackMaker : public StMaker {

    ClassDef(StFwdTrackMaker, 0);

  public:
    StFwdTrackMaker();
    ~StFwdTrackMaker(){/* nada */};

    int Init();
    int Finish();
    int Make();
    void Clear(const Option_t *opts = "");

    enum { kInnerGeometry,
           kOuterGeometry };

    void SetConfigFile(std::string n) {
        mConfigFile = n;
        LoadConfiguration();
    }
    void LoadConfiguration();
    void SetVisualize( bool _viz ) { mVisualize = _viz; }

    vector<StFwdTrack*> mFwdTracks;

    vector<FwdHit> &GetFttHits() { return mFwdHitsFtt; }
    vector<FwdHit> &GetFstHits() { return mFwdHitsFst; }

  #ifndef __CINT__
    // Get the FwdTracker object
    std::shared_ptr<ForwardTracker> GetForwardTracker() { return mForwardTracker; }
    const std::vector<Seed_t> &getTrackSeeds() const;
    const std::vector<GenfitTrackResult> &getFitResults() const;
  #endif
    TVector3 GetEventPrimaryVertex();

  private:
  protected:

  StFcsDb* mFcsDb = 0; // Pointer to fcs db object
  
    // Event Filters
    float mEventFilterMinTofMult = 2;
    bool  mEventFilterRequireEventVertex = false;
    bool  mEventFilterRequireVpdVertex = true;
    float mEventFilterMinVpdZ = -99;
    float mEventFilterMaxVpdZ = 99;

    // for Wavefront OBJ export
    size_t eventIndex = 0; // counts up for processed events
    size_t mEventNum = 0; // global event num (index)
    TVector3 mEventVertex; // primary vertex used in fwd tracking this event

    std::string mConfigFile;

    std::map<std::string, TH1 *> mHistograms;

    bool mVisualize = false; // if true,write out a Wavefront OBJ to visualize the event in 3D
    vector<TVector3> mFttHits;
    vector<TVector3> mFstHits;
    vector<TVector3> mFcsClusters;
    vector<float> mFcsClusterEnergy;
    vector<TVector3> mFcsPreHits;

    std::vector< genfit::GFRaveVertex * > mRaveVertices;
    vector<float> mFttZFromGeom, mFstZFromGeom;

    void ProcessFwdTracks();
    void FillEvent();
    void FillTrackDeltas();
    bool SkipEvent();

    StFwdTrack * makeStFwdTrack( GenfitTrackResult &gtr, size_t indexTrack );

    // I could not get the library generation to succeed with these.
    // so I have removed them
    #ifndef __CINT__
        TMatrixDSym mEventVertexCov; // covariance matrix for the primary vertex
        enum FwdVertexSource { kFwdVertexSourceUnknown, kFwdVertexSourceNone, kFwdVertexSourceTpc, kFwdVertexSourceMc, kFwdVertexSourceVpd }; // unknown means we havent looked yet
        FwdVertexSource mFwdVertexSource = StFwdTrackMaker::kFwdVertexSourceUnknown;
        vector<FwdHit> mFwdHitsFtt;
        vector<FwdHit> mFwdHitsFst;
        std::shared_ptr<SiRasterizer> mSiRasterizer;
        FwdTrackerConfig mFwdConfig;
        std::shared_ptr<ForwardTracker> mForwardTracker;
        std::shared_ptr<FwdDataSource> mForwardData;
        size_t loadMcTracks( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap );
        void loadFcs();
        void loadFttHits( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap, int count = 0 );
        void loadFttHitsFromStEvent( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap, int count = 0 );
        void loadFttHitsFromGEANT( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap, int count = 0 );

        int loadFstHits( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap );
        int loadFstHitsFromMuDst( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap );
        int loadFstHitsFromGEANT( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap );
        int loadFstHitsFromStEvent( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap );
        int loadFstHitsFromStRnDHits( std::map<int, std::shared_ptr<McTrack>> &mcTrackMap, std::map<int, std::vector<KiTrack::IHit *>> &hitMap );
    #endif


    void FitVertex();

    static std::string defaultConfig;
    bool configLoaded = false;
    TString mGeoCache;

    // Helper functions for modifying configuration
    public:
    void setOutputFilename( std::string fn ) { mFwdConfig.set( "Output:url", fn ); }
    void setFttHitSource( std::string source ) { mFwdConfig.set( "Source:ftt", source ); }

    void setUseFstRasteredGeantHits( bool use = true ){ mFwdConfig.set<bool>( "SiRasterizer:active", use ); }
    void setFstRasterR( double r = 3.0 /*cm*/ ){ mFwdConfig.set<double>( "SiRasterizer:r", r ); }
    void setFstRasterPhi( double phi = 0.00409 /*2*pi/(12*128)*/ ){ mFwdConfig.set<double>( "SiRasterizer:phi", phi ); }

    //Track Finding
    void setSeedFindingWithFstFttSequential() { mFwdConfig.set( "TrackFinder:source", "seq" ); }
    void setSeedFindingWithFstFttSimultaneous() { mFwdConfig.set( "TrackFinder:source", "sim" ); }
    void setSeedFindingWithFtt() { mFwdConfig.set( "TrackFinder:source", "ftt" ); }
    void setSeedFindingWithFst() { mFwdConfig.set( "TrackFinder:source", "fst" ); }
    void setSeedFindingNumInterations( int n = 1 ) { mFwdConfig.set<int>("TrackFinder:nIterations", n); }
    void setSeedFindingNumPhiSlices( int n = 8 ) { mFwdConfig.set<int>("TrackFinder.Iteration:nPhiSlices", n); }
    void setSeedFindingConnectorDistance( int d = 1 ) { mFwdConfig.set<int>( "TrackFinder.Connector:distance", d ); }
    void setSeedFindingUseSubsetNN( bool use = true ) { mFwdConfig.set<bool>( "TrackFinder.SubsetNN:active", use ); }
    void setSeedFindingMinHitsOnTrack( int n = 3 ) { mFwdConfig.set<int>( "TrackFinder.SubsetNN:min-hits-on-track", n ); }
    void setSeedFindingUseHitRemover( bool use = true ) { mFwdConfig.set<bool>( "TrackFinder.HitRemover:active", use ); }
    void setUseTruthSeedFinding( bool use = true ) { mFwdConfig.set<bool>( "TrackFinder:active", !use ); }

    // Track Fitting
    void setTrackFittingOff() { mFwdConfig.set( "TrackFitter:active", "false" ); }
    void setFittingMaterialEffects( bool mat = true) { mFwdConfig.set<bool>( "TrackFitter:materialEffects", mat ); }
    void setPrimaryVertexSigmaXY( double sXY ) { mFwdConfig.set<double>( "TrackFitter.Vertex:sigmaXY", sXY ); }
    void setPrimaryVertexSigmaZ(  double sZ ) { mFwdConfig.set<double>( "TrackFitter.Vertex:sigmaZ", sZ ); }
    // TODO: add options for beamline constraint
    void setZeroB( bool zeroB = true ) { mFwdConfig.set<bool>( "TrackFitter:zeroB", zeroB ); }
    void setConstB( bool constB = true ) { mFwdConfig.set<bool>( "TrackFitter:constB", constB ); }
    void setUseMcSeedForFit( bool mcSeed = true ) { mFwdConfig.set<bool>( "TrackFitter:mcSeed", mcSeed ); }

    void setTrackRefit( bool refit = true) { mFwdConfig.set<bool>( "TrackFitter:refit", refit ); }

    void setMaxFailedHitsInFit( int n = -1 /*no lim*/ ) {mFwdConfig.set<int>("TrackFitter.KalmanFitterRefTrack:MaxFailedHits", n);}
    void setFitDebugLvl( int level = 0 /*0=no output*/ ) {mFwdConfig.set<int>("TrackFitter.KalmanFitterRefTrack:DebugLvl", level); }
    void setFitMaxIterations( int n=4 ) {mFwdConfig.set<int>("TrackFitter.KalmanFitterRefTrack:MaxIterations", n); }
    void setFitMinIterations( int n = 1) {mFwdConfig.set<int>("TrackFitter.KalmanFitterRefTrack:MinIterations", n); }

    void setSmearMcPrimaryVertex( bool pvs = true ) { mFwdConfig.set<bool>( "TrackFitter.Vertex:smearMcVertex", pvs ); }

    void setGeoCache( TString gc ) { mGeoCache = gc; }

    void setConfigKeyValue( std::string k, std::string v ){
      mFwdConfig.set( k, v );
    }

    void setCrit2( std::string name, double min, double max ){
      for ( auto p : mFwdConfig.childrenOf( "TrackFinder.Iteration.SegmentBuilder" ) ){
        auto nName = mFwdConfig.get<std::string>( p + ":name", "DNE" );
        if (nName == name) {
          LOG_DEBUG << "Setting Crit2=" << nName << " (min=" << min << ", max=" << max << ")" << endm;
          mFwdConfig.set<double>(p + ":min", min );
          mFwdConfig.set<double>(p + ":max", max );
          return;
        }
      } // loop on existing crit2
      // if we got here then the crit did not exist

    }

    void setCrit3( std::string name, double min, double max ){
      for ( auto p : mFwdConfig.childrenOf( "TrackFinder.Iteration.ThreeHitSegments" ) ){
        auto nName = mFwdConfig.get<std::string>( p + ":name", "DNE" );
        if (nName == name) {
          LOG_DEBUG << "Setting Crit3=" << nName << " (min=" << min << ", max=" << max << ")" << endm;
          mFwdConfig.set<double>(p + ":min", min );
          mFwdConfig.set<double>(p + ":max", max );
          return;
        }
      } // loop on existing crit3
      // if we got here then the crit did not exist
    }

};

#endif