//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Data object carrying infomration about a fitted track
//      (residuals, chi2,...)
//      This class is meant to serve as a container which can be
//      used witht the ROOT TreeViewer to produce plots
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Sebastian Neubert    TUM            (original author)
//
//
//-----------------------------------------------------------

#ifndef TPCCOSMICS_HH
#define TPCCOSMICS_HH

// Base Class Headers ----------------
#include "TObject.h"
#include "TVector3.h"
#include "TMatrixD.h"

// Collaborating Class Headers -------
#include <ostream> // remove if you do not need streaming op
#include <vector>
// Collaborating Class Declarations --



class TpcCosmics : public TObject{
public:

  // Constructors/Destructors ---------
  TpcCosmics();
  TpcCosmics(const TpcCosmics& _c);
  virtual ~TpcCosmics();
  // Operators
  
  // Accessors -----------------------
  Int_t    GetPdgCode()	   { return _nPDG;       }
  Int_t    GetMotherID()   { return _motherID;   }
  Int_t    GetStatFlag()   { return _statflag;   }
  Double_t GetMCP()   	   { return _pmc;        }
  Double_t GetP()          { return _p;          }
  Double_t GetLength()     { return _length;     }
  TVector3 GetMom()        { return _mom;        }
  TVector3 GetMomErr()     { return _momerr;     }
  TVector3 GetPos()        { return _pos;        }
  TVector3 GetPosErr()     { return _poserr;     }
  TVector3 GetMCpos()      { return _MCpos;      }
  TVector3 GetMCmom()      { return _MCmom;      }
  Double_t GetTheta()      { return _theta;      }
  Double_t GetPhi()        { return _phi;        }
  Double_t GetClMeanAmp()  { return _clmeanamp;  }
  Double_t GetClMediAmp()  { return _clmediamp;  }
  Double_t GetClSumAmp()   { return _clsumamp;   }
  Double_t GetClSizeMed2D(){ return _clsizemed2d;}
  Double_t GetClSizeMed3D()    { return _clsizemed3d;}
  Double_t GetMeanZ()          { return _meanz;      }
  Int_t    GetEvent()          { return _event;      }
  //  Double_t GetTrackChi()   { return _trackChi;   }
  unsigned int getFailedHits() {return _failedHits;}
  unsigned int getNDF() const  {return _NDF;}    //NDF from fit
  Double_t getChi2() const     {return _ChiSqu;}      //ChiSqu from fit
  TVector3 GetzAxisPoca()      {return _zAxisPoca;}
  TVector3 GetzAxisDir()       {return _zAxisDir;}
  TVector3 GetFirstMCPoca()    {return _firstMCPoca;}
  TVector3 GetFirstMCDir()     {return _firstMCDir;}
  Int_t    GetNumCluster()     {return _TpcResX.size();}

 // Operations ----------------------

  void setp(Double_t p)            {_p=p;}
  void setmom(TVector3 p)          {_mom=p;}
  void setMomErr(TVector3 p)       {_momerr=p;}
  void setPos(TVector3 p)          {_pos=p;}
  void setPosErr(TVector3 p)       {_poserr=p;}
  void setMCpos(TVector3 p)        {_MCpos=p;}
  void setMCmom(TVector3 p)        {_MCmom=p;}
  void setTheta(Double_t val)      {_theta=val;}
  void setPhi(Double_t val)        {_phi=val;}
  void setpmc(Double_t p)          {_pmc=p;_hasMc=true;}
  void setpstart(Double_t pstart)  {_pstart=pstart;}
  void setsigp(Double_t s)         {_sigp=s;}
  void setcharge(Double_t q)       {_charge=q;}
  void setLength(Double_t val)     {_length=val;}
  void setClMeanAmp(Double_t val)  {_clmeanamp=val;}
  void setClMediAmp(Double_t val)  {_clmediamp=val;}
  void setClSumAmp(Double_t val)   {_clsumamp=val;}
  void setClSizeMed2D(Double_t val){_clsizemed2d=val;}
  void setClSizeMed3D(Double_t val){_clsizemed3d=val;}
  void setMeanZ(Double_t val)      {_meanz=val;}
  void setStatFlag(int val)        {_statflag=val;}
  void setEvent(int val)           {_event=val;}
  void setzAxisPocaDir(TVector3 p, TVector3 d)  {_zAxisPoca=p; _zAxisDir=d;}
  void setFirstMCPocaDir(TVector3 p, TVector3 d) {_firstMCPoca=p; _firstMCDir=d;}

  //  void setTrackChi(Double_t val)   {_trackChi=val;}

  void setmccharge(Double_t q)     {_mccharge=q;}
  void setpdg(Int_t pdg)         {_nPDG=pdg;}
  void setmotherid(Int_t motherID){_motherID=motherID;}
  unsigned int nhits() const {return _TpcResX.size();}


  const std::vector<Double_t>* GetResX() {return &_TpcResX;}
  const std::vector<Double_t>* GetResY() {return &_TpcResY;}
  const std::vector<Double_t>* GetResZ() {return &_TpcResZ;}
  const std::vector<TVector3>  GetRes();
  const TVector3  GetRes(int i) {return TVector3(_TpcResX[i],_TpcResY[i],_TpcResZ[i]);}

