Conversion.h

Go to the documentation of this file.

#ifndef EgammaCandidates_Conversion_h
#define EgammaCandidates_Conversion_h

#include <bitset>
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h" 
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1DFloat.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/CaloRecHit/interface/CaloCluster.h"
#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"


namespace reco {
    class Conversion  {
  public:

      enum ConversionAlgorithm {undefined=0, 
                ecalSeeded=1, 
                trackerOnly=2, 
                mixed=3, 
                                pflow=4,
                algoSize=5}; 

      enum ConversionQuality {generalTracksOnly=0, 
                  arbitratedEcalSeeded=1, 
                  arbitratedMerged=2,
                  arbitratedMergedEcalGeneral=3,
                              gsfTracksOpenOnly=4,
                  highPurity=8, 
                  highEfficiency=9,
                  ecalMatched1Track=10,
                  ecalMatched2Track=11};

      static const std::string algoNames[];      

      // Default constructor
      Conversion();
      
      Conversion( const reco::CaloClusterPtrVector& clu, 
          const std::vector<edm::RefToBase<reco::Track> >& tr,
          const std::vector<math::XYZPointF>& trackPositionAtEcal , 
          const reco::Vertex  &  convVtx,
          const std::vector<reco::CaloClusterPtr> & matchingBC,
          const float DCA,        
          const std::vector<math::XYZPointF> & innPoint,
          const std::vector<math::XYZVectorF> & trackPin ,
          const std::vector<math::XYZVectorF> & trackPout,
                  const std::vector<uint8_t>& nHitsBeforeVtx,
                  const std::vector<Measurement1DFloat> & dlClosestHitToVtx,
                  uint8_t nSharedHits,
                  const float mva,
          ConversionAlgorithm=undefined);


      Conversion( const reco::CaloClusterPtrVector& clu, 
          const std::vector<reco::TrackRef>& tr,
          const std::vector<math::XYZPointF>& trackPositionAtEcal , 
          const reco::Vertex  &  convVtx,
          const std::vector<reco::CaloClusterPtr> & matchingBC,
          const float DCA,        
          const std::vector<math::XYZPointF> & innPoint,
          const std::vector<math::XYZVectorF> & trackPin ,
          const std::vector<math::XYZVectorF> & trackPout,
                  const float mva,
          ConversionAlgorithm=undefined);
      


      
      Conversion( const reco::CaloClusterPtrVector& clu, 
          const std::vector<reco::TrackRef>& tr,
          const reco::Vertex  &  convVtx,
          ConversionAlgorithm=undefined);
      
      Conversion( const reco::CaloClusterPtrVector& clu, 
          const std::vector<edm::RefToBase<reco::Track> >& tr,
          const reco::Vertex  &  convVtx,
          ConversionAlgorithm=undefined);
      
      
      Conversion * clone() const;
      reco::CaloClusterPtrVector caloCluster() const {return caloCluster_ ;}
      std::vector<edm::RefToBase<reco::Track> > const& tracks() const ; 
      const reco::Vertex & conversionVertex() const  { return theConversionVertex_ ; }
      bool isConverted() const;
      unsigned int nTracks() const {return  tracks().size(); }
      double MVAout() const { return theMVAout_;}
      std::vector<float> const oneLegMVA() {return theOneLegMVA_;}
      double pairInvariantMass() const;
      double pairCotThetaSeparation() const;
      math::XYZVectorF  pairMomentum() const;
      math::XYZTLorentzVectorF   refittedPair4Momentum() const;
      math::XYZVectorF  refittedPairMomentum() const;
      double EoverP() const;
      double EoverPrefittedTracks() const;
      // Dist of minimum approach between tracks
      double distOfMinimumApproach() const {return  theMinDistOfApproach_;}
      // deltaPhi tracks at innermost point
      double dPhiTracksAtVtx() const;
      // deltaPhi tracks at ECAl
      double dPhiTracksAtEcal() const;
      // deltaEta tracks at ECAl
      double dEtaTracksAtEcal() const;

      //impact parameter and decay length computed with respect to given beamspot or vertex
      //computed from refittedPairMomentum

