/// \class AliParticle
/// \brief This class is used as container of all information needed to apply ML
///
/// \author: Marco Fargetta <marco.fargetta@ct.infn.it>
///

#ifndef ALIPARTICLE_H
#define ALIPARTICLE_H


#include <TObject.h>

#include <AliAODcascade.h>
#include <AliAODTrack.h>
#include <AliAODv0.h>

class AliRsnDaughter;
class AliRsnEvent;
class AliRsnMiniParticle;
class AliRsnDaughter;
namespace INFNCatania {
    class AliParticle : public TObject {
    public:
        AliParticle();
        AliParticle(AliRsnMiniParticle *);
        AliParticle(const AliParticle &);
        AliParticle& operator=(const AliParticle &);
        Bool_t AddSelectionValues(AliRsnDaughter &, AliRsnEvent &);

        // Getter
        Int_t GetTypeParticle() const { return fTypeParticle; }
        Int_t GetIndex() {return  fIndex; }
        Int_t GetIndexV0Pos() { return fIndexDaughters[0]; }
        Int_t GetIndexV0Neg() { return fIndexDaughters[1]; }
        Int_t GetIndexBachelor() { return fIndexDaughters[2]; }
        Short_t GetCharge() { return fCharge; }
        Float_t GetPsimX() { return fPsim[0]; }
        Float_t GetPsimY() { return fPsim[1]; }
        Float_t GetPsimZ() { return fPsim[2]; }
        Float_t GetPrecX() { return fPrec[0]; }
        Float_t GetPrecY() { return fPrec[1]; }
        Float_t GetPrecZ() { return fPrec[2]; }
        // Double_t GetMassSim() { return fMassSim; }
        // Double_t GetMassRec() { return fMassRec; }
        Float_t GetPmotherX() {return fPmother[0]; }
        Float_t GetPmotherY() {return fPmother[1]; }
        Float_t GetPmotherZ() {return fPmother[2]; }
        Long_t GetPDG() { return fPDG; }
        Int_t GetMother() { return fMother; }
        Long_t GetMotherPDG() {return fMotherPDG; }
        Double_t GetDCA() { return fDCA; }
        Short_t GetNTotSisters() {return fNTotSisters; }
        Bool_t GetIsFromB() { return fIsFromB; }
        Bool_t GetIsQuarkFound() { return fIsQuarkFound; }
        UShort_t GetCutBits() { return fCutBits; }
        Bool_t GetPassesOOBPileupCut() { return fPassesOOBPileupCut; }
        
        Float_t GetEtaDaughter0() { return fEtaDaughter[0]; }
        Float_t GetEtaDaughter1() { return fEtaDaughter[1]; }
        Float_t GetEtaDaughter2() { return fEtaDaughter[2]; }
        Bool_t GetTPCRefit0() { return fTPCRefit[0]; }
        Bool_t GetTPCRefit1() { return fTPCRefit[1]; }
        Bool_t GetTPCRefit2() { return fTPCRefit[2]; }
        Bool_t GetKinkDaughters0() { return fKinkDaughters[0]; }
        Bool_t GetKinkDaughters1() { return fKinkDaughters[1]; }
        Bool_t GetKinkDaughters2() { return fKinkDaughters[2]; }
        Int_t GetNumCrossRowTPC0() { return fNumCrossRowTPC[0]; }
        Int_t GetNumCrossRowTPC1() { return fNumCrossRowTPC[1]; }
        Int_t GetNumCrossRowTPC2() { return fNumCrossRowTPC[2]; }
        Float_t GetRatioCrossedRowsOverFindableClustersTPC0() { return fRatioCrossedRowsOverFindableClustersTPC[0]; }
        Float_t GetRatioCrossedRowsOverFindableClustersTPC1() { return fRatioCrossedRowsOverFindableClustersTPC[1]; }
        Float_t GetRatioCrossedRowsOverFindableClustersTPC2() { return fRatioCrossedRowsOverFindableClustersTPC[2]; }
        Float_t GetDCAToVertexXY0() { return fDCAToVertexXY[0]; }
        Float_t GetDCAToVertexXY1() { return fDCAToVertexXY[1]; }
        Float_t GetDCAToVertexXY2() { return fDCAToVertexXY[2]; }
        Short_t GetChargeDoughter0() { return fChargeDoughter[0]; }
        Short_t GetChargeDoughter1() { return fChargeDoughter[1]; }
        Short_t GetChargeDoughter2() { return fChargeDoughter[2]; }