  const std::vector<Double_t>* GetResU() {return &_TpcResU;}
  Double_t GetResU(int i) {return _TpcResU[i];}
  const std::vector<Double_t>* GetResV() {return &_TpcResV;}
  Double_t GetResV(int i) {return _TpcResV[i];}
  TVector3 GetResUV(int i){return TVector3(_TpcResU[i],_TpcResV[i],0);}

  const std::vector<TVector3>* GetResA() {return &_TpcResA;}
  const TVector3 GetResA(int i) {return _TpcResA[i];}
  const std::vector<TVector3>* GetResAMC() {return &_TpcResAMC;}
  const std::vector<Double_t>* GetResMCU() {return &_TpcResMCU;}
  const std::vector<Double_t>* GetResMCV() {return &_TpcResMCV;}
  const std::vector<Double_t>* GetErrU() {return &_TpcErrU;}
  const std::vector<Double_t>* GetErrV() {return &_TpcErrV;}
  const std::vector<Double_t>* GetSigU() {return &_TpcErrU;}
  const std::vector<Double_t>* GetSigV() {return &_TpcErrV;}
  const TVector3 GetSigUV(int i){return TVector3(_TpcErrU[i],_TpcErrV[i],0);}
  const std::vector<Double_t>* GetResR() {return &_TpcResR;}
  const std::vector<Double_t>* GetResP() {return &_TpcResP;}
  const std::vector<Double_t>* GetSigX() {return &_TpcSigX;}
  const std::vector<Double_t>* GetSigY() {return &_TpcSigY;}
  const std::vector<Double_t>* GetSigZ() {return &_TpcSigZ;}
  const TVector3 GetSigXYZ(int i) {return TVector3(_TpcSigX[i],_TpcSigY[i],_TpcSigZ[i]);}
  const std::vector<TVector3>* GetSigT() {return &_TpcSigT;}
  const std::vector<TVector3>* GetSigC() {return &_TpcSigC;}

  const std::vector<TVector3>* GetSigA() {return &_TpcSigA;}
  const TVector3 GetSigA(int i) {return _TpcSigA[i];}

  const std::vector<Double_t>* GetSigResT()  {return &_TpcSigResT;}
  const std::vector<Double_t>* GetSigResMC() {return &_TpcSigResMC;}
  const std::vector<TVector3>* GetAxis1() {return &_TpcAxis1;}
  const std::vector<TVector3>* GetAxis2() {return &_TpcAxis2;}
  const std::vector<TVector3>* GetAxis3() {return &_TpcAxis3;}
  const TVector3 GetAxis1(int i) {return _TpcAxis1[i];}
  const TVector3 GetAxis2(int i) {return _TpcAxis2[i];}
  const TVector3 GetAxis3(int i) {return _TpcAxis3[i];}

  const std::vector<Double_t>* GetAxis1MCErr() {return &_TpcAxis1MCErr;}
  const std::vector<Double_t>* GetAxis2MCErr() {return &_TpcAxis2MCErr;}
  const std::vector<Double_t>* GetAxis3MCErr() {return &_TpcAxis3MCErr;}
  const std::vector<Double_t>* GetAxis1Diff() {return &_TpcAxis1Diff;}
  const std::vector<Double_t>* GetAxis2Diff() {return &_TpcAxis2Diff;}
  const std::vector<Double_t>* GetAxis3Diff() {return &_TpcAxis3Diff;}
  const std::vector<TVector3>* GetPlaneU()    {return &_PlaneU;}
  const std::vector<TVector3>* GetPlaneV()    {return &_PlaneV;}
  const std::vector<TVector3>* GetPlaneW()    {return &_PlaneW;}
  const std::vector<TVector3>* GetPlaneO()    {return &_PlaneO;}
  const std::vector<TVector3>* GetMidPlaneU()    {return &_MidPlaneU;}
  const std::vector<TVector3>* GetMidPlaneV()    {return &_MidPlaneV;}
  const std::vector<TVector3>* GetMidPlaneW()    {return &_MidPlaneW;}
  const std::vector<TVector3>* GetMidPlaneO()    {return &_MidPlaneO;}


  const TVector3 GetPlaneU(int i)    {return _PlaneU[i];}
  const TVector3 GetPlaneV(int i)    {return _PlaneV[i];}
  const TVector3 GetPlaneO(int i)    {return _PlaneO[i];}
  const TVector3 GetPlaneW(int i)    {return _PlaneW[i];}
  const TVector3 GetMidPlaneU(int i)    {return _MidPlaneU[i];}
  const TVector3 GetMidPlaneV(int i)    {return _MidPlaneV[i];}
  const TVector3 GetMidPlaneO(int i)    {return _MidPlaneO[i];}
  const TVector3 GetMidPlaneW(int i)    {return _MidPlaneW[i];}

