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));
  }
 
}  // namespace reco
 
#endif