SpecialClusterImporter.cc

Go to the documentation of this file.

#include "RecoParticleFlow/PFProducer/interface/BlockElementImporterBase.h"
#include "RecoParticleFlow/PFClusterTools/interface/ClusterClusterMapping.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/Common/interface/ValueMap.h"

// NOTE! This should come *after* and importers that bring in super clusters
// of their own (like electron seeds or photons)
// otherwise ECAL <-> ECAL linking will not work correctly
template<reco::PFBlockElement::Type T> 
class SpecialClusterImporter : public BlockElementImporterBase {
public:
  SpecialClusterImporter(const edm::ParameterSet& conf,
             edm::ConsumesCollector& sumes) :
    BlockElementImporterBase(conf,sumes),
    _src(sumes.consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("source"))),
    _assoc(sumes.consumes<edm::ValueMap<reco::CaloClusterPtr> >(conf.getParameter<edm::InputTag>("BCtoPFCMap"))) {}
  
  void importToBlock( const edm::Event& ,
              ElementList& ) const override;

private:
  edm::EDGetTokenT<reco::PFClusterCollection> _src;
  edm::EDGetTokenT<edm::ValueMap<reco::CaloClusterPtr> > _assoc;
};


template<reco::PFBlockElement::Type T> 
void SpecialClusterImporter<T>::
importToBlock( const edm::Event& e, 
           BlockElementImporterBase::ElementList& elems ) const {
  BlockElementImporterBase::ElementList ecals;
  auto clusters = e.getHandle(_src);
  auto assoc = e.getHandle(_assoc);
  auto bclus = clusters->cbegin();
  auto eclus = clusters->cend();
  // get all the SCs in the element list
  auto sc_end = std::partition(elems.begin(),elems.end(),
                   [](const ElementList::value_type& o){
                 return o->type() == reco::PFBlockElement::SC;
                   });   
  ecals.reserve(clusters->size());
  for( auto clus = bclus; clus != eclus; ++clus  ) {    
    reco::PFClusterRef tempref(clusters, std::distance(bclus,clus));
    reco::PFBlockElementCluster* newelem = 
      new reco::PFBlockElementCluster(tempref,T);
    for( auto scelem = elems.begin(); scelem != sc_end; ++scelem ) {
      const reco::PFBlockElementSuperCluster* elem_as_sc =
    static_cast<const reco::PFBlockElementSuperCluster*>(scelem->get());
      const reco::SuperClusterRef& this_sc = elem_as_sc->superClusterRef();

      const bool in_sc = ( elem_as_sc->fromPFSuperCluster() ?
               // use association map if from PFSC
               ClusterClusterMapping::overlap(tempref,
                              *this_sc,
                              *assoc) :
               // match by overlapping rechit otherwise
               ClusterClusterMapping::overlap(*tempref,
                              *this_sc) );
      if( in_sc ) { 
    newelem->setSuperClusterRef(this_sc);
    break;
      }
    }
    ecals.emplace_back(newelem);
  }
  elems.reserve(elems.size()+ecals.size());
  for( auto& ecal : ecals ) {
    elems.emplace_back(ecal.release());
  }
}


typedef SpecialClusterImporter<reco::PFBlockElement::ECAL> ECALClusterImporter;
DEFINE_EDM_PLUGIN(BlockElementImporterFactory, 
          ECALClusterImporter, 
          "ECALClusterImporter");

typedef SpecialClusterImporter<reco::PFBlockElement::HGCAL> HGCalClusterImporter;
DEFINE_EDM_PLUGIN(BlockElementImporterFactory, 
          HGCalClusterImporter, 
          "HGCalClusterImporter");