// -----------------------------------------------------------------------
// -----                    CbmL1CATrdTrackFinderSA                  -----
// -----            Created 2/12/2006 by A. Bubak & M. Krauze        -----
// -----------------------------------------------------------------------

/** CbmL1CATrdTrackFinderSA_Hits
 *@author A.Bubak<abubak@nuph.us.edu.pl> & M.Krauze<meszik@nuph.us.edu.pl>
 ** Algorithm for track finding in TRD, based on Cellular Automathon algorithm
 **/


#ifndef CBML1CATRDTRACKFINDERSA_HITS
#define CBML1CATRDTRACKFINDERSA_HITS

#include "TStopwatch.h"

#include <vector>
#include <map>
#include "CbmTrdTrackFinder.h"
#include "CbmTrdFitTracks.h"
#include <CbmTrdTrackFitterKF.h>
#include <CbmTrdTrackFitter.h>
#include "CbmL1TrdTracklet.h"
#include "CbmL1TrdTracklet4.h"


class TClonesArray;
class CbmTrdTrack;
class CbmTrdHit;
class CbmKF;
class CbmKFTrack;
class TH1F;
class TH2F;
class CbmGeoTrdPar;

class CbmL1CATrdTrackFinderSA : public CbmTrdTrackFinder {

 public:

  /** Default constructor **/
  CbmL1CATrdTrackFinderSA();

  /** Destructor **/
  virtual ~CbmL1CATrdTrackFinderSA();

  /** Initialisation **/
  void Init();

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

 private:

  CbmGeoTrdPar *TrdPar;
    
  /** Event counter **/
  Int_t fEvents;

  Int_t fNofEvents;

  /** Data branches **/
  TClonesArray* fArrayTrdHit;
  TClonesArray* fArrayStsTrack;
  TClonesArray* fArrayKFTrdHit;
  TClonesArray* fArrayTrdTrack;

  /** Arrays of MC information **/
  TClonesArray* fMCTrackArray;
  TClonesArray* fMCPointArray;

  TClonesArray* fTrdSegments;

  //CbmL1TrackFitter* fTrackFitter;
  //CbmTrdTrackFitterKF* fTrackFitter;
  CbmTrdTrackFitter* trdTrackFitter;
  //   CbmTrdFitTracks*   trdFitTracks;
    
  Int_t fTrackArrayInd;

  /** Verbosity level **/
  Int_t fVerbose;

  /** Pid assumption. Default value - pion PDG 211. **/
  Int_t fPid;

  /** Chi2 to hit cut **/
  Double_t fChi2Cut;

  /** TRD layout **/
  Int_t fNoTrdStations;
  Int_t fNoTrdPerStation;

  /** Array of sorted TRD hits **/
  Int_t fNoTrdHits[12];
  Int_t fTrdHitIndex[12][10000];

  /** Arrays for TRD tracks **/
  vector<CbmTrdTrack*> fvTempArray;
  vector<CbmTrdTrack*> fvFoundTracks;

  /** Map from hit index to boolean flag
   ** 0 - hit is free
   ** 1 - hit is attached
   **/
  map<Int_t, Bool_t> fmapHitUsed;

  /** Map from sts track index to boolean flag **/
  map<Int_t, Bool_t> fmapStsTrackUsed;

  /** Translation hitIndex in HitArray to Y value **/
  map<Double_t, Int_t> fMapTransl_YIdn;

  /**  Structure contains trd hits divided per given station **/
  struct LayerWithHits
  {
    Int_t    hitIndex;
    Int_t    mcTrackID;
    Double_t X;
    Double_t Y;
    Double_t Z;
    Double_t DX;
    Double_t DY;
    Int_t    planeID;
  } planeHits;
  
  inline static Bool_t CompareY(LayerWithHits A, LayerWithHits B){
    return (A.Y < B.Y);
  };
  
  /** Structure contains temporary values of track candidates **/
  struct TempTrackStruct
  {
    Double_t Chi2;
    Int_t M[12];
  } tempTrack;

  inline static Bool_t CompareChi2(TempTrackStruct A, TempTrackStruct B){
    return (A.Chi2 < B.Chi2);
  };


  //--- vector with hits which belong to given trd plane
  vector <LayerWithHits> fvTrdHitArr[12];
  vector <LayerWithHits> fvTrdPointArr[12];

  Double_t DistTrackletCutY(TClonesArray* fHit,
			    Int_t iIndexFirst,
			    Int_t iIndexSecond);

  Double_t DistTrackletCutX(TClonesArray* trdHit,
			    Int_t iIndexFirst,
			    Int_t iIndexSecond);

  // iterators to vectors
  vector<Int_t>::iterator iStation1;
  vector<Int_t>::iterator iStation2;

  vector<Int_t>::iterator fImapSt1; 
  vector<Int_t>::iterator fImapSt2; 

  vector<CbmL1TrdTracklet4*>::iterator itTrackletsLeft;
  vector<CbmL1TrdTracklet4*>::iterator itTrackletsRight;

  Int_t
    iHitMap1,
    iHitMap2;
  Double_t
    iHitMapY1,
    iHitMapY2;

  /** Z position selected trd layers **/
  Double_t
    fTrd13_Z,
    fTrd14_Z,
    fTrd21_Z,
    fTrd24_Z,
    fTrd31_Z;


  /** To check time comsumption of procedures **/
  TStopwatch
    createSegments,
    findNeighbour,
    createSPs,
    createSPs_SL,
    sortSPs,
    doFind,
    sortHits,
    tagTracks,
    createTracks,
    selectTracks,
    delTime,
    secondLoopTime;
  
