HybridClusterAlgo.h

Go to the documentation of this file.

#ifndef RecoEcal_EgammaClusterAlgos_HybridClusterAlgo_h
#define RecoEcal_EgammaClusterAlgos_HybridClusterAlgo_h

#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EgammaReco/interface/BasicClusterFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "RecoCaloTools/Navigation/interface/EcalBarrelNavigator.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/CaloTopology/interface/EcalBarrelHardcodedTopology.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "DataFormats/Math/interface/RectangularEtaPhiRegion.h"
#include "RecoEcal/EgammaCoreTools/interface/BremRecoveryPhiRoadAlgo.h"
#include "RecoEcal/EgammaCoreTools/interface/SuperClusterShapeAlgo.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include <vector>
#include <set>

class EcalSeverityLevelAlgo;

class HybridClusterAlgo {
private:
  //Quick typedef for position calculation.
  typedef math::XYZPoint Point;

  //Thresholds for seeds.
  double eb_st;

  //Number of steps in phi that the Hybrid algorithm will take
  //when clustering.  Remember, uses phiSteps_ in positive direction
  //and then phiSteps_ in negative direction.
  int phiSteps_;

  // et in 25
  double et25(EcalBarrelNavigatorHT &navigator,
              const EcalRecHitCollection *hits,
              const CaloSubdetectorGeometry *geometry);
  // ratio Et/e
  double e2Et(EcalBarrelNavigatorHT &navigator,
              const EcalRecHitCollection *hits,
              const CaloSubdetectorGeometry *geometry);

  BremRecoveryPhiRoadAlgo *phiRoadAlgo_;

  //Threshold for basic cluster.
  double eThres_;
  double eThresA_;
  double eThresB_;

  //Threshold for becoming a sub-peak in the supercluster.
  double Eseed;

  //Coefficient to increase Eseed as a function of 5x5
  double Xi;

  //Increase Eseed as a function of et_5x5 (othwewise it's e_5x5)
  bool UseEtForXi;

  //Threshold for adding the additional two 'wing' cells to domino.
  double Ewing;

  // do dynamic phi road
  bool dynamicPhiRoad_;

  // do dynamic ethres
  bool dynamicEThres_;

  //Map of DetId, RecHit relationship.  EcalRecHit knows what DetId it is,
  //but DetId doesn't  know what EcalRecHit it is.
  //  std::map<DetId, EcalRecHit>  rechits_m;

  // colection of all rechits
  const EcalRecHitCollection *recHits_;

  // topology
  EcalBarrelHardcodedTopology *topo_;

  //  SuperClusterShapeAlgo* SCShape_;

  //Set of DetIds that have already been used.
  std::set<DetId> useddetids;

  // The vector of seeds:
  std::vector<EcalRecHit> seeds;

  //The vector of seed clusters:
  std::vector<reco::BasicCluster> seedClus_;

  //Map of basicclusters and what supercluster they will belong to.
  std::map<int, std::vector<reco::BasicCluster> > clustered_;

  //algo to calulate position of clusters
  PositionCalc posCalculator_;

  // channels not to be used for seeding
  std::vector<int> v_chstatus_;

  // severity levels to discriminate against
  std::vector<int> v_severitylevel_;
  float severityRecHitThreshold_;
  float severitySpikeThreshold_;

  bool excludeFromCluster_;
  std::set<DetId> excludedCrys_;

public:
  //The default constructor
  HybridClusterAlgo() {}

  //The real constructor
  HybridClusterAlgo(double eb_str,
                    int step,
                    double ethres,
                    double eseed,
                    double xi,
                    bool useEtForXi,
                    double ewing,
                    const std::vector<int> &v_chstatus,
                    const PositionCalc &posCalculator,
                    bool dynamicEThres = false,
                    double eThresA = 0,
                    double eThresB = 0.1,
                    const std::vector<int> &severityToExclude = std::vector<int>().operator=(std::vector<int>(999)),
                    //double severityRecHitThreshold=0.08,
                    //int severitySpikeId=1,
                    //double severitySpikeThreshold=0,
                    bool excludeFromCluster = false);
  //                    const edm::ParameterSet &bremRecoveryPset,

  // destructor
  ~HybridClusterAlgo() {
    if (dynamicPhiRoad_)
      delete phiRoadAlgo_;
    delete topo_;
    //     delete SCShape_;
  }

  void setDynamicPhiRoad(const edm::ParameterSet &bremRecoveryPset) {
    dynamicPhiRoad_ = true;
    phiRoadAlgo_ = new BremRecoveryPhiRoadAlgo(bremRecoveryPset);
  }

  //Hand over the map, the geometry, and I'll hand you back clusters.
  void makeClusters(const EcalRecHitCollection *,
                    const CaloSubdetectorGeometry *geometry,
                    reco::BasicClusterCollection &basicClusters,
                    const EcalSeverityLevelAlgo *sevLv,
                    bool regional = false,
                    const std::vector<RectangularEtaPhiRegion> &regions = std::vector<RectangularEtaPhiRegion>());

  //Make superclusters from the references to the BasicClusters in the event.
  reco::SuperClusterCollection makeSuperClusters(const reco::CaloClusterPtrVector &);

  //The routine doing the real work.
  void mainSearch(const EcalRecHitCollection *hits, const CaloSubdetectorGeometry *geometry);

  //Make dominos for the hybrid method.
  double makeDomino(EcalBarrelNavigatorHT &navigator, std::vector<EcalRecHit> &cells);
};

#endif