#include <PFHFRecHitCreator.h>

Inheritance diagram for PFHFRecHitCreator:

Classes
class	DetIDSorter

Public Member Functions
void	importRecHits (std::unique_ptr< reco::PFRecHitCollection > &out, std::unique_ptr< reco::PFRecHitCollection > &cleaned, const edm::Event &iEvent, const edm::EventSetup &iSetup) override

	PFHFRecHitCreator (const edm::ParameterSet &iConfig, edm::ConsumesCollector &iC)

Public Member Functions inherited from PFRecHitCreatorBase
virtual void	init (const edm::EventSetup &es)

	PFRecHitCreatorBase ()

	PFRecHitCreatorBase (const edm::ParameterSet &iConfig, edm::ConsumesCollector &iC)

virtual	~PFRecHitCreatorBase ()=default

Protected Attributes
double	EM_Depth_

double	HAD_Depth_

double	HFCalib_

double	longFibre_Cut

double	longFibre_Fraction

edm::EDGetTokenT< edm::SortedCollection< HFRecHit > >	recHitToken_

double	shortFibre_Cut

double	shortFibre_Fraction

double	thresh_HF_

Protected Attributes inherited from PFRecHitCreatorBase
std::vector< std::unique_ptr< PFRecHitQTestBase > >	qualityTests_

Additional Inherited Members
Protected Member Functions inherited from PFRecHitCreatorBase
void	beginEvent (const edm::Event &event, const edm::EventSetup &setup)

Detailed Description

Definition at line 21 of file PFHFRecHitCreator.h.

Constructor & Destructor Documentation

◆ PFHFRecHitCreator()

PFHFRecHitCreator::PFHFRecHitCreator	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &	iC
	)

inline

Definition at line 23 of file PFHFRecHitCreator.h.

                                                                               : PFRecHitCreatorBase(iConfig, iC) {
     recHitToken_ = iC.consumes<edm::SortedCollection<HFRecHit> >(iConfig.getParameter<edm::InputTag>("src"));
     EM_Depth_ = iConfig.getParameter<double>("EMDepthCorrection");
     HAD_Depth_ = iConfig.getParameter<double>("HADDepthCorrection");
     shortFibre_Cut = iConfig.getParameter<double>("ShortFibre_Cut");
     longFibre_Fraction = iConfig.getParameter<double>("LongFibre_Fraction");
     longFibre_Cut = iConfig.getParameter<double>("LongFibre_Cut");
     shortFibre_Fraction = iConfig.getParameter<double>("ShortFibre_Fraction");
     thresh_HF_ = iConfig.getParameter<double>("thresh_HF");
     HFCalib_ = iConfig.getParameter<double>("HFCalib29");
   }

References edm::ConsumesCollector::consumes(), EM_Depth_, edm::ParameterSet::getParameter(), HAD_Depth_, HFCalib_, longFibre_Cut, longFibre_Fraction, recHitToken_, shortFibre_Cut, shortFibre_Fraction, and thresh_HF_.

Member Function Documentation

◆ importRecHits()

