Conversion.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Conversion.h

#ifndef CONVERSION_H__
#define CONVERSION_H__

#include <g4main/PHG4Particle.h>
#include <g4main/PHG4VtxPoint.h>
#include <trackbase_historic/SvtxTrack.h>
#include <trackbase_historic/SvtxClusterMap.h>
#include <trackbase_historic/SvtxVertex.h>
#include <g4eval/SvtxTrackEval.h>
#include <GenFit/GFRaveVertex.h>
#include <TLorentzVector.h>
#include <TVector3.h>
#include <utility>

namespace PHGenFit {
  class Track;
} /* namespace PHGenFit */


class SvtxTrackEval;
class PHCompositeNode;
class PHG4TruthInfoContainer;
class TLorentzVector;
class SvtxHitMap;
class SVReco;
class VtxRegressor;

//TODO check function to see ifthey can be made const
class Conversion
{
  public:
    Conversion(){verbosity=0;}
    Conversion(SvtxTrackEval* trackeval,int verbosity=0);
    Conversion(PHG4VtxPoint* vtx,int verbosity=0);
    Conversion(PHG4VtxPoint* vtx,SvtxTrackEval *trackeval,int verbosity=0);
    ~Conversion();
    void setElectron(PHG4Particle* e);
    inline void setTrackEval(SvtxTrackEval *trackeval){this->trackeval=trackeval;}
    inline void setVtx(PHG4VtxPoint* vtx){this->vtx=vtx;}
    inline PHG4VtxPoint* getVtx()const{return vtx;}
    inline bool isComplete()const{
      if (e1&&e2&&photon)
      {
        return true;
      }
      else{
        return false;
      }
    }
    inline bool hasPair()const{
      if (e1&&e2)
      {
        return true;
      }
      else{
        return false;
      }
    }
    bool setParent(PHG4Particle* parent);

    void setPrimaryPhoton(PHG4Particle* parent,PHG4TruthInfoContainer* truthinfo);

    inline int recoCount()const{
      int r=0;
      if (reco1)
      {
        r++;
      }
      if (reco2)
      {
        r++;
      }
      return r;
    }
    PHG4Particle* getElectron();
    inline PHG4Particle* getElectron()const{return e1;}
    PHG4Particle* getPositron();
    inline PHG4Particle* getPositron()const{return e2;}
    inline PHG4Particle* getPhoton()const{return photon;}
    inline PHG4Particle* getPrimaryPhoton()const{return primaryPhoton;}
    inline int getEmbed() const {return embedID;}

    inline void setEmbed(int embedID) {this->embedID=embedID;}
    inline void setSourceId(int source){sourceId=source;}
    inline int getSourceId()const{return sourceId;}
    inline genfit::GFRaveVertex* getRecoVtx()const{return recoVertex;}
    float trackDEta()const;
    static float trackDEta(SvtxTrack* reco1, SvtxTrack* reco2);
    inline float trackDPhi()const{
      if (recoCount()==2)
      {
        return DeltaPhi(reco1->get_phi(),reco2->get_phi());
      }
      else return -1.;
    }
    inline static float trackDPhi(SvtxTrack* reco1, SvtxTrack* reco2){
      return DeltaPhi(reco1->get_phi(),reco2->get_phi());
    }
    float minTrackpT();
    std::pair<float,float> getTrackpTs();
    std::pair<float,float> getTrackEtas();
    std::pair<float,float> getTrackPhis();
    inline std::pair<SvtxTrack*,SvtxTrack*> getRecoTracks()const{
      return std::pair<SvtxTrack*,SvtxTrack*>(reco1,reco2);
    }
    SvtxTrack* getRecoTrack(unsigned truthID) const;
    inline void setClusterMap(SvtxClusterMap* cmap){
      _svtxClusterMap=cmap;
    }
    inline int setVerbosity(int v){
      verbosity=v;
      return verbosity;
    }
    int get_cluster_id();
    int get_cluster_id()const;
    int get_cluster_id(SvtxTrackEval *trackeval);
    std::pair<int,int> get_cluster_ids();
    int setRecoTracks(SvtxTrackEval* trackeval);
    int setRecoTracks();
    void setRecoTrack(int truthID, SvtxTrack* recoTrack);
    bool setElectron();
    int trackDLayer(SvtxClusterMap* cmap,SvtxHitMap *hitmap);
    int trackDLayer(TrkrClusterContainer* );
    static int trackDLayer(TrkrClusterContainer*,SvtxTrack*,SvtxTrack* );
    int firstLayer(SvtxClusterMap* cmap,SvtxHitMap *hitmap);
    int firstLayer(TrkrClusterContainer* );
    bool hasSilicon(SvtxClusterMap* );
    double approachDistance()const;
    static double approachDistance(SvtxTrack*,SvtxTrack*);
    double dist(PHG4VtxPoint* vtx, SvtxClusterMap* cmap);
    double dist(TVector3* vtx, SvtxClusterMap* cmap);
    double dist(TVector3* vtx, TrkrClusterContainer* cmap);
    float minDca();
    float vtxTrackRPhi(TVector3 vertpos);
    static float vtxTrackRPhi(TVector3 vertpos,SvtxTrack*,SvtxTrack*);
    float vtxTrackRZ(TVector3 vertpos);
    static float vtxTrackRZ(TVector3 vertpos,SvtxTrack*,SvtxTrack*);

