EgammaHLTTrackIsolation.h

Go to the documentation of this file.

#ifndef EgammaHLTAlgos_EgammaHLTTrackIsolation_h
#define EgammaHLTAlgos_EgammaHLTTrackIsolation_h
// -*- C++ -*-
//
// Package:     EgammaHLTAlgos
// Class  :     EgammaHLTTrackIsolation
//
//
// Original Author:  Monica Vazquez Acosta - CERN
//         Created:  Tue Jun 13 12:19:32 CEST 2006
//

#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"

#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"

#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"

#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/Vector.h"
#include "DataFormats/Math/interface/Point3D.h"

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

class EgammaHLTTrackIsolation {
public:
  EgammaHLTTrackIsolation(double egTrkIso_PtMin,
                          double egTrkIso_ConeSize,
                          double egTrkIso_ZSpan,
                          double egTrkIso_RSpan,
                          double egTrkIso_VetoConeSize,
                          double egTrkIso_stripBarrel = 0,
                          double egTrkIso_stripEndcap = 0)
      : ptMin(egTrkIso_PtMin),
        conesize(egTrkIso_ConeSize),
        zspan(egTrkIso_ZSpan),
        rspan(egTrkIso_RSpan),
        vetoConesize(egTrkIso_VetoConeSize),
        stripBarrel(egTrkIso_stripBarrel),
        stripEndcap(egTrkIso_stripEndcap) {
    /*
    std::cout << "EgammaHLTTrackIsolation instance:"
    << " ptMin=" << ptMin << " "
    << " conesize="<< conesize << " "
    << " zspan=" << zspan << " "
    << " rspan=" << rspan << " "
    << " vetoConesize="<< vetoConesize
    << std::endl;    
      */
  }

  std::pair<int, float> electronIsolation(const reco::Track* const tr, const reco::TrackCollection* isoTracks);
  std::pair<int, float> electronIsolation(const reco::Track* const tr,
                                          const reco::ElectronCollection* allEle,
                                          const reco::TrackCollection* isoTracks);
  std::pair<int, float> electronIsolation(const reco::Track* const tr,
                                          const reco::TrackCollection* isoTracks,
                                          GlobalPoint vertex);

  std::pair<int, float> photonIsolation(const reco::RecoCandidate* const recocand,
                                        const reco::TrackCollection* isoTracks,
                                        bool useVertex);
  std::pair<int, float> photonIsolation(const reco::RecoCandidate* const recocand,
                                        const reco::TrackCollection* isoTracks,
                                        GlobalPoint vertex);
  std::pair<int, float> photonIsolation(const reco::RecoCandidate* const recocand,
                                        const reco::ElectronCollection* allEle,
                                        const reco::TrackCollection* isoTracks);

  int electronTrackCount(const reco::Track* const tr, const reco::TrackCollection* isoTracks) {
    return electronIsolation(tr, isoTracks).first;
  }
  int electronTrackCount(const reco::Track* const tr, const reco::TrackCollection* isoTracks, GlobalPoint vertex) {
    return electronIsolation(tr, isoTracks, vertex).first;
  }

  int photonTrackCount(const reco::RecoCandidate* const recocand,
                       const reco::TrackCollection* isoTracks,
                       bool useVertex) {
    return photonIsolation(recocand, isoTracks, useVertex).first;
  }
  int photonTrackCount(const reco::RecoCandidate* const recocand,
                       const reco::TrackCollection* isoTracks,
                       GlobalPoint vertex) {
    return photonIsolation(recocand, isoTracks, vertex).first;
  }
  int photonTrackCount(const reco::RecoCandidate* const recocand,
                       const reco::ElectronCollection* allEle,
                       const reco::TrackCollection* isoTracks) {
    return photonIsolation(recocand, allEle, isoTracks).first;
  }

  float electronPtSum(const reco::Track* const tr, const reco::TrackCollection* isoTracks) {
    return electronIsolation(tr, isoTracks).second;
  }
  float electronPtSum(const reco::Track* const tr, const reco::TrackCollection* isoTracks, GlobalPoint vertex) {
    return electronIsolation(tr, isoTracks, vertex).second;
  }
  float electronPtSum(const reco::Track* const tr,
                      const reco::ElectronCollection* allEle,
                      const reco::TrackCollection* isoTracks) {
    return electronIsolation(tr, allEle, isoTracks).second;
  }

  float photonPtSum(const reco::RecoCandidate* const recocand, const reco::TrackCollection* isoTracks, bool useVertex) {
    return photonIsolation(recocand, isoTracks, useVertex).second;
  }
  float photonPtSum(const reco::RecoCandidate* const recocand,
                    const reco::TrackCollection* isoTracks,
                    GlobalPoint vertex) {
    return photonIsolation(recocand, isoTracks, vertex).second;
  }
  float photonPtSum(const reco::RecoCandidate* const recocand,
                    const reco::ElectronCollection* allEle,
                    const reco::TrackCollection* isoTracks) {
    return photonIsolation(recocand, allEle, isoTracks).second;
  }

  double getPtMin() { return ptMin; }
  double getConeSize() { return conesize; }
  double getZspan() { return zspan; }
  double getRspan() { return rspan; }
  double getvetoConesize() { return vetoConesize; }

private:
  // Call track reconstruction
  std::pair<int, float> findIsoTracks(GlobalVector mom,
                                      GlobalPoint vtx,
                                      const reco::TrackCollection* isoTracks,
                                      bool isElectron,
                                      bool useVertex = true);
  std::pair<int, float> findIsoTracksWithoutEle(GlobalVector mom,
                                                GlobalPoint vtx,
                                                const reco::ElectronCollection* allEle,
                                                const reco::TrackCollection* isoTracks);

  // Parameters of isolation cone geometry.
  double ptMin;
  double conesize;
  double zspan;
  double rspan;
  double vetoConesize;

  //added for inner eta strip veto (I'll keep the violation of CMS naming conventions to be consistant)
  double stripBarrel;
  double stripEndcap;
};

#endif