StEmbeddingQATrack.h

//----------------------------------------------------------------------------------------------------
//  Class StEmbeddingQATrack
//    Store relevant track informations for the embedding/real data QA
//----------------------------------------------------------------------------------------------------
/****************************************************************************************************
 * $Id: StEmbeddingQATrack.h,v 1.13 2019/07/10 05:46:22 zhux Exp $
 * $Log: StEmbeddingQATrack.h,v $
 * Revision 1.13  2019/07/10 05:46:22  zhux
 * added option for btof pid for primary real tracks
 *
 * Revision 1.12  2011/04/01 05:00:18  hmasui
 * Move track cuts into StEmbeddingQAUtilities, added global momentum for embedding
 *
 * Revision 1.11  2011/02/11 23:21:28  hmasui
 * Added missing functions getNSigma...()
 *
 * Revision 1.10  2011/02/11 03:55:48  hmasui
 * Change geantid type to integer
 *
 * Revision 1.9  2011/01/12 21:36:17  hmasui
 * Add nHitsFit/nHitsPoss cut
 *
 * Revision 1.8  2010/05/14 19:49:07  hmasui
 * Add rapidity cut
 *
 * Revision 1.7  2010/04/24 20:20:11  hmasui
 * Add geant process, and modift the type of parent, parent-parent geantid to match the data members in minimc tree
 *
 * Revision 1.6  2010/02/16 02:11:49  hmasui
 * Add parent-parent geantid
 *
 * Revision 1.5  2009/12/22 21:39:31  hmasui
 * Add comments for functions and members
 *
 ****************************************************************************************************/

#ifndef _StEmbeddingQATrack_h__
#define _StEmbeddingQATrack_h__

#include "TString.h"
#include "StLorentzVectorD.hh"

class StTinyMcTrack ;
class StMiniMcPair ;
class StContamPair ;
class StMuTrack ;

class StEmbeddingQATrack {
  public:
    StEmbeddingQATrack();

    StEmbeddingQATrack(const TString name, const StTinyMcTrack& track) ;

    StEmbeddingQATrack(const TString name, StMiniMcPair* track) ;

    StEmbeddingQATrack(const TString name, StContamPair* track) ;

    //  Need to put the geantid by hand 
    //  in order to calculate rapidity (and maybe invariant mass if you like)
    //  since the real tracks don't have geantid
    StEmbeddingQATrack(const TString name, const StMuTrack& track, const Int_t geantid, const Bool_t btof);

    virtual ~StEmbeddingQATrack();

    Bool_t isPtAndEtaOk() const ;  
    Bool_t isRapidityOk(const Double_t ycut) const ; 

    Bool_t isNHitOk() const ;      
    Bool_t isNHitToNPossOk() const ; 
    Bool_t isDcaOk() const ;       
    Bool_t isCommonHitOk() const ; 

    // if ( real tracks ) return |nSigma| < 2 
    // else               return true (i.e. no nSigma cut)
    Bool_t isNSigmaOk(const Int_t geantid) const ;

    StLorentzVectorD getVectorMc() const ; 
    StLorentzVectorD getVectorRc() const ; 
    StLorentzVectorD getVectorPr() const ; 
    StLorentzVectorD getVectorGl() const ; 

    Short_t getNCommonHit()          const ; 
    Int_t   getParentParentGeantId() const ; 
    Int_t   getParentGeantId()       const ; 
    Int_t   getGeantId()             const ; 
    Int_t   getGeantProcess()        const ; 
    Short_t getNHit()                const ; 
    Short_t getNHitPoss()            const ; 
    Short_t getCharge()              const ; 

    Double_t getMassMc()         const ; 
    Float_t getPtMc()            const ; 
    Float_t getPxMc()            const ; 
    Float_t getPyMc()            const ; 
    Float_t getPzMc()            const ; 
    Float_t getPMc()             const ; 
    Float_t getEtaMc()           const ; 
    Float_t getRapidityMc()      const ; 
    Double_t getMassRc()         const ; 
    Float_t getPtRc()            const ; 
    Float_t getPxRc()            const ; 
    Float_t getPyRc()            const ; 
    Float_t getPzRc()            const ; 
    Float_t getPRc()             const ; 
    Float_t getEtaRc()           const ; 
    Float_t getRapidityRc()      const ; 

    Float_t getPhi()           const ; 
    Float_t getdEdx()          const ; 
    Float_t getdEdxkeV()       const ; 
    Float_t getDcaGl()         const ; 

