// 
// Class AliRsnMonitorTrack
//
// Monitor object used
// for storing info ina TTree
// and studying cut values and variables.
//
// author: A. Pulvirenti
//

#ifndef ALIRSNMONITORTRACK_H
#define ALIRSNMONITORTRACK_H

#include "AliPID.h"

class AliESDtrack;
class AliTOFT0maker;
class AliStack;

class AliRsnMonitorTrack : public TObject
{
  public:

    AliRsnMonitorTrack();
    AliRsnMonitorTrack(const AliRsnMonitorTrack& copy);
    //AliRsnMonitorTrack& operator=(const AliRsnMonitorTrack& copy) {MakeCopy(copy); return (*this);}
    virtual ~AliRsnMonitorTrack() { /*nothing*/ }
    
    void       Reset();
    Bool_t     AdoptMC(Int_t label, AliStack *stack);

    Bool_t&    CutsPassed()     {return fCutsPassed;}
    
    Double_t&  PsimX()          {return fPsim[0];}
    Double_t&  PrecX()          {return fPrec[0];}
    Double_t&  PtpcX()          {return fPtpc[0];}
    
    Double_t&  PsimY()          {return fPsim[1];}
    Double_t&  PrecY()          {return fPrec[1];}
    Double_t&  PtpcY()          {return fPtpc[1];}
    
    Double_t&  PsimZ()          {return fPsim[2];}
    Double_t&  PrecZ()          {return fPrec[2];}
    Double_t&  PtpcZ()          {return fPtpc[2];}
    
    Double_t   PsimT()          {return TMath::Sqrt(fPsim[0]*fPsim[0] + fPsim[1]*fPsim[1]);}
    Double_t   PrecT()          {return TMath::Sqrt(fPrec[0]*fPrec[0] + fPrec[1]*fPrec[1]);}
    Double_t   PtpcT()          {return TMath::Sqrt(fPtpc[0]*fPtpc[0] + fPtpc[1]*fPtpc[1]);}
    
    Double_t   Psim()           {return TMath::Sqrt(PsimT()*PsimT() + fPsim[2]*fPsim[2]);}
    Double_t   Prec()           {return TMath::Sqrt(PrecT()*PrecT() + fPrec[2]*fPrec[2]);}
    Double_t   Ptpc()           {return TMath::Sqrt(PtpcT()*PtpcT() + fPtpc[2]*fPtpc[2]);}
    
    Bool_t&    Prim()           {return fPrim;}
    Int_t&     PDG()            {return fPDG;}
    Int_t&     PDGM()           {return fPDGM;}
    Int_t&     Mother()         {return fMother;}

    Bool_t     OkFlag(UInt_t f) {return ((fStatus & f) != 0);}
    UInt_t&    Status()         {return fStatus;}
    Double_t&  Length()         {return fLength;}
    Int_t&     Charge()         {return fCharge;}
    Double_t&  DCAr()           {return fDCA[0];}
    Double_t&  DCAz()           {return fDCA[1];}
    
    Bool_t&    ITSsa()          {return fITSsa;}
    Bool_t&    TOFok()          {return fTOFok;}
    
    Bool_t&    ITSmap(Int_t i)    {if (i>=0 && i<6) return fITSmap[i]; else return fITSmap[0];}
    Int_t      ITScount()         {return (SPDcount() + SDDcount() + SSDcount());}
    Int_t      SPDcount()         {Int_t count=0; if (fITSmap[0]) count++; if (fITSmap[1]) count++; return count;}
    Int_t      SDDcount()         {Int_t count=0; if (fITSmap[2]) count++; if (fITSmap[3]) count++; return count;}
    Int_t      SSDcount()         {Int_t count=0; if (fITSmap[4]) count++; if (fITSmap[5]) count++; return count;}
    Double_t&  ITSchi2()          {return fITSchi2;}
    Double_t&  ITSsignal()        {return fITSsignal;}
    Double_t&  ITSnsigma(Int_t i) {if (i>=0 && i<AliPID::kSPECIES) return fITSnsigma[i]; else return fITSnsigma[0];}
    
    Int_t&     TPCcount()         {return fTPCcount;}
    Double_t&  TPCchi2()          {return fTPCchi2;}
    Double_t&  TPCsignal()        {return fTPCsignal;}
    Double_t&  TPCnsigma(Int_t i) {if (i>=0 && i<AliPID::kSPECIES) return fTPCnsigma[i]; else return fTPCnsigma[0];}
    
    Double_t&  TOFsignal()        {return fTOFsignal;}
    Double_t&  TOFsigma(Int_t i)  {if (i>=0 && i<AliPID::kSPECIES) return fTOFsigma[i]; else return fTOFsigma[0];}
    Double_t&  TOFref(Int_t i)    {if (i>=0 && i<AliPID::kSPECIES) return fTOFref[i]; else return fTOFref[0];}
    Double_t   TOFnsigma(Int_t i) {if (i>=0 && i<AliPID::kSPECIES) return ((fTOFsignal - fTOFref[i]) / fTOFsigma[i]); return 1E6;}

  private:
  
    Bool_t       fCutsPassed;                     // did it pass all defined cuts?
    
    Bool_t       fPrim;                           // is physical primary?
    Int_t        fPDG;                            // true PDG code
    Int_t        fPDGM;                           // PDG code of mother (if any)
    Int_t        fMother;                         // label of mother (if any)

    UInt_t       fStatus;                         // 'status' flag of track in ESD (0 = none)
    Double_t     fLength;                         // integrated length
    Int_t        fCharge;                         // track charge
    Double_t     fDCA[2];                         // DCA ([0] = xy, [1] = z)
        
    Bool_t       fITSsa;                          // to know if its is ITS standalone (otherwise it is TPC)
    Bool_t       fTOFok;                          // to know if track has a TOF match
    
    Bool_t       fITSmap[6];                      // ITS cluster map
    Double_t     fITSchi2;                        // chi2 in ITS
    Double_t     fITSsignal;                      // ITS signal used for PID
    Double_t     fITSnsigma[AliPID::kSPECIES];    // number of sigmas ITS
    
    Int_t        fTPCcount;                       // # TPC clusters
    Double_t     fTPCchi2;                        // TPC chi 2
    Double_t     fTPCsignal;                      // TPC dEdx signal
    Double_t     fTPCnsigma[AliPID::kSPECIES];    // number of sigmas TPC for: e, mu, pi, K, p
    
    Double_t     fTOFsignal;                      // TOF signal
    Double_t     fTOFsigma[AliPID::kSPECIES];     // TOF sigma for: e, mu, pi, K, p
    Double_t     fTOFref[AliPID::kSPECIES];       // expected times for: e, mu, pi, K, p
    
    Double_t     fPsim[3];                        // simulated momentum
    Double_t     fPrec[3];                        // reconstructed momentum
    Double_t     fPtpc[3];                        // reconstructed momentum at the TPC inner wall

    ClassDef(AliRsnMonitorTrack, 1)
};

#endif