EcalRecHitRecalib.cc

Go to the documentation of this file.

 
#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
 
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
 
#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"
#include "CalibCalorimetry/CaloMiscalibTools/interface/EcalRecHitRecalib.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
EcalRecHitRecalib::EcalRecHitRecalib(const edm::ParameterSet& iConfig) {
  ecalHitsProducer_ = iConfig.getParameter<std::string>("ecalRecHitsProducer");
  barrelHits_ = iConfig.getParameter<std::string>("barrelHitCollection");
  endcapHits_ = iConfig.getParameter<std::string>("endcapHitCollection");
  RecalibBarrelHits_ = iConfig.getParameter<std::string>("RecalibBarrelHitCollection");
  RecalibEndcapHits_ = iConfig.getParameter<std::string>("RecalibEndcapHitCollection");
  refactor_ = iConfig.getUntrackedParameter<double>("Refactor", (double)1);
  refactor_mean_ = iConfig.getUntrackedParameter<double>("Refactor_mean", (double)1);
 
  //register your products
  produces<EBRecHitCollection>(RecalibBarrelHits_);
  produces<EERecHitCollection>(RecalibEndcapHits_);
}
 
EcalRecHitRecalib::~EcalRecHitRecalib() {}
 
// ------------ method called to produce the data  ------------
void EcalRecHitRecalib::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  using namespace edm;
  using namespace std;
 
  Handle<EBRecHitCollection> barrelRecHitsHandle;
  Handle<EERecHitCollection> endcapRecHitsHandle;
 
  const EBRecHitCollection* EBRecHits = nullptr;
  const EERecHitCollection* EERecHits = nullptr;
 
  iEvent.getByLabel(ecalHitsProducer_, barrelHits_, barrelRecHitsHandle);
  if (!barrelRecHitsHandle.isValid()) {
    LogDebug("") << "EcalREcHitMiscalib: Error! can't get product!" << std::endl;
  } else {
    EBRecHits = barrelRecHitsHandle.product();  // get a ptr to the product
  }
 
  iEvent.getByLabel(ecalHitsProducer_, endcapHits_, endcapRecHitsHandle);
  if (!endcapRecHitsHandle.isValid()) {
    LogDebug("") << "EcalREcHitMiscalib: Error! can't get product!" << std::endl;
  } else {
    EERecHits = endcapRecHitsHandle.product();  // get a ptr to the product
  }
 
  //Create empty output collections
  auto RecalibEBRecHitCollection = std::make_unique<EBRecHitCollection>();
  auto RecalibEERecHitCollection = std::make_unique<EERecHitCollection>();
 
  // Intercalib constants
  edm::ESHandle<EcalIntercalibConstants> pIcal;
  iSetup.get<EcalIntercalibConstantsRcd>().get(pIcal);
  const EcalIntercalibConstants* ical = pIcal.product();
 
  if (EBRecHits) {
    //loop on all EcalRecHits (barrel)
    EBRecHitCollection::const_iterator itb;
    for (itb = EBRecHits->begin(); itb != EBRecHits->end(); ++itb) {
      // find intercalib constant for this xtal
      EcalIntercalibConstantMap::const_iterator icalit = ical->getMap().find(itb->id().rawId());
      EcalIntercalibConstant icalconst = -1;
 
      if (icalit != ical->getMap().end()) {
        icalconst = (*icalit);
        // edm::LogDebug("EcalRecHitRecalib") << "Found intercalib for xtal " << EBDetId(itb->id()) << " " << icalconst ;
 
      } else {
        edm::LogError("EcalRecHitRecalib") << "No intercalib const found for xtal " << EBDetId(itb->id())
                                           << "! something wrong with EcalIntercalibConstants in your DB? ";
      }
 
      // make the rechit with rescaled energy and put in the output collection
      icalconst = refactor_mean_ +
                  (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
      EcalRecHit aHit(itb->id(), itb->energy() * icalconst, itb->time());
 
      RecalibEBRecHitCollection->push_back(aHit);
    }
  }
 
  if (EERecHits) {
    //loop on all EcalRecHits (barrel)
    EERecHitCollection::const_iterator ite;
    for (ite = EERecHits->begin(); ite != EERecHits->end(); ++ite) {
      // find intercalib constant for this xtal
      EcalIntercalibConstantMap::const_iterator icalit = ical->getMap().find(ite->id().rawId());
      EcalIntercalibConstant icalconst = -1;
 
      if (icalit != ical->getMap().end()) {
        icalconst = (*icalit);
        // edm:: LogDebug("EcalRecHitRecalib") << "Found intercalib for xtal " << EEDetId(ite->id()) << " " << icalconst ;
      } else {
        edm::LogError("EcalRecHitRecalib") << "No intercalib const found for xtal " << EEDetId(ite->id())
                                           << "! something wrong with EcalIntercalibConstants in your DB? ";
      }
 
      // make the rechit with rescaled energy and put in the output collection
 
      icalconst = refactor_mean_ +
                  (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
      EcalRecHit aHit(ite->id(), ite->energy() * icalconst, ite->time());
 
      RecalibEERecHitCollection->push_back(aHit);
    }
  }
 
  //Put Recalibrated rechit in the event
  iEvent.put(std::move(RecalibEBRecHitCollection), RecalibBarrelHits_);
  iEvent.put(std::move(RecalibEERecHitCollection), RecalibEndcapHits_);
}