#include <ESRecHitWorker.h>

Inheritance diagram for ESRecHitWorker:

Public Member Functions
	ESRecHitWorker (const edm::ParameterSet &ps, edm::ConsumesCollector cc)

bool	run (const ESDigiCollection::const_iterator &digi, ESRecHitCollection &result) override

void	set (const edm::EventSetup &es) override

	~ESRecHitWorker () override

Public Member Functions inherited from ESRecHitWorkerBaseClass
	ESRecHitWorkerBaseClass (const edm::ParameterSet &)

virtual	~ESRecHitWorkerBaseClass ()

Private Attributes
ESRecHitAnalyticAlgo *	algoA_

ESRecHitFitAlgo *	algoF_

ESRecHitSimAlgo *	algoW_

edm::ESHandle< ESAngleCorrectionFactors >	esAngleCorrFactors_

edm::ESGetToken< ESAngleCorrectionFactors, ESAngleCorrectionFactorsRcd >	esAngleCorrFactorsToken_

edm::ESHandle< ESChannelStatus >	esChannelStatus_

edm::ESGetToken< ESChannelStatus, ESChannelStatusRcd >	esChannelStatusToken_

edm::ESHandle< ESGain >	esgain_

edm::ESGetToken< ESGain, ESGainRcd >	esgainToken_

edm::ESHandle< ESIntercalibConstants >	esMIPs_

edm::ESGetToken< ESIntercalibConstants, ESIntercalibConstantsRcd >	esMIPsToken_

edm::ESHandle< ESMIPToGeVConstant >	esMIPToGeV_

edm::ESGetToken< ESMIPToGeVConstant, ESMIPToGeVConstantRcd >	esMIPToGeVToken_

edm::ESHandle< ESPedestals >	esPedestals_

edm::ESGetToken< ESPedestals, ESPedestalsRcd >	esPedestalsToken_

edm::ESHandle< ESRecHitRatioCuts >	esRatioCuts_

edm::ESGetToken< ESRecHitRatioCuts, ESRecHitRatioCutsRcd >	esRatioCutsToken_

edm::ESHandle< ESTimeSampleWeights >	esWeights_

edm::ESGetToken< ESTimeSampleWeights, ESTimeSampleWeightsRcd >	esWeightsToken_

int	recoAlgo_

Detailed Description

Definition at line 37 of file ESRecHitWorker.h.

Constructor & Destructor Documentation

◆ ESRecHitWorker()

ESRecHitWorker::ESRecHitWorker	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector	cc
	)

Definition at line 13 of file ESRecHitWorker.cc.

                                                                                  : ESRecHitWorkerBaseClass(ps) {
   recoAlgo_ = ps.getParameter<int>("ESRecoAlgo");
   esgainToken_ = cc.esConsumes<ESGain, ESGainRcd>();
   esMIPToGeVToken_ = cc.esConsumes<ESMIPToGeVConstant, ESMIPToGeVConstantRcd>();
   esWeightsToken_ = cc.esConsumes<ESTimeSampleWeights, ESTimeSampleWeightsRcd>();
   esPedestalsToken_ = cc.esConsumes<ESPedestals, ESPedestalsRcd>();
   esMIPsToken_ = cc.esConsumes<ESIntercalibConstants, ESIntercalibConstantsRcd>();
   esChannelStatusToken_ = cc.esConsumes<ESChannelStatus, ESChannelStatusRcd>();
   esRatioCutsToken_ = cc.esConsumes<ESRecHitRatioCuts, ESRecHitRatioCutsRcd>();
   esAngleCorrFactorsToken_ = cc.esConsumes<ESAngleCorrectionFactors, ESAngleCorrectionFactorsRcd>();
  
   if (recoAlgo_ == 0)
     algoW_ = new ESRecHitSimAlgo();
   else if (recoAlgo_ == 1)
     algoF_ = new ESRecHitFitAlgo();
   else
     algoA_ = new ESRecHitAnalyticAlgo();
 }

References algoA_, algoF_, algoW_, esAngleCorrFactorsToken_, esChannelStatusToken_, esgainToken_, esMIPsToken_, esMIPToGeVToken_, esPedestalsToken_, esRatioCutsToken_, esWeightsToken_, edm::ParameterSet::getParameter(), and recoAlgo_.

◆ ~ESRecHitWorker()

