TopProjector.h

Go to the documentation of this file.

#ifndef PhysicsTools_PFCandProducer_TopProjector_
#define PhysicsTools_PFCandProducer_TopProjector_
 
// system include files
#include <iostream>
#include <memory>
#include <string>
 
// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
 
#include "DataFormats/Provenance/interface/ProductID.h"
 
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/TauReco/interface/PFTau.h"
#include "DataFormats/JetReco/interface/PFJet.h"
 
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Candidate/interface/OverlapChecker.h"
 
#include "DataFormats/Math/interface/deltaR.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include <iostream>
 
template <class Top, class Bottom>
class TopProjectorFwdPtrOverlap {
public:
  typedef edm::FwdPtr<Top> TopFwdPtr;
  typedef edm::FwdPtr<Bottom> BottomFwdPtr;
 
  explicit TopProjectorFwdPtrOverlap() { bottom_ = 0; }
 
  explicit TopProjectorFwdPtrOverlap(edm::ParameterSet const& iConfig) { bottom_ = nullptr; }
 
  inline void setBottom(BottomFwdPtr const& bottom) { bottom_ = &bottom; }
 
  bool operator()(TopFwdPtr const& top) const {
    bool topFwdGood = top.ptr().isNonnull() && top.ptr().isAvailable();
    bool topBckGood = top.backPtr().isNonnull() && top.backPtr().isAvailable();
    bool bottomFwdGood = bottom_->ptr().isNonnull() && bottom_->ptr().isAvailable();
    bool bottomBckGood = bottom_->backPtr().isNonnull() && bottom_->backPtr().isAvailable();
 
    bool matched = (topFwdGood && bottomFwdGood && top.ptr().refCore() == bottom_->ptr().refCore() &&
                    top.ptr().key() == bottom_->ptr().key()) ||
                   (topFwdGood && bottomBckGood && top.ptr().refCore() == bottom_->backPtr().refCore() &&
                    top.ptr().key() == bottom_->backPtr().key()) ||
                   (topBckGood && bottomFwdGood && top.backPtr().refCore() == bottom_->ptr().refCore() &&
                    top.backPtr().key() == bottom_->ptr().key()) ||
                   (topBckGood && bottomBckGood && top.backPtr().refCore() == bottom_->backPtr().refCore() &&
                    top.backPtr().key() == bottom_->backPtr().key());
    if (!matched) {
      for (unsigned isource = 0; isource < top->numberOfSourceCandidatePtrs(); ++isource) {
        reco::CandidatePtr const& topSrcPtr = top->sourceCandidatePtr(isource);
        bool topSrcGood = topSrcPtr.isNonnull() && topSrcPtr.isAvailable();
        if ((topSrcGood && bottomFwdGood && topSrcPtr.refCore() == bottom_->ptr().refCore() &&
             topSrcPtr.key() == bottom_->ptr().key()) ||
            (topSrcGood && bottomBckGood && topSrcPtr.refCore() == bottom_->backPtr().refCore() &&
             topSrcPtr.key() == bottom_->backPtr().key())) {
          matched = true;
          break;
        }
      }
    }
    if (!matched) {
      for (unsigned isource = 0; isource < (*bottom_)->numberOfSourceCandidatePtrs(); ++isource) {
        reco::CandidatePtr const& bottomSrcPtr = (*bottom_)->sourceCandidatePtr(isource);
        bool bottomSrcGood = bottomSrcPtr.isNonnull() && bottomSrcPtr.isAvailable();
        if ((topFwdGood && bottomSrcGood && bottomSrcPtr.refCore() == top.ptr().refCore() &&
             bottomSrcPtr.key() == top.ptr().key()) ||
            (topBckGood && bottomSrcGood && bottomSrcPtr.refCore() == top.backPtr().refCore() &&
             bottomSrcPtr.key() == top.backPtr().key())) {
          matched = true;
          break;
        }
      }
    }
 
    return matched;
  }
 
protected:
  BottomFwdPtr const* bottom_;
};
 
