//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Preliminary cluster to calculates Covariance, Errors, Position, ...
//      
//
// Environment:
//      Software developed for the FOPI-TPC Detector at GSI.
//
// Author List:
//          Unknown                TUM     (original author)
//          Martin Berger          TUM     (extensive changes)
//
//-----------------------------------------------------------

#ifndef TPCPRELIMCLUSTER_HH
#define TPCPRELIMCLUSTER_HH

#include <vector>
#include <map>
#include <set>
#include "TVector3.h"
#include "McIdCollection.h"
#include "TMatrixD.h"
#include "TVectorD.h"
#include "GFDetPlane.h"
#include "TNtupleD.h"
#include "TH2D.h"

class TpcPadPlane;
class TpcDigi;
class TpcCluster;

class TpcPrelimCluster{
 private:
  void calcCog();
  void calcError(double zJitter);
  void calcErrorPlane(double zJitter);
  void calcErrorPlaneParam(double zJitter);
  TMatrixDSym fitDigis2D(TNtupleD* digisOnPlaneTuple, TMatrixDSym covOnPlaneSym, TVector2 digiErr, TVector2& shift);
  TMatrixDSym fitDigis2D(TNtupleD* digisOnPlaneTuple, TMatrixDSym covOnPlaneSym, TVector2& shift);
  Double_t fitDigis1D(TNtupleD& digisOnPlaneTuple, double sigma, double mean, Double_t& shift);
  TVector3 recalcDigiPos(TVector3 digpos, int padid, double ampfrac);
  TVector3 calcClusterSize(TNtupleD* digisOnPlaneTuple,TVector3 ax0, TVector3 ax1);
  void getDigiWeights();
  TVector3 calcPOCAtoLine(TVector3 refpos, TVector3 dir, TVector3 pos);
  void getGemSpreadCorr(double z, double* corrFactors);
  void getShapeCovFromDigis(TVector3 planeO, TVector3 planeU, TVector3 planeV);
  void getShapeCovFromDigis(TMatrixD UVplane);
  void getShapeCovFromParam(TMatrixD UVplane);
  void getCogOnPlane(TNtupleD* digisOnPlaneTuple);
  TMatrixDSym calcHesse();
  double getAmpWeight();

  TVector3 fpos;
  TVector3 fposOnPlane;
  TVector3 fcogpos;
  TVector3 ferr;
  TVector3 ferrT;
  TVector3 ferrA;
  TVector3 feigenValOnPlane;
  TVector3 fminSigma;
  TVector3 fdir;
  TVector3 fmidPos;
  TVector3 fRMS;
  TVector3 fARMS;
  TVector3 fRMSUV;
  TVector3 fARMSUV;
  TVector3 fCogUV;
  GFDetPlane fmidPlane;
  TMatrixDSym fcov;
  TMatrixDSym fcovOnPlane;
  TMatrixDSym fshapeCov;
  TMatrixDSym fshapeCovPlane;
  TMatrixDSym funwShapeCov;
  TMatrixDSym funwShapeCovPlane;
  TVectorD feigenVal;
  TMatrixD feigenVect;
  double famp;
  double famp2;
  double fmaxDigiAmp;
  double fcogT;
  int fid;
  double fG;
  double fC;
  double fphi;
  double fcorrFactor;
  double famp_weighted;
  double famp2_weighted;
  Bool_t frecalcDigiPos;
  Bool_t ffitGood;
  //double fchi2;
  //double fndf;
  double fminNll;
  bool isGeomErr[3];
  bool fDoPRF;

  std::vector<TpcDigi*> fdigis;
  std::vector<GFDetPlane> fdetPlanes;
  std::map<const TpcDigi*, double> fdigiShares;
  std::vector<int> fpadids;
  std::vector<double> ftbins;
  std::set<unsigned int> fpossiblePads; // pads neighbouring unshared digis
  std::set<unsigned int> fpossiblePadsShared; // pads neighbouring shared digis
  std::vector<double> fresponseweights;
  std::map<const TpcDigi*, std::set<TpcPrelimCluster*> > fSharedClusters; // clusters to which digis are shared

  unsigned int fnUnsharedDigis;

  TpcPadPlane* fpadplane;
  double ftimeslice;
  McIdCollection fmcidCol;

  bool isInTimeWindow(const TpcDigi* const);
  Bool_t phiIsSet;


 public:
  TpcPrelimCluster(TpcPadPlane* p, double t , int id, double G, double C);
  TpcPrelimCluster(TpcPadPlane* p, int id, double G, double C);
  virtual ~TpcPrelimCluster();

  void addHit(TpcDigi*, bool noXclust=false, double share=1., bool check=false);
  void addHit(TpcDigi*, GFDetPlane, double share=1.);
  

  void addSharedCluster(TpcDigi* d, TpcPrelimCluster* c); 
  void removeSharedCluster(TpcDigi* d, TpcPrelimCluster* c) {fSharedClusters[d].erase(fSharedClusters[d].find(c));}
  void setPhi(Double_t p){fphi=p;phiIsSet=kTRUE;}
  void setDir(TVector3 m){fdir=m;}
  void setMidPos(TVector3 v){fmidPos=v;}
  void setMidPlane(GFDetPlane p){fmidPlane=p;}
  void setRecalcDigiPos(Bool_t opt=kTRUE){frecalcDigiPos=opt;}
  void setCorrFactor(double var){fcorrFactor=var;}
  void setDoPRF(bool opt=kTRUE){fDoPRF=opt;}
  //void setEigenvalOnPlane(double v1, double v2, double v3){feigenvalOnPlane.SetXYZ(v1,v2,v3);}

  unsigned int getNSharedClusters(TpcDigi* d) {return fSharedClusters[d].size();}
  TpcPrelimCluster* getSharedCluster(TpcDigi* d, unsigned int i);
  double getCogT(){return fcogT;}
  double getAmp() {return famp;}
  TpcDigi* getDigi(unsigned int id){return fdigis[id];}
  double getDigiShare(unsigned int id){return fdigiShares[fdigis[id]];}
  unsigned int getNDigis() const {return fdigis.size();}
  unsigned int getNUnsharedDigis() const {return fnUnsharedDigis;}
  TMatrixDSym getCov(){return fcov;}
  TVectorD getEigenVal(){return feigenVal;}
  TMatrixD getEigenVect(){return feigenVect;}
  TVector3 getPos(){return fpos;}
  TVector3 getPosOnPlane(){return fposOnPlane;}
  TVector3 getCogOnPlane(){return fCogUV;}
  
  int isInCluster(const TpcDigi* const); // 0 = not a neighbor; 1 = neighbour to an unshared digi; 2 = neighbour to a shared digi

  TpcCluster* convTpcCluster(unsigned int sectorId, double zJitter, bool saveRaw, bool usePlane=false);

};

#endif