/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/RecoTauTag/RecoTau/plugins/RecoTauPhotonFilter.cc

Go to the documentation of this file.

/*
 * ===========================================================================
 *
 *       Filename:  RecoTauPhotonFilter
 *
 *    Description:  Modify taus to recursively filter lowpt photons
 *
 *         Author:  Evan K. Friis (UC Davis)
 *
 * ===========================================================================
 */

#include <boost/foreach.hpp>
#include "RecoTauTag/RecoTau/interface/RecoTauBuilderPlugins.h"
#include "RecoTauTag/RecoTau/interface/RecoTauCommonUtilities.h"

namespace reco { namespace tau {

// Filter photons
class RecoTauPhotonFilter : public RecoTauModifierPlugin {
  public:
    explicit RecoTauPhotonFilter(const edm::ParameterSet& pset);
    virtual ~RecoTauPhotonFilter() {}
    void operator()(PFTau&) const;
  private:
    bool filter(const RecoTauPiZero* piZero,
                const reco::Candidate::LorentzVector& tau) const;
    double minPtFractionSinglePhotons_;
    double minPtFractionPiZeroes_;
};

RecoTauPhotonFilter::RecoTauPhotonFilter(
    const edm::ParameterSet& pset):RecoTauModifierPlugin(pset) {
  minPtFractionSinglePhotons_ =
      pset.getParameter<double>("minPtFractionSinglePhotons");
  minPtFractionPiZeroes_ =
      pset.getParameter<double>("minPtFractionPiZeroes");
}

// Sort container of PiZero pointers by ascending Pt
namespace {
struct PiZeroPtSorter {
  bool operator()(const RecoTauPiZero* A, const RecoTauPiZero* B) {
    return (A->pt() < B->pt());
  }
};
}

// Decide if we should filter a pi zero or not.
bool RecoTauPhotonFilter::filter( const RecoTauPiZero* piZero,
    const reco::Candidate::LorentzVector& total) const {
  if (piZero->numberOfDaughters() > 1)
    return piZero->pt()/total.pt() < minPtFractionPiZeroes_;
  return piZero->pt()/total.pt() < minPtFractionSinglePhotons_;
}

void RecoTauPhotonFilter::operator()(PFTau& tau) const {
  std::vector<const RecoTauPiZero*> signalPiZeros;
  BOOST_FOREACH(const RecoTauPiZero& piZero, tau.signalPiZeroCandidates()) {
    signalPiZeros.push_back(&piZero);
  }
  std::sort(signalPiZeros.begin(), signalPiZeros.end(), PiZeroPtSorter());
  std::vector<const RecoTauPiZero*>::const_iterator wimp =
      signalPiZeros.begin();

  // Loop until we have a sturdy enough pizero
  reco::Candidate::LorentzVector totalP4 = tau.p4();
  while(wimp != signalPiZeros.end() && filter(*wimp, totalP4)) {
    totalP4 -= (*wimp)->p4();
    ++wimp;
  }

  if (wimp != signalPiZeros.begin()) {
    // We filtered stuff, update our tau
    double ptDifference = (totalP4 - tau.p4()).pt();
    tau.setisolationPFGammaCandsEtSum(
        tau.isolationPFGammaCandsEtSum() + ptDifference);

    // Update four vector
    tau.setP4(totalP4);

    std::vector<RecoTauPiZero> toMove;
    std::vector<RecoTauPiZero> newSignal;
    std::vector<RecoTauPiZero> newIsolation;

    // Build our new objects
    for (std::vector<const RecoTauPiZero*>::const_iterator iter =
         signalPiZeros.begin(); iter != wimp; ++iter) {
      toMove.push_back(**iter);
    }
    for (std::vector<const RecoTauPiZero*>::const_iterator iter =
         wimp; iter != signalPiZeros.end(); ++iter) {
      newSignal.push_back(**iter);
    }
    // Build our new isolation collection
    std::copy(toMove.begin(), toMove.end(), std::back_inserter(newIsolation));
    std::copy(tau.isolationPiZeroCandidates().begin(),
              tau.isolationPiZeroCandidates().end(),
              std::back_inserter(newIsolation));

    // Set the collections in the taus.
    tau.setsignalPiZeroCandidates(newSignal);
    tau.setisolationPiZeroCandidates(newIsolation);

    // Now we need to deal with the gamma candidates underlying moved pizeros.
    std::vector<PFCandidatePtr> pfcandsToMove = flattenPiZeros(toMove);

    // Copy the keys to move
    std::set<size_t> keysToMove;
    BOOST_FOREACH(const PFCandidatePtr& ptr, pfcandsToMove) {
      keysToMove.insert(ptr.key());
    }

    PFCandidateRefVector newSignalPFGammas;
    PFCandidateRefVector newSignalPFCands;
    PFCandidateRefVector newIsolationPFGammas = tau.isolationPFGammaCands();
    PFCandidateRefVector newIsolationPFCands = tau.isolationPFCands();

    // Move the necessary signal pizeros - what a mess!
    BOOST_FOREACH(const PFCandidateRef& ref, tau.signalPFCands()) {
      if (keysToMove.count(ref.key()))
        newIsolationPFCands.push_back(ref);
      else
        newSignalPFCands.push_back(ref);
    }

    BOOST_FOREACH(const PFCandidateRef& ref, tau.signalPFGammaCands()) {
      if (keysToMove.count(ref.key()))
        newIsolationPFGammas.push_back(ref);
      else
        newSignalPFGammas.push_back(ref);
    }

    tau.setsignalPFCands(newSignalPFCands);
    tau.setsignalPFCands(newSignalPFGammas);
    tau.setisolationPFGammaCands(newIsolationPFGammas);
    tau.setisolationPFCands(newIsolationPFCands);
  }
}
}}  // end namespace reco::tau
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_EDM_PLUGIN(RecoTauModifierPluginFactory,
    reco::tau::RecoTauPhotonFilter,
    "RecoTauPhotonFilter");