  const std::vector<Double_t>* GetResMcX()   {return &_TpcResMcX;}
  const std::vector<Double_t>* GetResMcY()   {return &_TpcResMcY;}
  const std::vector<Double_t>* GetResMcZ()   {return &_TpcResMcZ;}
  const std::vector<TVector3>  GetResMC();  
  const TVector3  GetResMC(int i) {return TVector3(_TpcResMcX[i],_TpcResMcY[i],_TpcResMcZ[i]);}
  const std::vector<Double_t>* GetResMcR()   {return &_TpcResMcR;}
  const std::vector<Double_t>* GetResMcP()   {return &_TpcResMcP;}
  const std::vector<Double_t>* GetMcRefPosX(){return &_TpcMcRefPosX;}
  const std::vector<Double_t>* GetMcRefPosY(){return &_TpcMcRefPosY;}
  const std::vector<Double_t>* GetMcRefPosZ(){return &_TpcMcRefPosZ;}
  const TVector3 			   GetMCRefPos(int i) {return TVector3(_TpcMcRefPosX[i],_TpcMcRefPosY[i],_TpcMcRefPosZ[i]);}
  const std::vector<Double_t>* GetMcRefPosR(){return &_TpcMcRefPosR;}
  const std::vector<TVector3>* GetMcPosMom() {return &_TpcMcPosMom;}

  const std::vector<TVector3>* GetGTrack() {return &_TpcGTrack;}

  const std::vector<Double_t>* GetChi2X() {return &_TpcChi2X;}
  const std::vector<Double_t>* GetChi2Y() {return &_TpcChi2Y;}
  const std::vector<Double_t>* GetChi2Z() {return &_TpcChi2Z;}
  const std::vector<unsigned int>* GetClSizes()   {return &_TpcClusterSize;}
  const int                    GetClusterSize(int i) {return _TpcClusterSize[i];}
  const std::vector<Double_t>* GetClSizesU()   {return &_TpcClusterSizeU;}
  const std::vector<unsigned int>* Get2DClSizes() {return &_Tpc2DClusterSize;}
  const int 				   Get2DClusterSize(int i){return _Tpc2DClusterSize[i];}
  const std::vector<TVector3>* GetFullClusterSize() {return &_TpcFullClusterSize;}
  const TVector3 GetFullClusterSize(int i) {return _TpcFullClusterSize[i];}
  const std::vector<TVector3>* GetFullClusterSizeTrack() {return &_TpcFullClusterSizeTrack;}

  const std::vector<TVector3>* GetFullClusterSizeAxis() {return &_TpcFullClusterSizeAxis;}
  const TVector3 GetFullClusterSizeAxis(int i) {return _TpcFullClusterSizeAxis[i];}

  const std::vector<Double_t>* GetAmps() {return &_TpcClusterAmp;}
  const Double_t GetAmp(Int_t iclus) {return _TpcClusterAmp[iclus];}

  const std::vector<Double_t>* GetPhis() {return &_TpcClusterPhi;}
  const std::vector<Double_t>* GetClusterDists() {return &_TpcClusterDist;}
  const double GetClusterDist(int i) {return _TpcClusterDist[i];}
  const std::vector<TVector3>* GetProjectionPoints() {return &_TpcProj;}  //projection point is the track point in the detplane
  const TVector3 GetProjectionPoint(int i) {return _TpcProj[i];}
  const std::vector<TVector3>* GetProjectionPointsErr() {return &_TpcProjErr;}
  const std::vector<TVector3>* GetProjectionPointsMom() {return &_TpcProjMom;}
  const TVector3 GetProjectionPointsMom(int i) {return _TpcProjMom[i];}
  const std::vector<TVector3>* GetProjectionPointsMomErr() {return &_TpcProjMomErr;}
  const std::vector<Double_t>* GetHitPositionsX() {return &_TpcPosX;}
  const std::vector<Double_t>* GetHitPositionsY() {return &_TpcPosY;}
  const std::vector<Double_t>* GetHitPositionsZ() {return &_TpcPosZ;}
  const TVector3 GetHitPosistionXYZ(int i){return TVector3(_TpcPosX[i],_TpcPosY[i],_TpcPosZ[i]);}
  const TVector3 GetHitPositionXYZ(int i){return TVector3(_TpcPosX[i],_TpcPosY[i],_TpcPosZ[i]);}


  const Double_t GetHitPositionsX(int iclus) {return _TpcPosX[iclus];}
  const Double_t GetHitPositionsY(int iclus) {return _TpcPosY[iclus];}
  const Double_t GetHitPositionsZ(int iclus) {return _TpcPosZ[iclus];}

  const TVector3 GetHitPosition(int iclus){return TVector3(_TpcPosX[iclus],_TpcPosY[iclus],_TpcPosZ[iclus]);}

  const std::vector<Double_t>* GetHitPositionsR() {return &_TpcPosR;}
  const std::vector<int>* GetHitIDs()             {return &_TpcHitID;}
  const int GetHitID(int i)                      {return _TpcHitID[i];}

  const std::vector<bool>* GetSaturationFlag()  {return &_TpcSaturated;}

  const std::vector<TVector3>* GetIsGeomErr() {return &_TpcIsGeomErr;}
  const TVector3 GetIsGeomErr(int i) {return _TpcIsGeomErr[i];}

  const std::vector<bool>* GetClusterFitGood(){return &_TpcClusterFitGood;}
  const bool GetClusterFitGood(int i){return _TpcClusterFitGood[i];}

  const std::vector<TVector3>* GetEigenValOnPlane(){return &_TpcEigenValOnPlane;}
  const TVector3 GetEigenValOnPlane(int i){return _TpcEigenValOnPlane[i];}

  const std::vector<TVector3>* GetMinSigma(){return &_TpcMinSigma;}