    //Deprecated 
    //float setRecoVtx(SvtxVertex* recovtx,SvtxClusterMap* cmap);
    TLorentzVector* setRecoPhoton();
    TLorentzVector* getRecoPhoton();
    static TLorentzVector* getRecoPhoton(SvtxTrack* reco1, SvtxTrack* reco2);

    TLorentzVector* getRefitRecoPhoton();
    PHG4Particle* getTruthPhoton(PHG4TruthInfoContainer*);

    std::pair<PHGenFit::Track*,PHGenFit::Track*> refitTracks(SVReco* vertexer, SvtxVertex* recoVtx);
    std::pair<PHGenFit::Track*,PHGenFit::Track*> refitTracks(SVReco* vertexer);

    std::pair<PHGenFit::Track*,PHGenFit::Track*> refitTracksTruthVtx(SVReco* vertexer);
    std::pair<PHGenFit::Track*,PHGenFit::Track*> refitTracksTruthVtx(SVReco* vertexer,SvtxVertex* seedVtx);
    //TODO Set {@link recoVertex} to the vertex reconstructed from {@link SVReco} using the reco tracks and @return {@link recoVertex}. @return NULL if {@link recoCount()}!=2. Delete any existing {@link recoVertex}
    genfit::GFRaveVertex* getSecondaryVertex(SVReco* vertexer);
    std::pair<PHGenFit::Track*,PHGenFit::Track*> getPHGFTracks(SVReco* vertexer);
    /*Convertes {@link reco1} and {@link reco2} into a pair of TLorentzVector* using the electron mass. 
     * references {@link recoCount()} to determine which NULL values to @return
     * Ownership is returned.**/
    std::pair<TLorentzVector*,TLorentzVector*> getRecoTlvs();
    /*Convertes {@link _refit_phgf_tracks} into a pair of TLorentzVector* using the electron mass. 
     * If either refit track is not defined @return will be a pair of NULL vectors
     * Ownership is returned.**/
    std::pair<TLorentzVector*,TLorentzVector*> getRefitRecoTlvs();
    std::pair<PHG4Particle*,PHG4Particle*> getParticlesMissingTrack();
    genfit::GFRaveVertex* correctSecondaryVertex(VtxRegressor* regressor);
    static genfit::GFRaveVertex* correctSecondaryVertex(VtxRegressor* regressor,genfit::GFRaveVertex*, SvtxTrack* reco1, SvtxTrack* reco2);
    inline static double InTwoPi (double phi) {
      while (phi < 0 || 2*TMath::Pi() <= phi) {
        if (phi < 0) phi += 2*TMath::Pi();
        else phi -= 2*TMath::Pi();
      }
      return phi;
    }

    inline static double DeltaPhi (double phi1, double phi2) {
      phi1 = InTwoPi(phi1);
      phi2 = InTwoPi(phi2);
      double dphi = abs(phi1 - phi2);
      while (dphi > TMath::Pi()) dphi = abs (dphi - 2*TMath::Pi());
      return dphi;
    }

    void printTruth();
    void printReco();
    void PrintPhotonRecoInfo();
    void PrintPhotonRecoInfo(TLorentzVector *tlv_photon,TLorentzVector *tlv_electron, TLorentzVector *tlv_positron,float mass);
  private:
    PHG4Particle* e1=NULL;
    PHG4Particle* e2=NULL;
    PHG4Particle* photon=NULL;
    PHG4Particle* primaryPhoton=NULL;
    PHG4VtxPoint* vtx=NULL;
    SvtxVertex* truthSvtxVtx=NULL;
    SvtxTrack* reco1=NULL;
    SvtxTrack* reco2=NULL;
    SvtxTrackEval* trackeval=NULL;
    SvtxClusterMap* _svtxClusterMap=NULL;                                                                              
    genfit::GFRaveVertex *recoVertex=NULL;
    TLorentzVector *recoPhoton=NULL;
    std::pair<PHGenFit::Track*,PHGenFit::Track*> _refit_phgf_tracks;
    std::pair<unsigned,unsigned> pairTruthReco1;
    std::pair<unsigned,unsigned> pairTruthReco2;

    static const int _kNSiliconLayer =7; 
    int embedID=0;
    int verbosity;
    int sourceId;
    static const float _kElectronRestM;
    static float vtxTrackRZ(TVector3 recoVertPos,SvtxTrack *track);
    static float vtxTrackRPhi(TVector3 recoVertPos,SvtxTrack *track);
    void PHG4VtxPointToSvtxVertex();
    void PHG4VtxPointToSvtxVertex(SvtxVertex* seedVtx);

};
#endif //CONVERSION_H__