  Double_t
    totCreateSegments,
    totFindNeighbour,
    totCreateSPs,
    totCreateSPs_SL,
    totSortSPs,
    totDoFind,
    totSortHits,
    totTagTracks,
    totCreateTracks,
    totDelTime,
    totSecondLoopTime,
    totSelectTracks;

  

  void  DeleteTracklets(vector<CbmL1TrdTracklet4*> vect);
  void  DeleteTracklets(vector<CbmL1TrdTracklet*> vect);

  Double_t DistTwoTrackletsX(TClonesArray* fHit, 
			     Int_t iIndexFirst,
			     Int_t iIndexSecond, 
			     Double_t zed);

  Double_t DistTwoTrackletsY(TClonesArray* fHit, 
			     Int_t iIndexFirst,
			     Int_t iIndexSecond, 
			     Double_t zed);  


  void CreateSpacePoints(vector <LayerWithHits> vTrdHitArrayA,
			 vector <LayerWithHits> vTrdHitArrayB,
			 vector <CbmL1TrdTracklet*>& clSpacePointsAB,
			 Double_t  sigmaA, Double_t sigmaB);


  Bool_t CreateSegments(vector <CbmL1TrdTracklet*>clSpacePointsAB,
			vector <CbmL1TrdTracklet*>clSpacePointsCD,
			vector <CbmL1TrdTracklet4*>& clTrackletsAD,
			Double_t dX, Double_t dY);

  Bool_t TagSegments(vector <CbmL1TrdTracklet4*>& clTrackletsA,
		     vector <CbmL1TrdTracklet4*>& clTrackletsB);

  Bool_t CreateTracks(vector <CbmL1TrdTracklet4*> clTracklets14,
		      vector <CbmL1TrdTracklet4*> clTracklets58,
		      vector <CbmL1TrdTracklet4*> clTracklets912,
		      map<Int_t,Int_t> &mapUsedHits,
		      Bool_t removeUsedHits,
		      Bool_t competition = true,
		      TClonesArray *trackArray = NULL);
 
  Bool_t CreateAndManageSegments(vector <CbmL1TrdTracklet4*> clTracklets14,
				 vector <CbmL1TrdTracklet4*> clTracklets58,
				 vector <CbmL1TrdTracklet4*> clTracklets912,
				 TClonesArray *trackArray);

  Bool_t OverlapsHitsXY(Int_t posA,
			Int_t posB);

  Bool_t FindNeighbour(vector <CbmL1TrdTracklet4*> &v1,
		       vector <CbmL1TrdTracklet4*> &v2,
		       Double_t dY, Double_t dX);
		

  Double_t FitLinear(CbmTrdTrack *tr, Int_t var); //var = {1,2} => which coordinate to use   
  Double_t FitLinear(Int_t M[], Int_t var); //var = {1,2} => which coordinate to use   
  Double_t Fit(CbmTrdTrack *tr);
  Double_t Fit(Int_t M[]);
  Double_t FitKF(Int_t M[]);
  Double_t FitTLinearFitter(Int_t M[]);


  /** Create histogramms **/
  void CreateHistogramms();

  /** Activates data branches **/
  void DataBranches();

  /** Determine detector layout **/
  void TrdLayout();

 public:

  /** Write histogramms **/
  void WriteHistogramms();

  /** Public accessors **/
  inline const Int_t& GetVerbose() const {return fVerbose;};
  inline const Int_t& GetPid() const {return fPid;};
  inline const Double_t& GetChi2Cut() const {return fChi2Cut;};

//  Int_t Rejection(Double_t Procent, Int_t num);
   
  /** Public modifiers **/
  inline void SetVerbose(const Int_t& verbose) {fVerbose = verbose;};
  inline void SetPid(const Int_t& pid) {fPid = pid;};
  inline void SetChi2Cut(const Double_t& chi2cut) {fChi2Cut = chi2cut;};


  /** Histogramms **/
  TH1F* fh_chi2hit;
  TH2F* fh_chi2hit_plane;

  // Histogramms for the distance cuts
  TH1F* fDistLongX;
  TH1F* fDistLongY;
  TH1F* fDistShortX;
  TH1F* fDistShortY;

  TH1F* fDistLongBX;
  TH1F* fDistLongBY;
  TH1F* fDistShortBX;
  TH1F* fDistShortBY;

  TH1F* fDistY12;

  TH2F* fMomDistLongPrimaryX;
  TH2F* fMomDistLongPrimaryY;
  TH2F* fMomDistLongExtraX;
  TH2F* fMomDistLongExtraY;

  TH2F* fMomDistExtrapolPrimaryX;
  TH2F* fMomDistExtrapolPrimaryY;
  TH2F* fMomDistExtrapolExtraX;
  TH2F* fMomDistExtrapolExtraY;

  TH2F* fMomDistShortPrimaryX;
  TH2F* fMomDistShortPrimaryY;
  TH2F* fMomDistShortExtraX;
  TH2F* fMomDistShortExtraY;

  TH1F *fDistY;
  TH1F *fDistX;

  TH1F *fPlane1Ydens;
  TH1F *fPlane5Ydens;
  TH1F *fPlane9Ydens;

  TH1F *fSPlength;
  TH1F *fSPlengthMC;

  TH1F *fYat0;
  TH1F *fYat0MC;

  TH2F* fNoEvTime;

  ClassDef(CbmL1CATrdTrackFinderSA, 1);

};


#endif