      //transverse impact parameter
      double dxy(const math::XYZPoint& myBeamSpot = math::XYZPoint()) const;
      //longitudinal impact parameter
      double dz(const math::XYZPoint& myBeamSpot = math::XYZPoint()) const;
      //transverse decay length
      double lxy(const math::XYZPoint& myBeamSpot = math::XYZPoint()) const;
      //longitudinal decay length
      double lz(const math::XYZPoint& myBeamSpot = math::XYZPoint()) const;
      //z position of intersection with beamspot in rz plane (possible tilt of beamspot is neglected)
      double zOfPrimaryVertexFromTracks(const math::XYZPoint& myBeamSpot = math::XYZPoint()) const { return dz(myBeamSpot) + myBeamSpot.z(); }

      const std::vector<math::XYZPointF> & ecalImpactPosition() const  {return thePositionAtEcal_;}
      //  pair of BC matching a posteriori the tracks
      const std::vector<reco::CaloClusterPtr>&  bcMatchingWithTracks() const { return theMatchingBCs_;}
      std::vector<double> tracksSigned_d0() const ;
      const std::vector<math::XYZPointF>& tracksInnerPosition() const {return theTrackInnerPosition_;}
      const std::vector<math::XYZVectorF>& tracksPout() const {return theTrackPout_;}
      const std::vector<math::XYZVectorF>& tracksPin() const  {return theTrackPin_;}
      const std::vector<uint8_t> &nHitsBeforeVtx() const { return nHitsBeforeVtx_; }
      const std::vector<Measurement1DFloat> &dlClosestHitToVtx() const { return dlClosestHitToVtx_; }
      uint8_t nSharedHits() const { return nSharedHits_; }


      void setMVAout(const float& mva) { theMVAout_=mva;}
      void setOneLegMVA(const std::vector<float>& mva) { theOneLegMVA_=mva;}
      // Set the ptr to the Super cluster if not set in the constructor 
      void setMatchingSuperCluster ( const  reco::CaloClusterPtrVector& sc) { caloCluster_= sc;}
      void setConversionAlgorithm(const ConversionAlgorithm a, bool set=true) { if (set) algorithm_=a; else algorithm_=undefined;}
      ConversionAlgorithm algo() const ;
      std::string algoName() const;
      static std::string algoName(ConversionAlgorithm );
      static ConversionAlgorithm  algoByName(const std::string &name);      

      bool quality(ConversionQuality q) const { return  (qualityMask_ & (1<<q))>>q; }
      void setQuality(ConversionQuality q, bool b);


      
    private:
      
      reco::CaloClusterPtrVector caloCluster_;
      std::vector<edm::RefToBase<reco::Track> >  trackToBaseRefs_;
      std::vector<math::XYZPointF>  thePositionAtEcal_;
      reco::Vertex theConversionVertex_;
      std::vector<reco::CaloClusterPtr> theMatchingBCs_;
      std::vector<math::XYZPointF> theTrackInnerPosition_;    
      std::vector<math::XYZVectorF> theTrackPin_;    
      std::vector<math::XYZVectorF> theTrackPout_;    
      std::vector<uint8_t> nHitsBeforeVtx_;
      std::vector<Measurement1DFloat> dlClosestHitToVtx_;
      std::vector<float>  theOneLegMVA_;
      float theMinDistOfApproach_;
      float theMVAout_;
      uint16_t qualityMask_;
      uint8_t nSharedHits_;
      uint8_t algorithm_;


  };

    inline Conversion::ConversionAlgorithm Conversion::algo() const {
      return (ConversionAlgorithm) algorithm_;
    }
    
    
    inline std::string Conversion::algoName() const{
            
      switch(algorithm_)
    {
    case undefined: return "undefined";
    case ecalSeeded: return "ecalSeeded";
    case trackerOnly: return "trackerOnly";
    case mixed: return "mixed";
    case pflow: return "pflow";

    }
      return "undefined";
    }

    inline std::string Conversion::algoName(ConversionAlgorithm a){
      if(int(a) < int(algoSize) && int(a)>0) return algoNames[int(a)];
      return "undefined";
    }

    inline void Conversion::setQuality(ConversionQuality q, bool b){
      if (b)//regular OR if setting value to true
        qualityMask_ |= (1<<q) ;
      else // doing "half-XOR" if unsetting value
        qualityMask_ &= (~(1<<q));

    }
  
}

#endif