template <class Top, class Bottom>
class TopProjectorDeltaROverlap {
public:
  typedef edm::FwdPtr<Top> TopFwdPtr;
  typedef edm::FwdPtr<Bottom> BottomFwdPtr;
 
  explicit TopProjectorDeltaROverlap() { bottom_ = 0; }
  explicit TopProjectorDeltaROverlap(edm::ParameterSet const& config)
      : deltaR2_(config.getParameter<double>("deltaR")),
        bottom_(nullptr),
        bottomCPtr_(nullptr),
        botEta_(-999.f),
        botPhi_(0.f) {
    deltaR2_ *= deltaR2_;
  }
 
  inline void setBottom(BottomFwdPtr const& bottom) {
    bottom_ = &bottom;
    bottomCPtr_ = &**bottom_;
    botEta_ = bottomCPtr_->eta();
    botPhi_ = bottomCPtr_->phi();
  }
 
  bool operator()(TopFwdPtr const& top) const {
    const Top& oTop = *top;
    float topEta = oTop.eta();
    float topPhi = oTop.phi();
    bool matched = reco::deltaR2(topEta, topPhi, botEta_, botPhi_) < deltaR2_;
    return matched;
  }
 
protected:
  double deltaR2_;
  BottomFwdPtr const* bottom_;
  const Bottom* bottomCPtr_;
  float botEta_, botPhi_;
};
 
template <class Top, class Bottom, class Matcher = TopProjectorFwdPtrOverlap<Top, Bottom> >
class TopProjector : public edm::stream::EDProducer<> {
public:
  typedef std::vector<Top> TopCollection;
  typedef edm::Handle<std::vector<Top> > TopHandle;
  typedef edm::FwdPtr<Top> TopFwdPtr;
  typedef std::vector<TopFwdPtr> TopFwdPtrCollection;
  typedef edm::Handle<TopFwdPtrCollection> TopFwdPtrHandle;
 
  typedef std::vector<Bottom> BottomCollection;
  typedef edm::Handle<std::vector<Bottom> > BottomHandle;
  typedef edm::Ptr<Bottom> BottomPtr;
  typedef edm::Ref<BottomCollection> BottomRef;
  typedef edm::FwdPtr<Bottom> BottomFwdPtr;
  typedef std::vector<BottomFwdPtr> BottomFwdPtrCollection;
  typedef edm::Handle<BottomFwdPtrCollection> BottomFwdPtrHandle;
 
  TopProjector(const edm::ParameterSet&);
 
  ~TopProjector() override{};
 
  void produce(edm::Event&, const edm::EventSetup&) override;
 
private:
  Matcher match_;
 
  bool enable_;
 
  std::string name_;
 
  edm::InputTag inputTagTop_;
  edm::EDGetTokenT<TopFwdPtrCollection> tokenTop_;
 
  edm::InputTag inputTagBottom_;
  edm::EDGetTokenT<BottomFwdPtrCollection> tokenBottom_;
};
 
template <class Top, class Bottom, class Matcher>
TopProjector<Top, Bottom, Matcher>::TopProjector(const edm::ParameterSet& iConfig)
    : match_(iConfig), enable_(iConfig.getParameter<bool>("enable")) {
  name_ = iConfig.getUntrackedParameter<std::string>("name", "No Name");
  inputTagTop_ = iConfig.getParameter<edm::InputTag>("topCollection");
  tokenTop_ = consumes<TopFwdPtrCollection>(inputTagTop_);
  inputTagBottom_ = iConfig.getParameter<edm::InputTag>("bottomCollection");
  tokenBottom_ = consumes<BottomFwdPtrCollection>(inputTagBottom_);
 
  // will produce a collection of the unmasked candidates in the
  // bottom collection
  produces<BottomFwdPtrCollection>();
}
 
