AlCaECALRecHitReducer.cc

Go to the documentation of this file.

#include "Calibration/EcalAlCaRecoProducers/plugins/AlCaECALRecHitReducer.h"
//#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
#include "Geometry/CaloEventSetup/interface/CaloTopologyRecord.h"
#include "FWCore/Framework/interface/ESHandle.h"

//#define ALLrecHits
//#define DEBUG

//#define QUICK -> if commented loop over the recHits of the SC and add them to the list of recHits to be saved
//                 comment it if you want a faster module but be sure the window is large enough


AlCaECALRecHitReducer::AlCaECALRecHitReducer(const edm::ParameterSet& iConfig) 
{

  ebRecHitsToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter< edm::InputTag > ("ebRecHitsLabel"));
  eeRecHitsToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter< edm::InputTag > ("eeRecHitsLabel"));
  //  esRecHitsLabel_ = iConfig.getParameter< edm::InputTag > ("esRecHitsLabel");
 
  std::vector<edm::InputTag> srcLabels = iConfig.getParameter< std::vector<edm::InputTag> >("srcLabels");
  for ( auto inputTag = srcLabels.begin(); inputTag != srcLabels.end(); ++inputTag){
    eleViewTokens_.push_back(consumes<edm::View <reco::RecoCandidate> >(*inputTag));
  }
  
  //eleViewToken_ = consumes<edm::View <reco::RecoCandidate> > (iConfig.getParameter< edm::InputTag > ("electronLabel"));
  photonToken_ = consumes<reco::PhotonCollection>(iConfig.getParameter< edm::InputTag > ("photonLabel"));
  EESuperClusterToken_ = consumes<reco::SuperClusterCollection>(iConfig.getParameter< edm::InputTag>("EESuperClusterCollection"));

  minEta_highEtaSC_         = iConfig.getParameter< double >("minEta_highEtaSC");

  alcaBarrelHitsCollection_  = iConfig.getParameter<std::string>("alcaBarrelHitCollection");
  alcaEndcapHitsCollection_  = iConfig.getParameter<std::string>("alcaEndcapHitCollection");
  alcaCaloClusterCollection_ = iConfig.getParameter<std::string>("alcaCaloClusterCollection");
  
  //  alcaPreshowerHitsCollection_ = iConfig.getParameter<std::string>("alcaPreshowerHitCollection");
  
  etaSize_ = iConfig.getParameter<int> ("etaSize");
  phiSize_ = iConfig.getParameter<int> ("phiSize");
  // FIXME: minimum size of etaSize_ and phiSize_
  if ( phiSize_ % 2 == 0 ||  etaSize_ % 2 == 0)
    edm::LogError("AlCaECALRecHitReducerError") << "Size of eta/phi should be odd numbers";
 
  //  esNstrips_  = iConfig.getParameter<int> ("esNstrips");
  //  esNcolumns_ = iConfig.getParameter<int> ("esNcolumns");
  
  //register your products
  produces< EBRecHitCollection > (alcaBarrelHitsCollection_) ;
  produces< EERecHitCollection > (alcaEndcapHitsCollection_) ;
  produces< reco::CaloClusterCollection > (alcaCaloClusterCollection_) ;
  //  produces< ESRecHitCollection > (alcaPreshowerHitsCollection_) ;
}


AlCaECALRecHitReducer::~AlCaECALRecHitReducer()
{}


