ReducedESRecHitCollectionProducer.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "Geometry/EcalAlgo/interface/EcalPreshowerGeometry.h"
#include "Geometry/CaloTopology/interface/EcalPreshowerTopology.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "RecoCaloTools/Navigation/interface/EcalPreshowerNavigator.h"
#include "RecoEcal/EgammaClusterProducers/interface/ReducedESRecHitCollectionProducer.h"
#include "FWCore/Utilities/interface/transform.h"

using namespace edm;
using namespace std;
using namespace reco;

ReducedESRecHitCollectionProducer::ReducedESRecHitCollectionProducer(const edm::ParameterSet& ps):
  geometry_p(nullptr)
{

 scEtThresh_          = ps.getParameter<double>("scEtThreshold");

 InputRecHitES_       = 
     consumes<ESRecHitCollection>(ps.getParameter<edm::InputTag>("EcalRecHitCollectionES"));
 InputSuperClusterEE_ = 
     consumes<reco::SuperClusterCollection>(ps.getParameter<edm::InputTag>("EndcapSuperClusterCollection")); 

 OutputLabelES_       = ps.getParameter<std::string>("OutputLabel_ES");
 
 interestingDetIdCollections_  = 
     edm::vector_transform(
           ps.getParameter<std::vector<edm::InputTag>>("interestingDetIds"),
           [this](edm::InputTag const & tag) { 
               return consumes<DetIdCollection>(tag); 
           }
           );

 interestingDetIdCollectionsNotToClean_ = edm::vector_transform(ps.getParameter<std::vector<edm::InputTag>>("interestingDetIdsNotToClean"),
                                [this](edm::InputTag const & tag) 
                                { return consumes<DetIdCollection>(tag); }
                                );

 produces< EcalRecHitCollection > (OutputLabelES_);
 
}

ReducedESRecHitCollectionProducer::~ReducedESRecHitCollectionProducer() = default;

void ReducedESRecHitCollectionProducer::beginRun (edm::Run const&, const edm::EventSetup&iSetup){
  ESHandle<CaloGeometry> geoHandle;
  iSetup.get<CaloGeometryRecord>().get(geoHandle);
  geometry_p = dynamic_cast<const EcalPreshowerGeometry*>(geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalPreshower));
  if (!geometry_p){
    edm::LogError("WrongGeometry")<<
      "could not cast the subdet geometry to preshower geometry";
  }
  
  if (geometry_p) topology_p = std::make_unique<EcalPreshowerTopology>();
  
}

void ReducedESRecHitCollectionProducer::produce(edm::Event & e, const edm::EventSetup& iSetup){


  edm::Handle<ESRecHitCollection> ESRecHits_;
  e.getByToken(InputRecHitES_, ESRecHits_);
  
  auto output = std::make_unique<EcalRecHitCollection>();

  edm::Handle<reco::SuperClusterCollection> pEndcapSuperClusters;
  e.getByToken(InputSuperClusterEE_, pEndcapSuperClusters);
  {
    const reco::SuperClusterCollection* eeSuperClusters = pEndcapSuperClusters.product();
    
    for (reco::SuperClusterCollection::const_iterator isc = eeSuperClusters->begin(); isc != eeSuperClusters->end(); ++isc) {

      if (isc->energy() < scEtThresh_) continue;
      if (fabs(isc->eta()) < 1.65 || fabs(isc->eta()) > 2.6) continue;
      //cout<<"SC energy : "<<isc->energy()<<" "<<isc->eta()<<endl;

      //Int_t nBC = 0;
      reco::CaloCluster_iterator ibc = isc->clustersBegin();
      for ( ; ibc != isc->clustersEnd(); ++ibc ) {  

    //cout<<"BC : "<<nBC<<endl;

    const GlobalPoint point((*ibc)->x(),(*ibc)->y(),(*ibc)->z());

    ESDetId esId1 = geometry_p->getClosestCellInPlane(point, 1);
    ESDetId esId2 = geometry_p->getClosestCellInPlane(point, 2);
    
    collectIds(esId1, esId2, 0);
    collectIds(esId1, esId2, 1);
    collectIds(esId1, esId2, -1);

    //nBC++;
      }
      
    }
    
  }


  edm::Handle<DetIdCollection > detId;
  for( unsigned int t = 0; t < interestingDetIdCollections_.size(); ++t )
    {
      e.getByToken(interestingDetIdCollections_[t],detId);    
      if(!detId.isValid())
      {
          Labels labels;
          labelsForToken(interestingDetIdCollections_[t], labels);
          edm::LogError("MissingInput")<<"no reason to skip detid from : (" << labels.module << ", "
                                                                            << labels.productInstance << ", "
                                                                            << labels.process << ")" << std::endl;
          continue;
      }
      collectedIds_.insert(detId->begin(),detId->end());
    }


  //screw it, cant think of a better solution, not the best but lets run over all the rec hits, remove the ones failing cleaning
  //and then merge in the collection not to be cleaned
  //mainly as I suspect its more efficient to find an object in the DetIdSet rather than the rec-hit in the rec-hit collecition
  //with only a det id
  //if its a CPU issues then revisit
  for(const auto& hit : *ESRecHits_) {
    if(hit.recoFlag()==1 || hit.recoFlag()==14 || (hit.recoFlag()<=10 && hit.recoFlag()>=5)){ //right we might need to erase it from the collection
      auto idIt = collectedIds_.find(hit.id());
      if(idIt!=collectedIds_.end()) collectedIds_.erase(idIt);
    }
  }
   
  
  for(const auto& token : interestingDetIdCollectionsNotToClean_) {
    e.getByToken(token,detId);    
    if(!detId.isValid()){ //meh might as well keep the warning
      Labels labels;
      labelsForToken(token, labels);
      edm::LogError("MissingInput")<<"no reason to skip detid from : (" << labels.module << ", "
                   << labels.productInstance << ", "
                   << labels.process << ")" << std::endl;
      continue;
    }
    collectedIds_.insert(detId->begin(),detId->end());
  }
  

  output->reserve( collectedIds_.size());
  EcalRecHitCollection::const_iterator it;
  for (it = ESRecHits_->begin(); it != ESRecHits_->end(); ++it) {
    if (collectedIds_.find(it->id())!=collectedIds_.end()){
      output->push_back(*it);
    }
  }
  collectedIds_.clear();

  e.put(std::move(output), OutputLabelES_);

}