void PFHFRecHitCreator::importRecHits	(	std::unique_ptr< reco::PFRecHitCollection > &	out,
		std::unique_ptr< reco::PFRecHitCollection > &	cleaned,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

inlineoverridevirtual

Implements PFRecHitCreatorBase.

Definition at line 35 of file PFHFRecHitCreator.h.

                                                            {
     reco::PFRecHitCollection tmpOut;
  
     beginEvent(iEvent, iSetup);
  
     edm::Handle<edm::SortedCollection<HFRecHit> > recHitHandle;
  
     edm::ESHandle<CaloGeometry> geoHandle;
     iSetup.get<CaloGeometryRecord>().get(geoHandle);
  
     // get the ecal geometry
     const CaloSubdetectorGeometry* hcalGeo = geoHandle->getSubdetectorGeometry(DetId::Hcal, HcalForward);
  
     iEvent.getByToken(recHitToken_, recHitHandle);
     for (const auto& erh : *recHitHandle) {
       const HcalDetId& detid = (HcalDetId)erh.detid();
       auto depth = detid.depth();
  
       // ATTN: skip dual anode in HF for now (should be fixed in upstream changes)
       if (depth > 2)
         continue;
  
       auto energy = erh.energy();
       auto time = erh.time();
  
       std::shared_ptr<const CaloCellGeometry> thisCell = hcalGeo->getGeometry(detid);
       auto zp = dynamic_cast<IdealZPrism const*>(thisCell.get());
       assert(zp);
       thisCell = zp->forPF();
  
       // find rechit geometry
       if (!thisCell) {
         edm::LogError("PFHFRecHitCreator")
             << "warning detid " << detid.rawId() << " not found in geometry" << std::endl;
         continue;
       }
  
       PFLayer::Layer layer = depth == 1 ? PFLayer::HF_EM : PFLayer::HF_HAD;
  
       reco::PFRecHit rh(thisCell, detid.rawId(), layer, energy);
       rh.setTime(time);
       rh.setDepth(depth);
  
       bool rcleaned = false;
       bool keep = true;
  
       //Apply Q tests
       for (const auto& qtest : qualityTests_) {
         if (!qtest->test(rh, erh, rcleaned)) {
           keep = false;
         }
       }
  
       if (keep) {
         tmpOut.push_back(std::move(rh));
       } else if (rcleaned)
         cleaned->push_back(std::move(rh));
     }
     //Sort by DetID the collection
     DetIDSorter sorter;
     if (!tmpOut.empty())
       std::sort(tmpOut.begin(), tmpOut.end(), sorter);
  
  
     for (auto& hit : tmpOut) {
       reco::PFRecHit newHit = hit;
       const HcalDetId& detid = (HcalDetId)hit.detId();
       if (detid.depth() == 1) {
         double lONG = hit.energy();
         //find the short hit
         HcalDetId shortID(HcalForward, detid.ieta(), detid.iphi(), 2);
         auto found_hit =
             std::lower_bound(tmpOut.begin(), tmpOut.end(), shortID, [](const reco::PFRecHit& a, HcalDetId b) {
               return a.detId() < b.rawId();
             });
         if (found_hit != tmpOut.end() && found_hit->detId() == shortID.rawId()) {
           double sHORT = found_hit->energy();
           //Ask for fraction
           double energy = lONG - sHORT;
  
           if (abs(detid.ieta()) <= 32)
             energy *= HFCalib_;
           newHit.setEnergy(energy);
           if (!(lONG > longFibre_Cut && (sHORT / lONG < shortFibre_Fraction)))
             if (energy > thresh_HF_)
               out->push_back(newHit);
         } else {
           //make only long hit
           double energy = lONG;
           if (abs(detid.ieta()) <= 32)
             energy *= HFCalib_;
           newHit.setEnergy(energy);
  
           if (energy > thresh_HF_)
             out->push_back(newHit);
         }
  
       } else {
         double sHORT = hit.energy();
         HcalDetId longID(HcalForward, detid.ieta(), detid.iphi(), 1);
         auto found_hit =
             std::lower_bound(tmpOut.begin(), tmpOut.end(), longID, [](const reco::PFRecHit& a, HcalDetId b) {
               return a.detId() < b.rawId();
             });
         double energy = 2 * sHORT;
         if (found_hit != tmpOut.end() && found_hit->detId() == longID.rawId()) {
           double lONG = found_hit->energy();
           //Ask for fraction
  
           //If in this case lONG-sHORT<0 add the energy to the sHORT
           if ((lONG - sHORT) < thresh_HF_)
             energy = lONG + sHORT;
  
           if (abs(detid.ieta()) <= 32)
             energy *= HFCalib_;
  
           newHit.setEnergy(energy);
           if (!(sHORT > shortFibre_Cut && (lONG / sHORT < longFibre_Fraction)))
             if (energy > thresh_HF_)
               out->push_back(newHit);
  
         } else {
           //only short hit!
           if (abs(detid.ieta()) <= 32)
             energy *= HFCalib_;
           newHit.setEnergy(energy);
           if (energy > thresh_HF_)
             out->push_back(newHit);
         }
       }
     }
   }