// ------------ method called to produce the data  ------------
void
AlCaECALRecHitReducer::produce (edm::Event& iEvent, 
                                const edm::EventSetup& iSetup)
{
  using namespace edm;
  //using namespace std;
  
  edm::ESHandle<CaloTopology> theCaloTopology;
  iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
  const CaloTopology *caloTopology = theCaloTopology.product();

  
  // Get Photons
  Handle<reco::PhotonCollection> phoHandle;
  iEvent.getByToken(photonToken_, phoHandle);
  
  // get RecHits
  Handle<EBRecHitCollection> barrelRecHitsHandle;
  iEvent.getByToken(ebRecHitsToken_,barrelRecHitsHandle);
  const EBRecHitCollection *barrelHitsCollection = barrelRecHitsHandle.product () ;
  
  // get RecHits
  Handle<EERecHitCollection> endcapRecHitsHandle;    
  iEvent.getByToken(eeRecHitsToken_,endcapRecHitsHandle);
  const EERecHitCollection *endcapHitsCollection = endcapRecHitsHandle.product () ;
  
  //   // get ES RecHits
  //   Handle<ESRecHitCollection> preshowerRecHitsHandle;
  //   iEvent.getByToken(esRecHitsToken_,preshowerRecHitsHandle);
  
  //   const ESRecHitCollection * preshowerHitsCollection = 0 ;
  //   if (preshowerIsFull)  
  //     preshowerHitsCollection = preshowerRecHitsHandle.product () ;

  //   // make a vector to store the used ES rechits:
  //   set<ESDetId> used_strips;
  //   used_strips.clear();

  // for Z->ele+SC
  Handle<reco::SuperClusterCollection> EESCHandle;
  iEvent.getByToken(EESuperClusterToken_, EESCHandle);
 
  //Create empty output collections
  auto miniEBRecHitCollection = std::make_unique<EBRecHitCollection>();
  auto miniEERecHitCollection = std::make_unique<EERecHitCollection>();  
  //  auto miniESRecHitCollection = std::make_unique<ESRecHitCollection>();  
  
  std::set<DetId> reducedRecHit_EBmap;
  std::set<DetId> reducedRecHit_EEmap;
  
  //  std::set< edm::Ref<reco::CaloCluster> > reducedCaloClusters_map;
  
  auto reducedCaloClusterCollection = std::make_unique<reco::CaloClusterCollection>();
  
  //Photons:
#ifdef shervin
  for (reco::PhotonCollection::const_iterator phoIt=phoHandle->begin(); phoIt!=phoHandle->end(); phoIt++) {
    const reco::SuperCluster& sc = *(phoIt->superCluster()) ;
    
    if (phoIt->isEB()) {
      AddMiniRecHitCollection(sc, reducedRecHit_EBmap, caloTopology);
    } else { // endcap
      AddMiniRecHitCollection(sc, reducedRecHit_EEmap, caloTopology);
    } // end of endcap
    
    reco::CaloCluster_iterator it = sc.clustersBegin();
    reco::CaloCluster_iterator itend = sc.clustersEnd();
    for ( ; it !=itend; ++it) {
      reco::CaloCluster caloClus(**it);
      reducedCaloClusterCollection->push_back(caloClus);
    }
  }
#endif

    Handle<edm::View < reco::RecoCandidate> > eleViewHandle;  
  for(auto iToken=eleViewTokens_.begin(); iToken!=eleViewTokens_.end(); iToken++){
    iEvent.getByToken(*iToken, eleViewHandle);

  //Electrons:  
  for (auto eleIt=eleViewHandle->begin(); eleIt!=eleViewHandle->end(); eleIt++) {
    const reco::SuperCluster& sc = *(eleIt->superCluster()) ;
    
    if (fabs(sc.eta())<1.479) {
      AddMiniRecHitCollection(sc, reducedRecHit_EBmap, caloTopology);
    } else { // endcap
      AddMiniRecHitCollection(sc, reducedRecHit_EEmap, caloTopology);
    } // end of endcap
    
    reco::CaloCluster_iterator it = sc.clustersBegin();
    reco::CaloCluster_iterator itend = sc.clustersEnd();
    for ( ; it !=itend; ++it) {
      reco::CaloCluster caloClus(**it);
      reducedCaloClusterCollection->push_back(caloClus);
    }
  }
  }
  
  

  //saving recHits for highEta SCs for highEta studies
  for(reco::SuperClusterCollection::const_iterator SC_iter = EESCHandle->begin();
      SC_iter!=EESCHandle->end();
      SC_iter++){
    if(fabs(SC_iter->eta()) < minEta_highEtaSC_) continue;
    AddMiniRecHitCollection(*SC_iter, reducedRecHit_EEmap, caloTopology);

    const reco::SuperCluster& sc = *(SC_iter);
    reco::CaloCluster_iterator it = sc.clustersBegin();
    reco::CaloCluster_iterator itend = sc.clustersEnd();
    for ( ; it !=itend; ++it) {
      reco::CaloCluster caloClus(**it);
      reducedCaloClusterCollection->push_back(caloClus);
    }
  }


  //------------------------------ fill the alcareco reduced recHit collection
  for(std::set<DetId>::const_iterator itr = reducedRecHit_EBmap.begin();
      itr != reducedRecHit_EBmap.end(); itr++){
    if (barrelHitsCollection->find(*itr) != barrelHitsCollection->end())
      miniEBRecHitCollection->push_back(*(barrelHitsCollection->find(*itr)));
  }

  for(std::set<DetId>::const_iterator itr = reducedRecHit_EEmap.begin();
      itr != reducedRecHit_EEmap.end(); itr++){
    if (endcapHitsCollection->find(*itr) != endcapHitsCollection->end())
      miniEERecHitCollection->push_back(*(endcapHitsCollection->find(*itr)));
  }


  //--------------------------------------- Put selected information in the event
  iEvent.put(std::move(miniEBRecHitCollection),alcaBarrelHitsCollection_ );
  iEvent.put(std::move(miniEERecHitCollection),alcaEndcapHitsCollection_ );     
  //  iEvent.put(std::move(miniESRecHitCollection),alcaPreshowerHitsCollection_ );     
  iEvent.put(std::move(reducedCaloClusterCollection), alcaCaloClusterCollection_);
}

void AlCaECALRecHitReducer::AddMiniRecHitCollection(const reco::SuperCluster& sc,
                            std::set<DetId>& reducedRecHitMap,
                            const CaloTopology *caloTopology                        
                            ){
  DetId seed=(sc.seed()->seed());
  int phiSize=phiSize_, etaSize=etaSize_;
  if(seed.subdetId()!=EcalBarrel){ // if not EB, take a square window
    etaSize= std::max(phiSize_,etaSize_);
    phiSize=etaSize;
  }

  std::vector<DetId> recHit_window = caloTopology->getWindow(seed, phiSize, etaSize);
  for(unsigned int i =0; i < recHit_window.size(); i++){
    reducedRecHitMap.insert(recHit_window[i]);
  }

  const std::vector< std::pair<DetId, float> > & scHits = sc.hitsAndFractions();
  for(std::vector< std::pair<DetId, float> >::const_iterator scHit_itr = scHits.begin(); 
      scHit_itr != scHits.end(); scHit_itr++){
    // the map fills just one time (avoiding double insert of recHits)
    reducedRecHitMap.insert(scHit_itr->first);
  }


  return;
}


DEFINE_FWK_MODULE(AlCaECALRecHitReducer);