SuperCluster.h

Go to the documentation of this file.

#ifndef EgammaReco_SuperCluster_h
#define EgammaReco_SuperCluster_h

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/CaloRecHit/interface/CaloCluster.h"
#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"
#include "DataFormats/EcalDetId/interface/EBDetId.h"

namespace reco {
  class SuperCluster : public CaloCluster {
  public:
    typedef math::XYZPoint Point;

    SuperCluster()
        : CaloCluster(0., Point(0., 0., 0.)),
          preshowerEnergy_(0),
          rawEnergy_(-1.),
          phiWidth_(0),
          etaWidth_(0),
          preshowerEnergy1_(0),
          preshowerEnergy2_(0) {}

    SuperCluster(double energy, const Point& position);

    SuperCluster(double energy,
                 const Point& position,
                 const CaloClusterPtr& seed,
                 const CaloClusterPtrVector& clusters,
                 double Epreshower = 0.,
                 double phiWidth = 0.,
                 double etaWidth = 0.,
                 double Epreshower1 = 0.,
                 double Epreshower2 = 0.);

    // to be merged in the previous one? -- FIXME
    SuperCluster(double energy,
                 const Point& position,
                 const CaloClusterPtr& seed,
                 const CaloClusterPtrVector& clusters,
                 const CaloClusterPtrVector& preshowerClusters,
                 double Epreshower = 0.,
                 double phiWidth = 0.,
                 double etaWidth = 0.,
                 double Epreshower1 = 0.,
                 double Epreshower2 = 0.);

    double rawEnergy() const { return rawEnergy_; }

    double preshowerEnergy() const { return preshowerEnergy_; }
    double preshowerEnergyPlane1() const { return preshowerEnergy1_; }
    double preshowerEnergyPlane2() const { return preshowerEnergy2_; }

    double phiWidth() const { return phiWidth_; }
    double etaWidth() const { return etaWidth_; }

    //Assign new variables to supercluster
    void setPreshowerEnergy(double preshowerEnergy) { preshowerEnergy_ = preshowerEnergy; };
    void setPreshowerEnergyPlane1(double preshowerEnergy1) { preshowerEnergy1_ = preshowerEnergy1; };
    void setPreshowerEnergyPlane2(double preshowerEnergy2) { preshowerEnergy2_ = preshowerEnergy2; };
    void setPhiWidth(double pw) { phiWidth_ = pw; }
    void setEtaWidth(double ew) { etaWidth_ = ew; }

    const CaloClusterPtr& seed() const { return seed_; }

    const CaloClusterPtrVector& clusters() const { return clusters_; }

    const CaloClusterPtrVector& preshowerClusters() const { return preshowerClusters_; }

    CaloCluster_iterator clustersBegin() const { return clusters_.begin(); }

    CaloCluster_iterator clustersEnd() const { return clusters_.end(); }

    CaloCluster_iterator preshowerClustersBegin() const { return preshowerClusters_.begin(); }

    CaloCluster_iterator preshowerClustersEnd() const { return preshowerClusters_.end(); }

    size_t clustersSize() const { return clusters_.size(); }

    size_t preshowerClustersSize() const { return preshowerClusters_.size(); }

    //std::vector<DetId> getHitsByDetId() const { return usedHits_; }

    void setSeed(const CaloClusterPtr& r) { seed_ = r; }

    //(re)-set clusters
    void setClusters(const CaloClusterPtrVector& clusters) {
      clusters_ = clusters;
      computeRawEnergy();
    }

    //(re)-set preshower clusters
    void setPreshowerClusters(const CaloClusterPtrVector& clusters) { preshowerClusters_ = clusters; }

    //clear hits and fractions vector (for slimming)
    void clearHitsAndFractions() { hitsAndFractions_.clear(); }

    void addCluster(const CaloClusterPtr& r) {
      clusters_.push_back(r);
      computeRawEnergy();
    }

    void addPreshowerCluster(const CaloClusterPtr& r) { preshowerClusters_.push_back(r); }

    void setPreshowerPlanesStatus(const uint32_t& status) {
      uint32_t flags = flags_ & flagsMask_;
      flags_ = flags | (status << flagsOffset_);
    }

    const int getPreshowerPlanesStatus() const { return (flags_ >> flagsOffset_); }

    const int seedCrysIEtaOrIx() const {
      auto detid = seed_->seed();
      int ietaorix = 0;
      if (detid.subdetId() == EcalBarrel) {
        EBDetId ebdetid(detid);
        ietaorix = ebdetid.ieta();
      } else if (detid.subdetId() == EcalEndcap) {
        EEDetId eedetid(detid);
        ietaorix = eedetid.ix();
      }
      return ietaorix;
    }

    const int seedCrysIPhiOrIy() const {
      auto detid = seed_->seed();
      int iphioriy = 0;
      if (detid.subdetId() == EcalBarrel) {
        EBDetId ebdetid(detid);
        iphioriy = ebdetid.iphi();
      } else if (detid.subdetId() == EcalEndcap) {
        EEDetId eedetid(detid);
        iphioriy = eedetid.iy();
      }
      return iphioriy;
    }

  private:
    void computeRawEnergy();

    CaloClusterPtr seed_;

    CaloClusterPtrVector clusters_;

    CaloClusterPtrVector preshowerClusters_;

    //std::vector<DetId> usedHits_;

    double preshowerEnergy_;

    double rawEnergy_;

    double phiWidth_;
    double etaWidth_;

    double preshowerEnergy1_;
    double preshowerEnergy2_;
  };

}  // namespace reco
#endif