void ReducedESRecHitCollectionProducer::collectIds(const ESDetId esDetId1, const ESDetId esDetId2, const int & row) {

  //cout<<row<<endl;
  
  map<DetId,const EcalRecHit*>::iterator it;
  map<DetId, int>::iterator itu;
  ESDetId next;
  ESDetId strip1;
  ESDetId strip2;

  strip1 = esDetId1;
  strip2 = esDetId2;

  EcalPreshowerNavigator theESNav1(strip1, topology_p.get());
  theESNav1.setHome(strip1);
  
  EcalPreshowerNavigator theESNav2(strip2, topology_p.get());
  theESNav2.setHome(strip2);

  if (row == 1) {
    if (strip1 != ESDetId(0)) strip1 = theESNav1.north();
    if (strip2 != ESDetId(0)) strip2 = theESNav2.east();
  } else if (row == -1) {
    if (strip1 != ESDetId(0)) strip1 = theESNav1.south();
    if (strip2 != ESDetId(0)) strip2 = theESNav2.west();
  }

  // Plane 1 
  if (strip1 == ESDetId(0)) {
  } else {
    collectedIds_.insert(strip1);
    //cout<<"center : "<<strip1<<endl;
    // east road 
    for (int i=0; i<15; ++i) {
      next = theESNav1.east();
      //cout<<"east : "<<i<<" "<<next<<endl;
      if (next != ESDetId(0)) {
    collectedIds_.insert(next);
      } else {
    break;
      }
    }

    // west road 
    theESNav1.setHome(strip1);
    theESNav1.home();
    for (int i=0; i<15; ++i) {
      next = theESNav1.west();
      //cout<<"west : "<<i<<" "<<next<<endl;
      if (next != ESDetId(0)) {
    collectedIds_.insert(next);
      } else {
    break;
      }
    }

  }

  if (strip2 == ESDetId(0)) {
  } else {
    collectedIds_.insert(strip2);
    //cout<<"center : "<<strip2<<endl;
    // north road 
    for (int i=0; i<15; ++i) {
      next = theESNav2.north();
      //cout<<"north : "<<i<<" "<<next<<endl;
      if (next != ESDetId(0)) {
    collectedIds_.insert(next);
      } else {
    break;
      } 
    }

    // south road 
    theESNav2.setHome(strip2);
    theESNav2.home();
    for (int i=0; i<15; ++i) {
      next = theESNav2.south();
      //cout<<"south : "<<i<<" "<<next<<endl;
      if (next != ESDetId(0)) {
    collectedIds_.insert(next);
      } else {
    break;
      }
    }
  }
}