        Float_t GetPIDCutPion() { return fPIDCutPion; }
        Float_t GetPIDCutPion2() { return fPIDCutPion2; }
        Float_t GetPIDCutProton() { return fPIDCutProton; }
        Float_t GetPIDCutBachelor() { return fPIDCutBachelor; }
        Float_t GetDaughDCA() { return fDaughDCA; }
        Float_t GetDaughDCACascade() { return fDaughDCACascade; }
        Float_t GetDCAVertex() { return fDCAVertex; }
        Float_t GetDCAVertexCascade() { return fDCAVertexCascade; }
        Float_t GetLife() { return fLife; }
        Float_t GetRadius() { return fRadius; }
        Float_t GetRadiusCascade() { return fRadiusCascade; }
        Int_t GetPtTolerance() { return fPtTolerance; }
        Float_t GetMassTolSigma() { return fMassTolSigma; }
        Float_t GetMassTolerance() { return fMassTolerance; }
        Float_t GetMassToleranceCascade() { return fMassToleranceCascade; }
        Float_t GetMassTolVetoMat() { return fMassTolVetoMat; }
        Float_t GetMassTolVetoAntiMat() { return fMassTolVetoAntiMat; }
        Float_t GetCosPointAngle() { return fCosPointAngle; }
        Float_t GetCosPointAngleCascade() { return fCosPointAngleCascade; }
        Float_t GetRapidity() { return fRapidity; }
        Float_t GetEta() { return fEta; }
        Int_t GetTPCcluster() { return fTPCcluster; }
        
    private:
        Bool_t AddV0AOD(AliAODv0*, AliRsnEvent &);
        Bool_t AddCascadeAOD(AliAODcascade*, AliRsnEvent&);
        Bool_t AODTrackAccepted(AliAODTrack*, Int_t);

        Int_t fTypeParticle;   //!

        // Paramaters available in AliRsnMiniParticle
        Int_t     fIndex;              // ID of track in its event
        Int_t     fIndexDaughters[3];  // daughter pos (if not V0/resonance then 0:ESD/AOD label),
                                       // daugher neg (if not V0/resonance then -1) and daugher bachelor
        Short_t   fCharge;             // track charge *character*: '+', '-', '0' (whatever else = undefined)
        Float_t   fPsim[3];            // MC momentum of the track
        Float_t   fPrec[3];            // reconstructed momentum of the track
        // Double_t  fMassSim;            // simulated mass
        // Double_t  fMassRec;            // reconstructed mass
        Float_t   fPmother[3];         // MC momentum of the track's mother
        Long_t    fPDG;                // particle PDG code
        Int_t     fMother;             // index of mother in its container
        Long_t    fMotherPDG;          // PDG code of mother
        Double_t  fDCA;                // DCA of the particle
        Short_t   fNTotSisters;        // number of  daughters of the particle
        Bool_t    fIsFromB;	           // is the particle from B meson flag
        Bool_t    fIsQuarkFound;       // is the particle from a quark flag (used to reject or accept Hijing event)
        UShort_t  fCutBits;            // list of bits used to know what cuts were passed by this track
        Bool_t    fPassesOOBPileupCut; // passes out-of-bunch pileup cut

        // Parameters used to cut daughter trucks
        Float_t       fEtaDaughter[3];           // Pseudorapidity (|eta| < 0.8)
        Bool_t        fTPCRefit[3];
        Bool_t        fKinkDaughters[3];         // NOTA: not used at the moment
        Int_t         fNumCrossRowTPC[3];        // Number of Crossed Rows in TPC
        Float_t       fRatioCrossedRowsOverFindableClustersTPC[3];
        Float_t       fDCAToVertexXY[3];
        Short_t       fChargeDoughter[3];

        // Parameters used to cut V0 (if not specified refer to V0 or hte whole)
        Float_t fPIDCutPion;
        Float_t fPIDCutPion2;
        Float_t fPIDCutProton;
        Float_t fPIDCutBachelor;
        Float_t fDaughDCA;
        Float_t fDaughDCACascade;
        Float_t fDCAVertex;
        Float_t fDCAVertexCascade;
        Float_t fLife;
        Float_t fRadius;
        Float_t fRadiusCascade;
        Int_t   fPtTolerance;                //! Used in ESD
        Float_t fMassTolSigma;               //! Used in ESD
        Float_t fMassTolerance;
        Float_t fMassToleranceCascade;
        Float_t fMassTolVetoMat;
        Float_t fMassTolVetoAntiMat;
        Float_t fCosPointAngle;
        Float_t fCosPointAngleCascade;
        Float_t fRapidity;
        Float_t fEta;                        // Verified with the cut MaxPseudorapidity
        Int_t   fTPCcluster;                 //! Not used

        const Double_t fMassK0Short = 0.497614;     //!
        const Double_t fMassLambda = 1.115683;      //!
        const Double_t fMassXi = 1.3217;            //!
        const Double_t fMassOmega = 1.6725;         //!


        ClassDef(AliParticle, 1);
    };
}
#endif