  const std::vector<TVector3>* GetResMCTrack(){return &_TpcResMCTrack;}
  const std::vector<TVector3>* GetResMCTrackUV(){return &_TpcResMCTrackUV;}
  const std::vector<TVector3>* GetResMCTrackA(){return &_TpcResMCTrackA;}

  const std::vector<TVector3>* GetCogPos(){return &_TpcCogPos;}
  const TVector3 GetCogPos(int i){return _TpcCogPos[i];}

  const std::vector<double>* GetMinNll(){return &_TpcMinNll;}
  const double GetMinNll(int i){return _TpcMinNll[i];}

  const std::vector<TMatrixD>* GetClusterCov(){return &_TpcClusterCov;}
  const TMatrixD GetClusterCov(int i){return _TpcClusterCov[i];}

  const std::vector<TVector3>* GetOuterAmp(){return &_TpcOuterAmp;}
  const TVector3 GetOuterAmp(int i){return _TpcOuterAmp[i];}

  const std::vector<TVector3>* GetInnerAmp(){return &_TpcInnerAmp;}
  const TVector3 GetInnerAmp(int i){return _TpcInnerAmp[i];}

  const std::vector<double>* GetDAFWeights(){return &_TpcDAFWeights;}
  const double GetDAFWeights(int i){return _TpcDAFWeights[i];}

  const std::vector<TMatrixD>* GetCovOnPlane(){return &_TpcCovOnPlane;}
  const TMatrixD GetCovOnPlane(int i){return _TpcCovOnPlane[i];}

  const std::vector<TMatrixD>* GetUnwCovOnPlane(){return &_TpcUnwCovOnPlane;}
  const TMatrixD GetUnwCovOnPlane(int i){return _TpcUnwCovOnPlane[i];}

  const std::vector<Double_t>* GetMaxDigiAmp()    {return &_TpcMaxDigiAmp;}
  const double GetMaxDigiAmp(int i)    {return _TpcMaxDigiAmp[i];}
  const std::vector<Double_t>* GetMaxSampleAmp()    {return &_TpcMaxSampleAmp;}
  const double GetMaxSampleAmp(int i)    {return _TpcMaxSampleAmp[i];}

  //fill in cosmics task the maxsamplke amp, add histograms in analyze macro.

  const std::vector<std::vector<TVector3> >* GetDigisOnPlane() {return &_TpcDigisOnPlane;}
  const std::vector<TVector3>* GetDigisOnPlane(int iclus) {return &_TpcDigisOnPlane[iclus];}

  const std::vector<std::vector<TVector3> >* GetDigiPos() {return &_TpcDigiPos;}
  const std::vector<TVector3>* GetDigiPos(int iclus) {return &_TpcDigiPos[iclus];}

  const std::vector<std::vector<TVector3> >* GetDigiMom() {return &_TpcDigiMom;}
  const std::vector<TVector3>* GetDigiMom(int iclus) {return &_TpcDigiMom[iclus];}

  const std::vector<std::vector<TVector3> >* GetDigiMCPos() {return &_TpcDigiMCPos;}
  const std::vector<TVector3>* GetDigiMCPos(int iclus) {return &_TpcDigiMCPos[iclus];}

  const std::vector<std::vector<Double_t> >* GetDigisOnPlaneAmp() {return &_TpcDigisOnPlaneAmp;}
  const std::vector<Double_t>* GetDigisOnPlaneAmp(int iclus) {return &_TpcDigisOnPlaneAmp[iclus];}
  const double GetDigisOnPlaneAmp(int iclus, int idigi){return _TpcDigisOnPlaneAmp[iclus][idigi];}

  const std::vector<Double_t>* GetClusterSNR()    	{return &_TpcCSNR;}
  const std::vector<Double_t>* GetDigiSNR()       	{return &_TpcDSNR;}
  const std::vector<Double_t>* GetSampleSNR()		{return &_TpcSSNR;}
  const double GetClusterSNR(int i)    	{return _TpcCSNR[i];}
  const double GetDigiSNR   (int i)    	{return _TpcDSNR[i];}
  const double GetSampleSNR (int i)		{return _TpcSSNR[i];}


  const std::vector<std::vector<TVector3 > >* GetDigiMCRes(){return &_TpcDigiMCRes;}
  const std::vector<TVector3 >* GetDigiMCRes(int i){return &_TpcDigiMCRes[i];}

  const std::vector<std::vector<TVector3 > >* GetDigiTrackRes(){return &_TpcDigiTrackRes;}
  const std::vector<TVector3 >* GetDigiTrackRes(int i){return &_TpcDigiTrackRes[i];}

  const std::vector<std::vector<double> >* GetDigiLen(){return &_TpcDigiLen;}
  const std::vector<double>* GetDigiLen(int i){return &_TpcDigiLen[i];}

  const std::vector<std::vector<int> >* GetDigiID(){return &_TpcDigiId;}
  const std::vector<int>* GetDigiID(int i){return &_TpcDigiId[i];}

  const std::vector<std::vector<double> >* GetPrfWeights(){return &_TpcDigiPrfWeights;}
  const std::vector<double>* GetPrfWeights(int i){return &_TpcDigiPrfWeights[i];}

  const TMatrixD GetShapeCov(int i){return _TpcShapeCov[i];}
  const TMatrixD GetUnwShapeCov(int i){return _TpcUnwShapeCov[i];}
  const TMatrixD GetShapeCovOnPlane(int i){return _TpcShapeCovOnPlane[i];}
  const TMatrixD GetUnwShapeCovOnPlane(int i){return _TpcUnwShapeCovOnPlane[i];}

