//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of resCalc
//      Uses existing GFTracks as reference and calculates
//      residua in XY for TpcClusters.
//      Developped for Test Bench tracking systems using the
//      RK track representation
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Felix Boehmer                     (original author)
//      Maxence Vandenbroucke             (Application of TpcCdcFit2DResCalc to GFTracks)
//      Physik Department E18, TUM
//
//-----------------------------------------------------------

#ifndef CDCREFGFTRKRES_ALIGN_HH
#define CDCREFGFTRKRES_ALIGN_HH

#include <vector>
#include <utility> 

#include <TH1.h>
#include <TH2.h>
#include <TString.h>
#include <TFile.h>

#include "CdcHit.h"
#include "CdcTrack.h"

#include "AbsRefTrackResCalc.h"
#include "TpcAlignmentManager.h"
#include "CdcTpcMatchingQA.h"
class GFRecoHitFactory;
class   TpcDevmapCyl;

class CdcTrackTpcHitResCalc : public AbsRefTrackResCalc {

 public:
  CdcTrackTpcHitResCalc();
  virtual ~CdcTrackTpcHitResCalc();

  virtual int calc();
  virtual bool init();

  void setTpcSPHitBranchName(const TString& name) {fTpcSPHitBranchName=name;}
  void setTpcTrackBranchName(const TString& name) {fTpcTrackBranchName=name;}
  void setCdcGFTrackBranchName(const TString& name) {fCdcGFTrackBranchName=name;}
  void setTpcClusterBranchName(const TString& name) {fTpcClusterBranchName=name;}
  void setUseFelixMatching(const TString& tupleBranchName){fFopiTupleBranchName=tupleBranchName;}

  void setCdcHitBranchName(const TString& name){fCdcHitBranchName=name;}
  void setCdcTrackBranchName(const TString& name){fCdcTrackBranchName=name;}
  void setCutOnNSectors(int nSectors){fCutNSectors=nSectors;}
  
  void setTrackRepId(const int id){fNRep=id;}
  void setUseClusters(bool opt=true){fUseClusters=opt;}

  void setOrigTransfName(TString opt){fOrigTransfName=opt;}

  
  void setCdcPtCut(double pt){fCdcTrackPtCut=pt;}
  void setCdcMaxPtCut(double pt){fCdcTrackMaxPtCut=pt;}
  void setTpcPtCut(double pt){fTpcTrackPtCut=pt;}
  void setThetaCut(double theta){fThetaCut=theta;}
  void setCdcExtrapolateToZ(bool opt){fCdcExtrapZ=opt;}
  void setCutOnRpc(bool opt){fCutOnRpc=opt;}
  void setMinHitsCdc(int nHit){fMinHitsCdc=nHit;}
  void setMassCut(double mcut){fMassCut=mcut;}
  //Select CDC tracks based on where in the sectors the lie, angle whise:
  // track.Phi() modulo 22.5
  // minAngle and maxAngle has to be between 0 and 22.5
  // 
  void setSectorTrackSelection(double minAngle_,double maxAngle);
  
  void applyDevMap(TString devMapPath){fDevMapPath=devMapPath;fApplyDevMap=true;}
  
  void writeHists();
  static double phiDifference(double angle1,double angle2);
  
  TString getHistoFileName() const;
  void setHistoFileName(const TString &value);
  
  bool getCheckFopiTrack() const;
  void setCheckFopiTrack(bool value);
  void setVerbose(int v=1){fVerbose=v;}
private:
  TClonesArray* fCdcGFTrackArray;
  TClonesArray* fCdcTrackArray;
  TClonesArray* fCdcHitArray;
  TClonesArray* fTpcSPHitArray;
  TClonesArray* fTpcTrackArray;
  TClonesArray* fTpcClusterArray;
  TClonesArray* fFopiTupleArray;
  TClonesArray* fFopiTrackArray;
  
  TString fCdcGFTrackBranchName;
  TString fCdcTrackBranchName;
  TString fCdcHitBranchName;
  TString fTpcTrackBranchName;
  TString fTpcSPHitBranchName;
  TString fTpcClusterBranchName;
  TString fFopiTupleBranchName;
  TString fFopiTrackBranchName;

  
  
  bool fUseFelixMatching;
  TpcAlignmentManager* fAlMan;
  TString fOrigTransfName;

  int fNRep;                       //which rep to use
  int fDetID;

  bool fUseClusters;
  bool fAlignedMatching;
  double fThetaCut;
  bool fCdcExtrapZ;
  bool fCutOnRpc;
  double fTrackdPhiCut;
  int fCutNSectors;
  bool fCheckFopiTrack;
  
  double fCdcTrackPtCut;
  double fCdcTrackMaxPtCut;
  double fTpcTrackPtCut;

  bool sectorTrackSelection;
  double minAngle;
  double maxAngle;
  
  double fMinR;
  double fMaxR;
  
  double fMassCut;
  std::vector<std::pair<double,double> > fPhiCuts; 
  
  int fMinHitsCdc;
  
  bool fApplyDevMap;
  TString fHistoFileName;
  TString fDevMapPath;
  TpcDevmapCyl * fDevMap;
  std::map<TString ,TH1*> histMap;
  std::map<TString,TString> folderNameMap;

  CdcTpcMatchingQA *fQA;
  
  int getNSectors(CdcTrack* theTrack);
  int getCdcSector(TVector3 wirePos);

  int fVerbose;
  
public:
  ClassDef(CdcTrackTpcHitResCalc,1)


};

#endif