PFCluster.h

Go to the documentation of this file.

#ifndef DataFormats_ParticleFlowReco_PFCluster_h
#define DataFormats_ParticleFlowReco_PFCluster_h

#include <iostream>
#include <vector>
#include <algorithm>

#include <Rtypes.h>

#include "DataFormats/CaloRecHit/interface/CaloCluster.h"
#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFraction.h"
#include "Math/GenVector/PositionVector3D.h"

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) {}

    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);

    PFCluster& operator=(const PFCluster&);


    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_;
    float timeError_{0};
    double depth_{0};

    PFLayer::Layer layer_;

    static const constexpr double depthCorA_ = 0.89;
    static const constexpr double depthCorB_ = 7.3;
    static const constexpr double depthCorAp_ = 0.89;
    static const constexpr double depthCorBp_ = 4.0;

    static const math::XYZPoint dummyVtx_;
  };

  std::ostream& operator<<(std::ostream& out, const PFCluster& cluster);

}  // namespace reco

#endif  // DataFormats_ParticleFlowReco_PFCluster_h