  const TVector3 GetRMS(int i){return _TpcRMS[i];}
  const TVector3 GetUnwRMS(int i){return _TpcUnwRMS[i];}
  const TVector3 GetRMS_UV(int i){return _TpcRMS_UV[i];}
  const TVector3 GetUnwRMS_UV(int i){return _TpcUnwRMS_UV[i];}
  const TVector3 GetRMS_A(int i){return _TpcRMS_A[i];}
  const TVector3 GetUnwRMS_A(int i){return _TpcUnwRMS_A[i];}
  const TVector3 GetRMS_A_UV(int i){return _TpcRMS_A_UV[i];}
  const TVector3 GetUnwRMS_A_UV(int i){return _TpcUnwRMS_A_UV[i];}

  const TVector3 GetFieldCorr(int i){return _TpcFieldCorr[i];}

  // Modifiers -----------------------

  void fillTpcResX(const std::vector<Double_t>& r){_TpcResX=r;}
  void fillTpcResY(const std::vector<Double_t>& r){_TpcResY=r;}
  void fillTpcResZ(const std::vector<Double_t>& r){_TpcResZ=r;}
  void fillTpcResU(const std::vector<Double_t>& r){_TpcResU=r;}
  void fillTpcResV(const std::vector<Double_t>& r){_TpcResV=r;}
  void fillTpcResA(const std::vector<TVector3>& r){_TpcResA=r;}
  void fillTpcResAMC(const std::vector<TVector3>& r){_TpcResAMC=r;}
  void fillTpcResMCU(const std::vector<Double_t>& r){_TpcResMCU=r;}
  void fillTpcResMCV(const std::vector<Double_t>& r){_TpcResMCV=r;}
  void fillTpcErrU(const std::vector<Double_t>& r){_TpcErrU=r;}
  void fillTpcErrV(const std::vector<Double_t>& r){_TpcErrV=r;}
  void fillTpcResR(const std::vector<Double_t>& r){_TpcResR=r;}
  void fillTpcResP(const std::vector<Double_t>& r){_TpcResP=r;}
  void fillTpcSigX(const std::vector<Double_t>& r){_TpcSigX=r;}
  void fillTpcSigY(const std::vector<Double_t>& r){_TpcSigY=r;}
  void fillTpcSigZ(const std::vector<Double_t>& r){_TpcSigZ=r;}
  void fillTpcSigT(const std::vector<TVector3>& r){_TpcSigT=r;}
  void fillTpcSigResT(const std::vector<Double_t>& r){_TpcSigResT=r;}
  void fillTpcSigResMC(const std::vector<Double_t>& r){_TpcSigResMC=r;}
  void fillTpcSigC(const std::vector<TVector3>& r){_TpcSigC=r;}
  void fillTpcSigA(const std::vector<TVector3>& r){_TpcSigA=r;}

  void fillTpcAxis1(const std::vector<TVector3>& r){_TpcAxis1=r;}
  void fillTpcAxis2(const std::vector<TVector3>& r){_TpcAxis2=r;}
  void fillTpcAxis3(const std::vector<TVector3>& r){_TpcAxis3=r;}

  void fillTpcAxis1MCErr(const std::vector<Double_t>& r){_TpcAxis1MCErr=r;}
  void fillTpcAxis2MCErr(const std::vector<Double_t>& r){_TpcAxis2MCErr=r;}
  void fillTpcAxis3MCErr(const std::vector<Double_t>& r){_TpcAxis3MCErr=r;}

  void fillTpcAxis1Diff(const std::vector<Double_t>& r){_TpcAxis1Diff=r;}
  void fillTpcAxis2Diff(const std::vector<Double_t>& r){_TpcAxis2Diff=r;}
  void fillTpcAxis3Diff(const std::vector<Double_t>& r){_TpcAxis3Diff=r;}

  void fillPlaneU(const std::vector<TVector3>& r){_PlaneU=r;}
  void fillPlaneV(const std::vector<TVector3>& r){_PlaneV=r;}
  void fillPlaneO(const std::vector<TVector3>& r){_PlaneO=r;}

  void fillTpcResMcX(const std::vector<Double_t>& r){_TpcResMcX=r;}
  void fillTpcResMcY(const std::vector<Double_t>& r){_TpcResMcY=r;}
  void fillTpcResMcZ(const std::vector<Double_t>& r){_TpcResMcZ=r;}
  void fillTpcResMcP(const std::vector<Double_t>& r){_TpcResMcP=r;}
  void fillTpcResMcR(const std::vector<Double_t>& r){_TpcResMcR=r;}
  void fillTpcMcRefPosX(const std::vector<Double_t>& r){_TpcMcRefPosX=r;}
  void fillTpcMcRefPosY(const std::vector<Double_t>& r){_TpcMcRefPosY=r;}
  void fillTpcMcRefPosZ(const std::vector<Double_t>& r){_TpcMcRefPosZ=r;}
  void fillTpcMcRefPosR(const std::vector<Double_t>& r) {_TpcMcRefPosR=r;}
  void fillTpcMcPosMom(const std::vector<TVector3>& r)   {_TpcMcPosMom=r;}