template <class Top, class Bottom, class Matcher>
void TopProjector<Top, Bottom, Matcher>::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  // get the various collections
 
  // Access the masking collection
  TopFwdPtrHandle tops;
  iEvent.getByToken(tokenTop_, tops);
  std::list<TopFwdPtr> topsList;
 
  for (typename TopFwdPtrCollection::const_iterator ibegin = tops->begin(), iend = tops->end(), i = ibegin; i != iend;
       ++i) {
    topsList.push_back(*i);
  }
 
  /*   if( !tops.isValid() ) { */
  /*     std::ostringstream  err; */
  /*     err<<"The top collection must be supplied."<<std::endl */
  /*        <<"It is now set to : "<<inputTagTop_<<std::endl; */
  /*     edm::LogError("PFPAT")<<err.str(); */
  /*     throw cms::Exception( "MissingProduct", err.str()); */
  /*   } */
 
  // Access the collection to
  // be masked by the other ones
  BottomFwdPtrHandle bottoms;
  iEvent.getByToken(tokenBottom_, bottoms);
 
  /*   if( !bottoms.isValid() ) { */
  /*     std::ostringstream  err; */
  /*     err<<"The bottom collection must be supplied."<<std::endl */
  /*        <<"It is now set to : "<<inputTagBottom_<<std::endl; */
  /*     edm::LogError("PFPAT")<<err.str(); */
  /*     throw cms::Exception( "MissingProduct", err.str()); */
  /*   } */
 
  /* if(verbose_) { */
  /*   const edm::Provenance& topProv = iEvent.getProvenance(tops.id()); */
  /*   const edm::Provenance& bottomProv = iEvent.getProvenance(bottoms.id()); */
 
  /*   edm::LogDebug("TopProjection")<<"Top projector: event "<<iEvent.id().event()<<std::endl; */
  /*   edm::LogDebug("TopProjection")<<"Inputs --------------------"<<std::endl; */
  /*   edm::LogDebug("TopProjection")<<"Top      :  " */
  /*         <<tops.id()<<"\t"<<tops->size()<<std::endl */
  /*         <<topProv.branchDescription()<<std::endl; */
 
  /*   for(unsigned i=0; i<tops->size(); i++) { */
  /*     TopFwdPtr top = (*tops)[i]; */
  /*     edm::LogDebug("TopProjection") << "< " << i << " " << top.key() << " : " << *top << std::endl; */
  /*   } */
 
  /*   edm::LogDebug("TopProjection")<<"Bottom   :  " */
  /*         <<bottoms.id()<<"\t"<<bottoms->size()<<std::endl */
  /*         <<bottomProv.branchDescription()<<std::endl; */
 
  /*   for(unsigned i=0; i<bottoms->size(); i++) { */
  /*     BottomFwdPtr bottom = (*bottoms)[i]; */
  /*     edm::LogDebug("TopProjection") << "> " << i << " " << bottom.key() << " : " << *bottom << std::endl; */
  /*   } */
 
  /* } */
 
  // output collection of FwdPtrs to objects,
  // selected from the Bottom collection
  std::unique_ptr<BottomFwdPtrCollection> pBottomFwdPtrOutput(new BottomFwdPtrCollection);
 
  LogDebug("TopProjection") << " Remaining candidates in the bottom collection ------ ";
 
  for (typename BottomFwdPtrCollection::const_iterator i = bottoms->begin(), iend = bottoms->end(), ibegin = i;
       i != iend;
       ++i) {
    BottomFwdPtr const& bottom = *i;
    match_.setBottom(bottom);
    typename std::list<TopFwdPtr>::iterator found = topsList.end();
    if (enable_) {
      found = std::find_if(topsList.begin(), topsList.end(), match_);
    }
 
    // If this is masked in the top projection, we remove it.
    if (found != topsList.end()) {
      LogDebug("TopProjection") << "X " << i - ibegin << **i;
      topsList.erase(found);
      continue;
    }
    // otherwise, we keep it.
    else {
      LogDebug("TopProjection") << "O " << i - ibegin << **i;
      pBottomFwdPtrOutput->push_back(bottom);
    }
  }
 
  iEvent.put(std::move(pBottomFwdPtrOutput));
}
 
#endif