HcalRecHitRecalib.cc

Go to the documentation of this file.

#include "CalibCalorimetry/CaloMiscalibTools/interface/HcalRecHitRecalib.h"

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "Geometry/Records/interface/HcalRecNumberingRecord.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/Framework/interface/ESHandle.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "CalibCalorimetry/CaloMiscalibTools/interface/MiscalibReaderFromXMLHcal.h"

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

  tok_hbhe_ = consumes<HBHERecHitCollection>(iConfig.getParameter<edm::InputTag>("hbheInput"));
  tok_ho_ = consumes<HORecHitCollection>(iConfig.getParameter<edm::InputTag>("hoInput"));
  tok_hf_ = consumes<HFRecHitCollection>(iConfig.getParameter<edm::InputTag>("hfInput"));

//   HBHEHitsProducer_ = iConfig.getParameter< std::string > ("HBHERecHitsProducer");
//   HOHitsProducer_ = iConfig.getParameter< std::string > ("HERecHitsProducer");
//   HFHitsProducer_ = iConfig.getParameter< std::string > ("HERecHitsProducer");
//   HBHEHits_ = iConfig.getParameter< std::string > ("HBHEHitCollection");
//   HFHits_ = iConfig.getParameter< std::string > ("HFHitCollection");
//   HOHits_ = iConfig.getParameter< std::string > ("HOHitCollection");

  RecalibHBHEHits_ = iConfig.getParameter< std::string > ("RecalibHBHEHitCollection");
  RecalibHFHits_ = iConfig.getParameter< std::string > ("RecalibHFHitCollection");
  RecalibHOHits_ = iConfig.getParameter< std::string > ("RecalibHOHitCollection");

  refactor_ = iConfig.getUntrackedParameter<double> ("Refactor",(double)1);
  refactor_mean_ = iConfig.getUntrackedParameter<double> ("Refactor_mean",(double)1);

  //register your products
  produces< HBHERecHitCollection >(RecalibHBHEHits_);
  produces< HFRecHitCollection >(RecalibHFHits_);
  produces< HORecHitCollection >(RecalibHOHits_);

  // here read them from xml (particular to HCAL)

  hcalfileinpath_=iConfig.getUntrackedParameter<std::string> ("fileNameHcal","");
  edm::FileInPath hcalfiletmp("CalibCalorimetry/CaloMiscalibTools/data/"+hcalfileinpath_);

  hcalfile_=hcalfiletmp.fullPath();
}


HcalRecHitRecalib::~HcalRecHitRecalib()
{
 

}

void
HcalRecHitRecalib::beginRun(const edm::Run&, const edm::EventSetup& iSetup)
{
  edm::ESHandle<HcalTopology> topology;
  iSetup.get<HcalRecNumberingRecord>().get( topology );
  
  mapHcal_.prefillMap(*topology);

  MiscalibReaderFromXMLHcal hcalreader_(mapHcal_);
  if(!hcalfile_.empty()) hcalreader_.parseXMLMiscalibFile(hcalfile_);
  mapHcal_.print();
}

// ------------ method called to produce the data  ------------
void
HcalRecHitRecalib::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
  using namespace edm;
  using namespace std;

  Handle<HBHERecHitCollection> HBHERecHitsHandle;
  Handle<HFRecHitCollection> HFRecHitsHandle;
  Handle<HORecHitCollection> HORecHitsHandle;

  const HBHERecHitCollection*  HBHERecHits = nullptr;
  const HFRecHitCollection*  HFRecHits = nullptr;
  const HORecHitCollection*  HORecHits = nullptr;

  iEvent.getByToken(tok_hbhe_,HBHERecHitsHandle);
  if (!HBHERecHitsHandle.isValid()) {
    LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
  } else {
    HBHERecHits = HBHERecHitsHandle.product(); // get a ptr to the product
  }

  iEvent.getByToken(tok_ho_,HORecHitsHandle);
  if (!HORecHitsHandle.isValid()) {
    LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
  } else {
    HORecHits = HORecHitsHandle.product(); // get a ptr to the product
  }

  iEvent.getByToken(tok_hf_,HFRecHitsHandle);
  if (!HFRecHitsHandle.isValid()) {
    LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
  } else {
    HFRecHits = HFRecHitsHandle.product(); // get a ptr to the product
  }


//     iEvent.getByLabel(HBHEHitsProducer_,HBHEHits_,HBHERecHitsHandle);
//     HBHERecHits = HBHERecHitsHandle.product(); // get a ptr to the product

//     iEvent.getByLabel(HFHitsProducer_,HFHits_,HFRecHitsHandle);
//     HFRecHits = HFRecHitsHandle.product(); // get a ptr to the product