  void fillGTrack(const std::vector<TVector3>& r){_TpcGTrack=r;}

  void fillTpcChi2X(const std::vector<Double_t>& r){_TpcChi2X=r;}
  void fillTpcChi2Y(const std::vector<Double_t>& r){_TpcChi2Y=r;}
  void fillTpcChi2Z(const std::vector<Double_t>& r){_TpcChi2Z=r;}
  void fillTpcClusterSize(const std::vector<unsigned int>& s){_TpcClusterSize=s;}
  void fillTpcClusterSizeU(const std::vector<Double_t>& s){_TpcClusterSizeU=s;}
  void fillTpc2DClusterSize(const std::vector<unsigned int>& s){_Tpc2DClusterSize=s;}
  void fillTpcFullClusterSize(const std::vector<TVector3>& s){_TpcFullClusterSize=s;}
  void fillTpcFullClusterSizeTrack(const std::vector<TVector3>& s){_TpcFullClusterSizeTrack=s;}
  void fillTpcFullClusterSizeAxis(const std::vector<TVector3>& s){_TpcFullClusterSizeAxis=s;}
  void fillTpcClusterAmp(const std::vector<Double_t>& s){_TpcClusterAmp=s;}
  void fillTpcClusterPhi(const std::vector<Double_t>& s){_TpcClusterPhi=s;}
  void fillTpcClusterDists(const std::vector<Double_t>& s){_TpcClusterDist=s;}
  void fillTpcProjPoints(const std::vector<TVector3>& s){_TpcProj=s;}
  void fillTpcProjPointsErr(const std::vector<TVector3>& s){_TpcProjErr=s;}
  void fillTpcProjPointsMom(const std::vector<TVector3>& s){_TpcProjMom=s;}
  void fillTpcProjPointsMomErr(const std::vector<TVector3>& s){_TpcProjMomErr=s;}
  void fillTpcHitPositionsX(const std::vector<Double_t>& s){_TpcPosX=s;}
  void fillTpcHitPositionsY(const std::vector<Double_t>& s){_TpcPosY=s;}
  void fillTpcHitPositionsZ(const std::vector<Double_t>& s){_TpcPosZ=s;}
  void fillTpcHitPositionsR(const std::vector<Double_t>& s){_TpcPosR=s;}
  void fillTpcHitIDs(const std::vector<int>& s){_TpcHitID=s;}


  void fillTpcMaxDigiAmp(const std::vector<Double_t>& s){_TpcMaxDigiAmp=s;}
  void appendMaxDigiAmp(double amp){_TpcMaxDigiAmp.push_back(amp);}
  void appendMaxSampleAmp(double amp){_TpcMaxSampleAmp.push_back(amp);}

  void fillTpcDigisOnPlane(const std::vector<std::vector<TVector3> >& s){_TpcDigisOnPlane=s;}
  void fillTpcDigisOnPlaneAmp(const std::vector<std::vector<Double_t> >& s){_TpcDigisOnPlaneAmp=s;}
  void fillTpcSaturationFlag(const std::vector<bool>& s){_TpcSaturated=s;}
  void fillTpcDSNR(const std::vector<Double_t>& s){_TpcDSNR=s;}
  void fillTpcCSNR(const std::vector<Double_t>& s){_TpcCSNR=s;}

  void appendTpcDSNR(double snr){_TpcDSNR.push_back(snr);}
  void appendTpcCSNR(double snr){_TpcCSNR.push_back(snr);}
  void appendTpcSSNR(double snr){_TpcSSNR.push_back(snr);}

  void fillTpcIsGeomErr(const std::vector<TVector3>& s){_TpcIsGeomErr=s;}
  void fillTpcClusterFitGood(const std::vector<bool>& s){_TpcClusterFitGood=s;}
  void fillTpcEigenValOnPlane(const std::vector<TVector3>& s){_TpcEigenValOnPlane=s;}

  void addFailedHits(int NFH) {_failedHits+=NFH;}
  void setNDF(unsigned int ndf) {_NDF=ndf;}
  void setChi2(Double_t chi2) {_ChiSqu=chi2;}
  
  void appendEigenValOnPlane(TVector3 vec){_TpcEigenValOnPlane.push_back(vec);}
  void appendMinSigma(TVector3 vec){_TpcMinSigma.push_back(vec);}

  void appendResMCTrack(TVector3 vec){_TpcResMCTrack.push_back(vec);}
  void appendResMCTrackUV(TVector3 vec){_TpcResMCTrackUV.push_back(vec);}
  void appendResMCTrackA(TVector3 vec){_TpcResMCTrackA.push_back(vec);}
  void appendCogPos(TVector3 vec){_TpcCogPos.push_back(vec);}
  void appendMinNll(double val){_TpcMinNll.push_back(val);}
  void appendClusterCov(TMatrixD val){_TpcClusterCov.push_back(val);}
  
  void appendOuterAmp(TVector3 vec){_TpcOuterAmp.push_back(vec);}
  void appendInnerAmp(TVector3 vec){_TpcInnerAmp.push_back(vec);}

  void appendDAFWeight(double vec){_TpcDAFWeights.push_back(vec);}

  void appendCovOnPlane(TMatrixD m){_TpcCovOnPlane.push_back(m);}
  void appendUnwCovOnPlane(TMatrixD m){_TpcUnwCovOnPlane.push_back(m);}

