// -------------------------------------------------------------------------
// -----                  CbmLitTrdTrackFinder header file               -----
// -----                  Created 06/07/06  by A. Lebedev               -----
// -------------------------------------------------------------------------


/** CbmLitTrdTrackFinder.h
 *@author A.Lebedev <alebedev@jinr.ru>
 **
 ** 
 **/ 

#ifndef CbmLitTrdTrackFinderHHH
#define CbmLitTrdTrackFinderHHH


#include "CbmTrdTrackFinder.h"

#include "set.h"
#include "map.h"

#include "CbmTrackPropagator.h"
#include "CbmTrackFilter.h"
#include "CbmLitKalmanFilter.h"
#include "CbmLitTrackPropagator.h"
#include "CbmTrackExtrapolator.h"
#include "CbmLitLineTrackExtrapolator.h"
#include "CbmLitRK4TrackExtrapolator.h"

#include "CbmTrdHit.h"
#include "CbmTrdTrack.h"

class TClonesArray;


class CbmLitTrdTrackFinder : public CbmTrdTrackFinder {

public:

    // Default constructor
    CbmLitTrdTrackFinder();

    // Destructor
    virtual ~CbmLitTrdTrackFinder();

    // Initialisation
    // must be implemented in derived classes
    virtual void Init() = 0;

    // Track finding algorithm
    // must be implemented in derived classes
    virtual Int_t DoFind(TClonesArray* hitArray,
                 TClonesArray* trackArray) = 0;
                 
protected:

    // TRD geometry
    // number of stations
    Int_t fNofTrdStations;
    // number of layers for each station
    std::vector<Int_t> fNofTrdLayersPerStation;
    // total number of layers
    Int_t fNofTrdLayers;
    
    // Standalone track finder or not
    Bool_t fIsStandalone;

    // Data
    TClonesArray* fArrayTrdHit;

    // Propagation and filter tools
    CbmTrackExtrapolator *fFieldExtrapolator;
    CbmTrackExtrapolator *fLineExtrapolator;
    CbmTrackPropagator *fFieldPropagator;
    CbmTrackPropagator *fLinePropagator;
    CbmTrackFilter *fFilter;
    
    // Verbosity level
    Int_t fVerbose;

    // Event number
    Int_t fEvents;

    //Number of iterations
    Int_t fNofIter;
    
    // Begin station
    Int_t fBeginStation;
    // End Station
    Int_t fEndStation;
    
    // Maximum number of missing hits in station
    Int_t fMaxNofMissingHitsInStation;
        
    // coefficient before sigma
    Double_t fSigmaCoef;
    
    // uses only with 3x3 geometry for Standalone track-finder
    Double_t fSigmaX_2[3];

    // vector with found TRD tracks
    std::vector<CbmTrdTrack*> fFoundTracks;

    // vector with TRD tracks
    std::vector<CbmTrdTrack*> fTrdTracks;

    // vector with pointers to TrdHits
    std::vector<std::vector<CbmTrdHit*> > fHits;

    // Max measurement error for each layer
    std::vector<Double_t> fMaxSigmaX;
    std::vector<Double_t> fMaxSigmaY;
    
    // set with hits that were used
    std::set<Int_t> fUsedHitsSet;
    
    // Map from pointer to CbmHit to Hit index
    std::map<CbmTrdHit*, Int_t> fHitIdMap;
    

    // Read TRD geometry
    void ReadTrdGeometry();

    // Arrange hits by planes
    void ArrangeHits();

    // Main track following procedure
    void TrackFollowing();

    // Follows track through the station
    void TrackFollowingStation(CbmTrdTrack *pTrack, Int_t Station);
    
    // Process the layer
    inline Bool_t ProcessLayer( Int_t layerInStation,
                                Int_t layer,
                                Int_t iHit,
                                Int_t IndMax[],
                                Int_t nofMissingHits[],  
                                CbmTrdTrack* pTracks[],            
                                CbmTrdHit* pHits[]);

    // Checks if the hit in the area near the track
    bool IsIn(CbmTrdTrack *pTrack, CbmTrdHit *pHit);

    // Kalman Filter update of the tracks
    void UpdateTracks(Int_t Station);

    // Checks found tracks for common hits
    void CheckCommonHits();

    // Defines min and max index of hits 
    // which can be used for futher following 
    void MinMaxIndex(CbmTrdTrack* pTrack, Int_t &IndMin, Int_t &HitCnt, Int_t layer);

    // Adds track candidate 
    void AddTrackCandidate(CbmTrdTrack* pTrack, CbmTrdHit* pHits[], Int_t Station);
   
    // Removes hits which belong to found tracks
    void RemoveHits();

    // Copy tracks to output TClonesArray
    void CopyToOutput(TClonesArray* trackArray);
    
    // Chi squared calculation
    Double_t CalcChi2(CbmTrackParam *pParam, CbmHit* pHit);
    
    //
    static bool CmpYUp(const CbmTrdHit *m1, const CbmTrdHit *m2){
      return m1->GetY() < m2->GetY();
    }
    //
    static bool CmpXUp(const CbmTrdHit *m1, const CbmTrdHit *m2){
      return m1->GetX() < m2->GetX();
    }
    
    static Bool_t CompareChi2(const CbmTrdTrack* a, const CbmTrdTrack* b) {
        return ( a->GetChi2() < b->GetChi2() );
    };

public:

     // Public accessors
    const Int_t& GetVerbose() const {return fVerbose;};

    // Public modifiers
    void SetVerbose(const Int_t& verbose) {fVerbose = verbose;};


    ClassDef(CbmLitTrdTrackFinder, 1);

};


#endif