KalmanFilterAlg.h

Go to the documentation of this file.

#ifndef KALMANFILTERALG_H
#define KALMANFILTERALG_H

#include <vector>
#include <memory>
#include "lardata/RecoObjects/KGTrack.h"
#include "lardata/RecoObjects/Propagator.h"
#include "lardata/RecoObjects/KHitContainer.h"
#include "fhiclcpp/ParameterSet.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "TCanvas.h"
#include "TMarker.h"
#include "TPaveText.h"

namespace trkf {

  class KalmanFilterAlg {
  public:

    KalmanFilterAlg(const fhicl::ParameterSet& pset);

    ~KalmanFilterAlg();

    void reconfigure(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.
                          const Propagator* prop,          // Propagator.
                          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