    // nSigma (e, pi, K, p) for real data
    Double_t getNSigmaElectron() const ; 
    Double_t getNSigmaPion()     const ; 
    Double_t getNSigmaKaon()     const ; 
    Double_t getNSigmaProton()   const ; 

    void print() const ;

    const TString getName() const ;

  private:
    const Short_t mNCommonHit ;           
    const Int_t   mParentParentGeantId ;  
    const Int_t   mParentGeantId ;        
    const Int_t   mGeantId ;              
    const Int_t   mGeantProcess ;         
    const Short_t mNHit ;                 
    const Short_t mNHitPoss ;             
    const Short_t mCharge ;               
    const StLorentzVectorD mVectorMc ;    
    const StLorentzVectorD mVectorRc ;    
    const StLorentzVectorD mVectorGl ;    
    const Float_t mPhi ;                  
    const Float_t mdEdx ;                 
    const Float_t mDcaGl ;                
    const Double_t mNSigmaElectron ;      
    const Double_t mNSigmaPion ;          
    const Double_t mNSigmaKaon ;          
    const Double_t mNSigmaProton ;        

    TString mName ; 

    ClassDef(StEmbeddingQATrack, 2)
};

inline Short_t StEmbeddingQATrack::getNCommonHit()          const { return mNCommonHit ; }
inline Int_t   StEmbeddingQATrack::getParentParentGeantId() const { return mParentParentGeantId ; }
inline Int_t   StEmbeddingQATrack::getParentGeantId()       const { return mParentGeantId ; }
inline Int_t   StEmbeddingQATrack::getGeantId()             const { return mGeantId ; }
inline Int_t   StEmbeddingQATrack::getGeantProcess()        const { return mGeantProcess ; }
inline Short_t StEmbeddingQATrack::getNHit()                const { return mNHit ; }
inline Short_t StEmbeddingQATrack::getNHitPoss()            const { return mNHitPoss ; }
inline Short_t StEmbeddingQATrack::getCharge()              const { return mCharge ; }

inline Double_t StEmbeddingQATrack::getMassMc()       const { return mVectorMc.m() ; }
inline Float_t StEmbeddingQATrack::getPMc()           const { return mVectorMc.vect().mag() ; }
inline Float_t StEmbeddingQATrack::getPtMc()          const { return mVectorMc.perp() ; }
inline Float_t StEmbeddingQATrack::getPxMc()          const { return mVectorMc.x() ; }
inline Float_t StEmbeddingQATrack::getPyMc()          const { return mVectorMc.y() ; }
inline Float_t StEmbeddingQATrack::getPzMc()          const { return mVectorMc.z() ; }
inline Float_t StEmbeddingQATrack::getEtaMc()         const { return mVectorMc.pseudoRapidity() ; }
inline Float_t StEmbeddingQATrack::getRapidityMc()    const { return mVectorMc.rapidity() ; }
inline Double_t StEmbeddingQATrack::getMassRc()       const { return mVectorRc.m() ; }
inline Float_t StEmbeddingQATrack::getPRc()           const { return mVectorRc.vect().mag() ; }
inline Float_t StEmbeddingQATrack::getPtRc()          const { return mVectorRc.perp() ; }
inline Float_t StEmbeddingQATrack::getPxRc()          const { return mVectorRc.x() ; }
inline Float_t StEmbeddingQATrack::getPyRc()          const { return mVectorRc.y() ; }
inline Float_t StEmbeddingQATrack::getPzRc()          const { return mVectorRc.z() ; }
inline Float_t StEmbeddingQATrack::getEtaRc()         const { return mVectorRc.pseudoRapidity() ; }
inline Float_t StEmbeddingQATrack::getRapidityRc()    const { return mVectorRc.rapidity() ; }

inline Float_t StEmbeddingQATrack::getPhi()           const { return mPhi ; }
inline Float_t StEmbeddingQATrack::getdEdx()          const { return mdEdx ; }
inline Float_t StEmbeddingQATrack::getdEdxkeV()       const { return mdEdx * 1.0e+06 ; }
inline Float_t StEmbeddingQATrack::getDcaGl()         const { return mDcaGl ; }

inline Double_t StEmbeddingQATrack::getNSigmaElectron() const { return mNSigmaElectron ; }
inline Double_t StEmbeddingQATrack::getNSigmaPion()     const { return mNSigmaPion ; }
inline Double_t StEmbeddingQATrack::getNSigmaKaon()     const { return mNSigmaKaon ; }
inline Double_t StEmbeddingQATrack::getNSigmaProton()   const { return mNSigmaProton ; }

inline const TString StEmbeddingQATrack::getName() const { return mName ; }

#endif