ESRecHitWorker::~ESRecHitWorker ( )

override

Definition at line 32 of file ESRecHitWorker.cc.

                                 {
   if (recoAlgo_ == 0)
     delete algoW_;
   else if (recoAlgo_ == 1)
     delete algoF_;
   else
     delete algoA_;
 }

References algoA_, algoF_, algoW_, and recoAlgo_.

Member Function Documentation

◆ run()

bool ESRecHitWorker::run	(	const ESDigiCollection::const_iterator &	digi,
		ESRecHitCollection &	result
	)

overridevirtual

Implements ESRecHitWorkerBaseClass.

Definition at line 103 of file ESRecHitWorker.cc.

                                                                                                {
   if (recoAlgo_ == 0)
     result.push_back(algoW_->reconstruct(*itdg));
   else if (recoAlgo_ == 1)
     result.push_back(algoF_->reconstruct(*itdg));
   else
     result.push_back(algoA_->reconstruct(*itdg));
   return true;
 }

References algoA_, algoF_, algoW_, recoAlgo_, ESRecHitSimAlgo::reconstruct(), ESRecHitAnalyticAlgo::reconstruct(), ESRecHitFitAlgo::reconstruct(), and mps_fire::result.

◆ set()

void ESRecHitWorker::set ( const edm::EventSetup & es )

overridevirtual

Implements ESRecHitWorkerBaseClass.

Definition at line 41 of file ESRecHitWorker.cc.

                                                 {
   esgain_ = es.getHandle(esgainToken_);
   const ESGain *gain = esgain_.product();
  
   esMIPToGeV_ = es.getHandle(esMIPToGeVToken_);
   const ESMIPToGeVConstant *mipToGeV = esMIPToGeV_.product();
  
   double ESGain = gain->getESGain();
   double ESMIPToGeV = (ESGain == 1) ? mipToGeV->getESValueLow() : mipToGeV->getESValueHigh();
  
   esWeights_ = es.getHandle(esWeightsToken_);
   const ESTimeSampleWeights *wgts = esWeights_.product();
  
   float w0 = wgts->getWeightForTS0();
   float w1 = wgts->getWeightForTS1();
   float w2 = wgts->getWeightForTS2();
  
   esPedestals_ = es.getHandle(esPedestalsToken_);
   const ESPedestals *peds = esPedestals_.product();
  
   esMIPs_ = es.getHandle(esMIPsToken_);
   const ESIntercalibConstants *mips = esMIPs_.product();
  
   esAngleCorrFactors_ = es.getHandle(esAngleCorrFactorsToken_);
   const ESAngleCorrectionFactors *ang = esAngleCorrFactors_.product();
  
   esChannelStatus_ = es.getHandle(esChannelStatusToken_);
   const ESChannelStatus *channelStatus = esChannelStatus_.product();
  
   esRatioCuts_ = es.getHandle(esRatioCutsToken_);
   const ESRecHitRatioCuts *ratioCuts = esRatioCuts_.product();
  
   if (recoAlgo_ == 0) {
     algoW_->setESGain(ESGain);
     algoW_->setMIPGeV(ESMIPToGeV);
     algoW_->setW0(w0);
     algoW_->setW1(w1);
     algoW_->setW2(w2);
     algoW_->setPedestals(peds);
     algoW_->setIntercalibConstants(mips);
     algoW_->setChannelStatus(channelStatus);
     algoW_->setRatioCuts(ratioCuts);
     algoW_->setAngleCorrectionFactors(ang);
   } else if (recoAlgo_ == 1) {
     algoF_->setESGain(ESGain);
     algoF_->setMIPGeV(ESMIPToGeV);
     algoF_->setPedestals(peds);
     algoF_->setIntercalibConstants(mips);
     algoF_->setChannelStatus(channelStatus);
     algoF_->setRatioCuts(ratioCuts);
     algoF_->setAngleCorrectionFactors(ang);
   } else {
     algoA_->setESGain(ESGain);
     algoA_->setMIPGeV(ESMIPToGeV);
     algoA_->setPedestals(peds);
     algoA_->setIntercalibConstants(mips);
     algoA_->setChannelStatus(channelStatus);
     algoA_->setRatioCuts(ratioCuts);
     algoA_->setAngleCorrectionFactors(ang);
   }
 }