  void appendPlaneW(TVector3 vec){_PlaneW.push_back(vec);}
  void appendMidPlaneU(TVector3 vec){_MidPlaneU.push_back(vec);}
  void appendMidPlaneV(TVector3 vec){_MidPlaneV.push_back(vec);}
  void appendMidPlaneW(TVector3 vec){_MidPlaneW.push_back(vec);}
  void appendMidPlaneO(TVector3 vec){_MidPlaneO.push_back(vec);}

  void appendDigisMCRes(std::vector<TVector3> s){_TpcDigiMCRes.push_back(s);}
  void appendDigisTrackRes(std::vector<TVector3> s){_TpcDigiTrackRes.push_back(s);}
  void appendDigiPos(std::vector<TVector3> s){_TpcDigiPos.push_back(s);}
  void appendDigiMom(std::vector<TVector3> s){_TpcDigiMom.push_back(s);}
  void appendDigiMCPos(std::vector<TVector3> s){_TpcDigiMCPos.push_back(s);}
  void appendDigiLen(std::vector<double> s) {_TpcDigiLen.push_back(s);}
  void appendDigiID(std::vector<int> s){_TpcDigiId.push_back(s);}
  void appendPrfWeights(std::vector<double> weights){_TpcDigiPrfWeights.push_back(weights);}

  void appendShapeCov(TMatrixD m){_TpcShapeCov.push_back(m);}
  void appendUnwShapeCov(TMatrixD m){_TpcUnwShapeCov.push_back(m);}
  void appendShapeCovOnPlane(TMatrixD m){_TpcShapeCovOnPlane.push_back(m);}
  void appendUnwShapeCovOnPlane(TMatrixD m){_TpcUnwShapeCovOnPlane.push_back(m);}
  void appendRMS(TVector3 v){_TpcRMS.push_back(v);}
  void appendUnwRMS(TVector3 v){_TpcUnwRMS.push_back(v);}
  void appendRMS_UV(TVector3 v){_TpcRMS_UV.push_back(v);}
  void appendUnwRMS_UV(TVector3 v){_TpcUnwRMS_UV.push_back(v);}
  void appendRMS_A(TVector3 v){_TpcRMS_A.push_back(v);}
  void appendUnwRMS_A(TVector3 v){_TpcUnwRMS_A.push_back(v);}
  void appendRMS_A_UV(TVector3 v){_TpcRMS_A_UV.push_back(v);}
  void appendUnwRMS_A_UV(TVector3 v){_TpcUnwRMS_A_UV.push_back(v);}

  void appendFieldCorr(TVector3 v){_TpcFieldCorr.push_back(v);}

private:

  // Private Data Members ------------
  std::vector<Double_t> _TpcResX;
  std::vector<Double_t> _TpcResY;
  std::vector<Double_t> _TpcResZ;
  std::vector<Double_t> _TpcResU;
  std::vector<Double_t> _TpcResV;
  std::vector<TVector3> _TpcResA;
  std::vector<TVector3> _TpcResAMC;
  std::vector<Double_t> _TpcResMCU;
  std::vector<Double_t> _TpcResMCV;
  std::vector<TVector3> _TpcResMCTrack;
  std::vector<TVector3> _TpcResMCTrackUV;
  std::vector<TVector3> _TpcResMCTrackA;
  std::vector<Double_t> _TpcErrU;
  std::vector<Double_t> _TpcErrV;
  std::vector<Double_t> _TpcResR;
  std::vector<Double_t> _TpcResP;
  std::vector<Double_t> _TpcSigX;
  std::vector<Double_t> _TpcSigY;
  std::vector<Double_t> _TpcSigZ;
  std::vector<TVector3> _TpcSigC;
  std::vector<TVector3> _TpcSigA;
  std::vector<TVector3> _TpcSigT;
  std::vector<Double_t> _TpcSigResT;
  std::vector<Double_t> _TpcSigResMC;
  std::vector<TVector3> _TpcAxis1;
  std::vector<TVector3> _TpcAxis2;
  std::vector<TVector3> _TpcAxis3;
  std::vector<Double_t> _TpcAxis1MCErr;
  std::vector<Double_t> _TpcAxis2MCErr;
  std::vector<Double_t> _TpcAxis3MCErr;
  std::vector<Double_t> _TpcAxis1Diff;
  std::vector<Double_t> _TpcAxis2Diff;
  std::vector<Double_t> _TpcAxis3Diff;
  std::vector<TVector3> _PlaneU;
  std::vector<TVector3> _PlaneV;
  std::vector<TVector3> _PlaneW;
  std::vector<TVector3> _PlaneO;
  std::vector<TVector3> _MidPlaneU;
  std::vector<TVector3> _MidPlaneV;
  std::vector<TVector3> _MidPlaneW;
  std::vector<TVector3> _MidPlaneO;
  std::vector<TVector3> _TpcEigenValOnPlane;
  std::vector<TVector3> _TpcMinSigma;

