KalmanFilterAlg.h

Go to the documentation of this file.

#ifndef KALMANFILTERALG_H
#define KALMANFILTERALG_H

#include <map>
#include <memory>
#include <vector>

#include "lardata/RecoObjects/Propagator.h"

namespace fhicl {
  class ParameterSet;
}
namespace trkf {
  class KETrack;
  class KGTrack;
  class KTrack;
  class KHitContainer;
}

#include "TCanvas.h"

class TMarker;
class TPaveText;
class TVirtualPad;

namespace trkf {

  class KalmanFilterAlg {
  public:
    KalmanFilterAlg(const fhicl::ParameterSet& pset);

    // Accessors.

    bool getTrace() const { return fTrace; } 
    int getPlane() const { return fPlane; }  

    // Modifiers.

    void setTrace(bool trace) { fTrace = trace; } 
    void setPlane(int plane) { fPlane = plane; }  

    // Methods.

    bool buildTrack(const KTrack& trk,                   // Starting track.
                    KGTrack& trg,                        // Result global track.
                    const Propagator& prop,              // Propagator.
                    const Propagator::PropDirection dir, // Direction.
                    KHitContainer& hits,                 // Candidate measurements.
                    bool linear) const;                  // Linear flag.

    bool smoothTrack(KGTrack& trg,                  // Global track to be smoothed.
                     KGTrack* trg1,                 // Result of unidirectional fit.
                     const Propagator& prop) const; // Propagator.

    bool extendTrack(KGTrack& trg,               // Global track.
                     const Propagator& prop,     // Propagator.
                     KHitContainer& hits) const; // Candidate measurements.

    bool fitMomentumRange(const KGTrack& trg,     // Global track.
                          KETrack& tremom) const; // Track with updated momentum.

    bool fitMomentumMS(const KGTrack& trg,     // Global track.
                       const Propagator& prop, // Propagator.
                       KETrack& tremom) const; // Track with updated momentum.

    bool fitMomentum(const KGTrack& trg,     // Global track.
                     const Propagator& prop, // Propagator.
                     KETrack& tremom) const; // Track with updated momentum.

    bool updateMomentum(const KETrack& tremom,  // Track with momentum estimate.
                        const Propagator& prop, // Propagator.
                        KGTrack& trg) const;    // Global track to be updated.

    bool smoothTrackIter(int niter,                     // Number of iterations.
                         KGTrack& trg,                  // Global track.
                         const Propagator& prop) const; // Propagator.

    void cleanTrack(KGTrack& trg) const;

  private:
    // Fcl parameters.

    bool fTrace;               
    double fMaxPErr;           
    double fGoodPErr;          
    double fMaxIncChisq;       
    double fMaxSeedIncChisq;   
    double fMaxSmoothIncChisq; 
    double fMaxEndChisq;       
    int fMinLHits;             
    double fMaxLDist;          
    double fMaxPredDist;       
    double fMaxSeedPredDist;   
    double fMaxPropDist;       
    double fMinSortDist;       
    double fMaxSortDist;       
    int fMaxSamePlane;         
    double fGapDist;           
    int fMaxNoiseHits;         
    double fMinSampleDist;     
    bool fFitMomRange;         
    bool fFitMomMS;            
    bool fGTrace;              
    double fGTraceWW;          
    double fGTraceWH;          
    double fGTraceXMin;        
    double fGTraceXMax;        
    std::vector<double> fGTraceZMin; 
    std::vector<double> fGTraceZMax; 

    // Other attributes.

    int fPlane;                                              
    mutable std::vector<std::unique_ptr<TCanvas>> fCanvases; 
    mutable std::vector<TVirtualPad*> fPads;                 
    mutable TVirtualPad* fInfoPad;                           
    mutable TPaveText* fMessages;                            
    mutable std::map<int, TMarker*> fMarkerMap;              
  };
}

#endif