//     iEvent.getByLabel(HOHitsProducer_,HOHits_,HORecHitsHandle);
//     HORecHits = HORecHitsHandle.product(); // get a ptr to the product


  //Create empty output collections
  auto RecalibHBHERecHitCollection = std::make_unique<HBHERecHitCollection>();
  auto RecalibHFRecHitCollection = std::make_unique<HFRecHitCollection>();
  auto RecalibHORecHitCollection = std::make_unique<HORecHitCollection>();

  // Intercalib constants
  //  edm::ESHandle<EcalIntercalibConstants> pIcal;
  //  iSetup.get<EcalIntercalibConstantsRcd>().get(pIcal);
  //  const EcalIntercalibConstants* ical = pIcal.product();

  if(HBHERecHits)
    {

       //loop on all EcalRecHits (barrel)
      HBHERecHitCollection::const_iterator itHBHE;
      for (itHBHE=HBHERecHits->begin(); itHBHE!=HBHERecHits->end(); ++itHBHE) {
    
    // find intercalib constant for this cell

    //  EcalIntercalibConstants::EcalIntercalibConstantMap::const_iterator icalit=ical->getMap().find(itb->id().rawId());
    //  EcalIntercalibConstants::EcalIntercalibConstant icalconst;

    //  if( icalit!=ical->getMap().end() ){
    //    icalconst = icalit->second;
      // edm::LogDebug("EcalRecHitMiscalib") << "Found intercalib for xtal " << EBDetId(itb->id()) << " " << icalconst ;

    //  } else {
    //    edm::LogError("EcalRecHitMiscalib") << "No intercalib const found for xtal " << EBDetId(itb->id()) << "! something wrong with EcalIntercalibConstants in your DB? "
    //              ;
    //          }
          
    float icalconst=(mapHcal_.get().find(itHBHE->id().rawId()))->second;
          // 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)    
    HBHERecHit aHit(itHBHE->id(),itHBHE->energy()*icalconst,itHBHE->time());
    
    RecalibHBHERecHitCollection->push_back( aHit);
      }
    }

  if(HFRecHits)
    {

       //loop on all EcalRecHits (barrel)
      HFRecHitCollection::const_iterator itHF;
      for (itHF=HFRecHits->begin(); itHF!=HFRecHits->end(); ++itHF) {
    
    // find intercalib constant for this cell

    //  EcalIntercalibConstants::EcalIntercalibConstantMap::const_iterator icalit=ical->getMap().find(itb->id().rawId());
    //  EcalIntercalibConstants::EcalIntercalibConstant icalconst;

    //  if( icalit!=ical->getMap().end() ){
    //    icalconst = icalit->second;
      // edm::LogDebug("EcalRecHitMiscalib") << "Found intercalib for xtal " << EBDetId(itb->id()) << " " << icalconst ;

    //  } else {
    //    edm::LogError("EcalRecHitMiscalib") << "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
    
    float icalconst=(mapHcal_.get().find(itHF->id().rawId()))->second;
    icalconst=refactor_mean_+(icalconst-refactor_mean_)*refactor_; //apply additional scaling factor (works if gaussian)    
    HFRecHit aHit(itHF->id(),itHF->energy()*icalconst,itHF->time());
    
    RecalibHFRecHitCollection->push_back( aHit);
      }
    }

  if(HORecHits)
    {

       //loop on all EcalRecHits (barrel)
      HORecHitCollection::const_iterator itHO;
      for (itHO=HORecHits->begin(); itHO!=HORecHits->end(); ++itHO) {
    
    // find intercalib constant for this cell

    //  EcalIntercalibConstants::EcalIntercalibConstantMap::const_iterator icalit=ical->getMap().find(itb->id().rawId());
    //  EcalIntercalibConstants::EcalIntercalibConstant icalconst;

    //  if( icalit!=ical->getMap().end() ){
    //    icalconst = icalit->second;
      // edm::LogDebug("EcalRecHitMiscalib") << "Found intercalib for xtal " << EBDetId(itb->id()) << " " << icalconst ;

    //  } else {
    //    edm::LogError("EcalRecHitMiscalib") << "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

    float icalconst=(mapHcal_.get().find(itHO->id().rawId()))->second;
    icalconst=refactor_mean_+(icalconst-refactor_mean_)*refactor_; //apply additional scaling factor (works if gaussian)    
    HORecHit aHit(itHO->id(),itHO->energy()*icalconst,itHO->time());
      
      RecalibHORecHitCollection->push_back( aHit);
      }
    }


  //Put Recalibrated rechit in the event
  iEvent.put(std::move(RecalibHBHERecHitCollection), RecalibHBHEHits_);
  iEvent.put(std::move(RecalibHFRecHitCollection), RecalibHFHits_);
  iEvent.put(std::move(RecalibHORecHitCollection), RecalibHOHits_);
}