PFCluster.h

Go to the documentation of this file.

#ifndef DataFormats_ParticleFlowReco_PFCluster_h
#define DataFormats_ParticleFlowReco_PFCluster_h
 
#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
#include "DataFormats/CaloRecHit/interface/CaloCluster.h"
 
#include "Math/GenVector/PositionVector3D.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "Rtypes.h"
 
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFraction.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
 
#include <iostream>
#include <vector>
#include <algorithm>
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
#include <atomic>
#endif
 
class PFClusterAlgo;
 
namespace reco {
 
  class PFCluster : public CaloCluster {
  public:
    typedef std::vector<std::pair<CaloClusterPtr::key_type, edm::Ptr<PFCluster> > > EEtoPSAssociation;
    // Next typedef uses double in ROOT 6 rather than Double32_t due to a bug in ROOT 5,
    // which otherwise would make ROOT5 files unreadable in ROOT6.  This does not increase
    // the size on disk, because due to the bug, double was actually stored on disk in ROOT 5.
    typedef ROOT::Math::PositionVector3D<ROOT::Math::CylindricalEta3D<double> > REPPoint;
 
    PFCluster() : CaloCluster(CaloCluster::particleFlow), time_(-99.0), layer_(PFLayer::NONE), color_(1) {}
 
    PFCluster(PFLayer::Layer layer, double energy, double x, double y, double z);
 
    void reset();
 
    void resetHitsAndFractions();
 
    void addRecHitFraction(const reco::PFRecHitFraction& frac);
 
    const std::vector<reco::PFRecHitFraction>& recHitFractions() const { return rechits_; }
 
    void setLayer(PFLayer::Layer layer);
 
    PFLayer::Layer layer() const;
 
    double energy() const { return energy_; }
 
    float time() const { return time_; }
    float timeError() const { return timeError_; }
 
    double depth() const { return depth_; }
 
    void setTime(float time, float timeError = 0) {
      time_ = time;
      timeError_ = timeError;
    }
    void setTimeError(float timeError) { timeError_ = timeError; }
    void setDepth(double depth) { depth_ = depth; }
 
    const REPPoint& positionREP() const { return posrep_; }
 
    void calculatePositionREP() { posrep_.SetCoordinates(position_.Rho(), position_.Eta(), position_.Phi()); }
 
    static double getDepthCorrection(double energy, bool isBelowPS = false, bool isHadron = false);
 
    void setColor(int color) { color_ = color; }
 
    int color() const { return color_; }
 
    PFCluster& operator=(const PFCluster&);
 
    static void setDepthCorParameters(int mode, double a, double b, double ap, double bp) {
      depthCorMode_ = mode;
      depthCorA_ = a;
      depthCorB_ = b;
      depthCorAp_ = ap;
      depthCorBp_ = bp;
    }
 
 
    double charge() const { return 0; }
 
    double pt() const { return (energy() * sin(position_.theta())); }
 
    double theta() const { return position_.theta(); }
 
    math::XYZPoint const& vertex() const { return dummyVtx_; }
    double vx() const { return vertex().x(); }
    double vy() const { return vertex().y(); }
    double vz() const { return vertex().z(); }
 
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    template <typename pruner>
    void pruneUsing(pruner prune) {
      // remove_if+erase algo applied to both vectors...
      auto iter = std::find_if_not(rechits_.begin(), rechits_.end(), prune);
      if (iter == rechits_.end())
        return;
      auto first = iter - rechits_.begin();
      for (auto i = first; ++i < int(rechits_.size());) {
        if (prune(rechits_[i])) {
          rechits_[first] = std::move(rechits_[i]);
          hitsAndFractions_[first] = std::move(hitsAndFractions_[i]);
          ++first;
        }
      }
      rechits_.erase(rechits_.begin() + first, rechits_.end());
      hitsAndFractions_.erase(hitsAndFractions_.begin() + first, hitsAndFractions_.end());
    }
#endif
 
  private:
    std::vector<reco::PFRecHitFraction> rechits_;
 
    REPPoint posrep_;
 
    float time_, timeError_;
    double depth_;
 
    PFLayer::Layer layer_;
 
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    static std::atomic<int> depthCorMode_;
 
    static std::atomic<double> depthCorA_;
 
    static std::atomic<double> depthCorB_;
 
    static std::atomic<double> depthCorAp_;
 
    static std::atomic<double> depthCorBp_;
#else
    static int depthCorMode_;
 
    static double depthCorA_;
 
    static double depthCorB_;
 
    static double depthCorAp_;
 
    static double depthCorBp_;
#endif
 
    static const math::XYZPoint dummyVtx_;
 
    int color_;
  };
 
  std::ostream& operator<<(std::ostream& out, const PFCluster& cluster);
 
}  // namespace reco
 
#endif