// -------------------------------------------------------------------------
// -----                  CbmLitTrackFinder header file               -----
// -----                  Created 12/11/07  by A. Lebedev               -----
// -------------------------------------------------------------------------


/** CbmLitTrackFinder.h
 *@author A.Lebedev <andrey.lebedev@gsi.de>
 **
 ** 
 **/ 

#ifndef CBMLITTRACKFINDER_H
#define CBMLITTRACKFINDER_H

#include "base/CbmTool.h"
#include "CbmTrkHit.h"
#include "base/CbmLitTrack.h"

#include <set>
#include <map>
#include <vector>

class CbmTrackPropagator;
class CbmTrackUpdate;
class CbmTrackExtrapolator;
class CbmLitKalmanFilter;

class TClonesArray;


class CbmLitTrackFinder
{
//: public CbmTool {

public:

    // Default constructor
    CbmLitTrackFinder();

    // Destructor
    virtual ~CbmLitTrackFinder();

    // Initialisation
  //  virtual void Init();

    // Track finding algorithm
  //  virtual Int_t DoFind(TClonesArray* hitArray,
  //                       TClonesArray* trackArray);
                 
protected:

    // Detector geometry
    // number of stations
    Int_t fNofStations;
    // number of layers per each station
    std::vector<Int_t> fNofLayersPerStation;
    // number of layers
    Int_t fNofLayers;
    
    // Data
    TClonesArray* fHitArray;
    //TClonesArray* fTrackArray;

    // Propagation and track updater tools
    CbmTrackExtrapolator *fExtrapolator;
    // CbmTrackExtrapolator *fExtrapolator;
    CbmTrackPropagator *fPropagator;
    // CbmTrackPropagator *fLinePropagator;
    CbmTrackUpdate *fFilter;
    
    // is standalone tracking or not
    Bool_t fIsStandalone;
    
    // Verbosity level
    Int_t fVerbose;

    // Event number
    Int_t fEvents;

    //Number of iterations
    Int_t fNofIter;
    
    // station to start the search
    Int_t fBeginStation;
    // station to end the search
    Int_t fEndStation;
    
    // Maximum number of missing hits in station
    Int_t fMaxNofMissingHitsInStation;
        
    // coefficient before sigma
    Double_t fSigmaCoef;
    
    // if use precalculated search regions then it should be true
    Bool_t fPrecalcSearchRegions;  
    
    // true if CbmTrackUpdate has to be used 
    // during the following through the station
    Bool_t fApplyUpdateInLayer;
    
    // max acceptable number of shared hits
    Int_t fNofSharedHits; 

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

    // vector with tracks
    std::vector<CbmLitTrack*> fTracks;

    // vector with pointers to hits
    std::vector<std::vector<CbmTrkHit*> > fHits;

    // Max measurement error for each layer
    std::vector<Double_t> fMaxErrX;
    std::vector<Double_t> fMaxErrY;
    
    // used only for precalculated tables of deviations
    std::vector<Double_t> fSigmaX;
    std::vector<Double_t> fSigmaY;
    
    // layer z positions
    std::vector<Double_t> fLayerZPos;
    
    // set with hits that were used
    std::set<Int_t> fUsedHitsSet;
    
    // Map from pointer to CbmTrkHit to Hit index
    std::map<CbmTrkHit*, Int_t> fHitIdMap;

    // Read detector geometry
    virtual void ReadDetectorGeometry();

    // Arrange hits by layers
    void ArrangeHits();    

    // Main track following procedure
    void TrackFollowing();

    // Follows track through the station
    void TrackFollowingStation(CbmLitTrack *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[],  
                                CbmLitTrack* pTracks[],            
                                CbmTrkHit* pHits[]);

    // Checks if the hit in the area near the track
    bool IsIn(CbmLitTrack *pTrack, CbmTrkHit *pHit);    
    
    // Defines min and max index of hits 
    // which can be used for futher following 
    void MinMaxIndex(CbmLitTrack* pTrack, Int_t &IndMin, Int_t &HitCnt, Int_t layer);
    
    // Adds track candidate 
    void AddTrackCandidate(CbmLitTrack* pTrack, CbmTrkHit* pHits[], Int_t Station);
    
    // Update of the tracks
    void UpdateTracks(Int_t Station);

    // Checks found tracks for common hits
    void CheckCommonHits();
    
    // Chi squared calculation
    Double_t CalcChi2(CbmTrackParam *pParam, CbmTrkHit* pHit);

    // Removes hits which belong to found tracks
    void RemoveHits();
  
    //
    static Bool_t CmpYUp(const CbmTrkHit *m1, const CbmTrkHit *m2){
      return m1->GetY() < m2->GetY();
    }
    
    //
    static Bool_t CmpXUp(const CbmTrkHit *m1, const CbmTrkHit *m2){
      return m1->GetX() < m2->GetX();
    }
    
    static Bool_t CompareChi2(const CbmLitTrack* a, const CbmLitTrack* b) {
        return ( (a->GetChi2() / a->GetNDF()) < (b->GetChi2() / b->GetNDF()) );
    };

public:

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

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


    ClassDef(CbmLitTrackFinder, 1);

};


#endif