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_);
  
}