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


}

#endif