  std::vector<Double_t> _TpcResMcX;
  std::vector<Double_t> _TpcResMcY;
  std::vector<Double_t> _TpcResMcZ;
  std::vector<Double_t> _TpcResMcP;
  std::vector<Double_t> _TpcResMcR;
  std::vector<Double_t> _TpcMcRefPosX;
  std::vector<Double_t> _TpcMcRefPosY;
  std::vector<Double_t> _TpcMcRefPosZ;
  std::vector<Double_t> _TpcMcRefPosR;
  std::vector<TVector3> _TpcMcPosMom;
  std::vector<TVector3> _TpcGTrack;

  std::vector<Double_t> _TpcChi2X;
  std::vector<Double_t> _TpcChi2Y;
  std::vector<Double_t> _TpcChi2Z;
  std::vector<unsigned int> _TpcClusterSize;
  std::vector<Double_t> _TpcClusterSizeU;
  std::vector<unsigned int> _Tpc2DClusterSize;
  std::vector<TVector3>     _TpcFullClusterSize;
  std::vector<TVector3>     _TpcFullClusterSizeTrack;
  std::vector<TVector3>     _TpcFullClusterSizeAxis;
  std::vector<Double_t>     _TpcClusterAmp;
  std::vector<Double_t>     _TpcClusterPhi;
  std::vector<TVector3>     _TpcProj;
  std::vector<TVector3>     _TpcProjErr;
  std::vector<TVector3>     _TpcProjMom;
  std::vector<TVector3>     _TpcProjMomErr;
  std::vector<Double_t>     _TpcPosX;
  std::vector<Double_t>     _TpcPosY;
  std::vector<Double_t>     _TpcPosZ;
  std::vector<Double_t>     _TpcPosR;
  std::vector<TVector3>     _TpcCogPos;
  std::vector<int>          _TpcHitID;
  std::vector<Double_t>     _TpcClusterDist;
  std::vector<Double_t>     _TpcMaxDigiAmp;
  std::vector<Double_t>		_TpcMaxSampleAmp;
  std::vector<std::vector<TVector3> > _TpcDigisOnPlane;
  std::vector<std::vector<TVector3> > _TpcDigiPos;
  std::vector<std::vector<TVector3> > _TpcDigiMCPos;
  std::vector<std::vector<Double_t> > _TpcDigisOnPlaneAmp;
  std::vector<std::vector<TVector3> > _TpcDigiMCRes;
  std::vector<std::vector<TVector3> > _TpcDigiMom;
  std::vector<std::vector<TVector3> > _TpcDigiTrackRes;
  std::vector<std::vector<TVector3> > _TpcDigiRes;
  std::vector<std::vector<double> >   _TpcDigiLen;
  std::vector<std::vector<int> >      _TpcDigiId;
  std::vector<std::vector<double> >   _TpcDigiPrfWeights;
  std::vector<bool>         _TpcSaturated;
  std::vector<Double_t>     _TpcDSNR;
  std::vector<Double_t>     _TpcCSNR;
  std::vector<Double_t>     _TpcSSNR;
  std::vector<TVector3>     _TpcIsGeomErr;
  std::vector<bool>         _TpcClusterFitGood;
  std::vector<double>       _TpcMinNll;
  std::vector<TMatrixD>     _TpcClusterCov;
  std::vector<TVector3>     _TpcOuterAmp;
  std::vector<TVector3>     _TpcInnerAmp;
  std::vector<double> 	    _TpcDAFWeights;
  std::vector<TMatrixD>     _TpcCovOnPlane;
  std::vector<TMatrixD>     _TpcUnwCovOnPlane;
  std::vector<TMatrixD>     _TpcShapeCov;
  std::vector<TMatrixD>     _TpcUnwShapeCov;
  std::vector<TMatrixD>     _TpcShapeCovOnPlane;
  std::vector<TMatrixD>     _TpcUnwShapeCovOnPlane;
  std::vector<TVector3>     _TpcRMS;
  std::vector<TVector3>     _TpcUnwRMS;
  std::vector<TVector3>     _TpcRMS_UV;
  std::vector<TVector3>     _TpcUnwRMS_UV;
  std::vector<TVector3>     _TpcRMS_A;
  std::vector<TVector3>     _TpcUnwRMS_A;
  std::vector<TVector3>     _TpcRMS_A_UV;
  std::vector<TVector3>     _TpcUnwRMS_A_UV;
  std::vector<TVector3> 	_TpcFieldCorr;

  Double_t _p;
  Double_t _pmc;
  Double_t _pstart;
  Double_t _theta;
  Double_t _phi;
  Double_t _length;
  Double_t _clmeanamp;
  Double_t _clmediamp;
  Double_t _clsumamp;
  Double_t _clsizemed2d;
  Double_t _clsizemed3d;
  TVector3 _mom;
  TVector3 _momerr;
  TVector3 _pos;
  TVector3 _poserr;
  TVector3 _MCpos;
  TVector3 _MCmom;
  TVector3 _zAxisPoca; 
  TVector3 _zAxisDir;
  TVector3 _firstMCPoca;
  TVector3 _firstMCDir;
  Double_t _charge;
  Double_t _mccharge;
  Double_t _sigp;
  Int_t _nPDG;
  Int_t _motherID;
  int _statflag;
  Double_t _meanz;
  int _event;
  Double_t _trackChi;

  unsigned int _failedHits;   //stores the number of failed hits (cov was zero)
  
  bool _hasMc;
  Double_t _ChiSqu;
  unsigned int _NDF;

  // Private Methods -----------------

public:
  ClassDef(TpcCosmics,4)

};

#endif