#include <EcalUncalibRecHitWorkerRatio.h>

Inheritance diagram for EcalUncalibRecHitWorkerRatio:

Public Member Functions
	EcalUncalibRecHitWorkerRatio (const edm::ParameterSet &, edm::ConsumesCollector &c)

	EcalUncalibRecHitWorkerRatio ()

edm::ParameterSetDescription	getAlgoDescription () override

bool	run (const edm::Event &evt, const EcalDigiCollection::const_iterator &digi, EcalUncalibratedRecHitCollection &result) override

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

	~EcalUncalibRecHitWorkerRatio () override

Public Member Functions inherited from EcalUncalibRecHitWorkerRunOneDigiBase
	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p, edm::ConsumesCollector &c)

	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p)

	EcalUncalibRecHitWorkerRunOneDigiBase ()

void	run (const edm::Event &evt, const EcalDigiCollection &digis, EcalUncalibratedRecHitCollection &result) override

	~EcalUncalibRecHitWorkerRunOneDigiBase () override

Public Member Functions inherited from EcalUncalibRecHitWorkerBaseClass
	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &, edm::ConsumesCollector &c)

	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &)

	EcalUncalibRecHitWorkerBaseClass ()

virtual void	set (const edm::Event &evt)

virtual	~EcalUncalibRecHitWorkerBaseClass ()

Protected Attributes
std::vector< double >	EBamplitudeFitParameters_

double	EBtimeConstantTerm_

std::pair< double, double >	EBtimeFitLimits_

std::vector< double >	EBtimeFitParameters_

std::vector< double >	EEamplitudeFitParameters_

double	EEtimeConstantTerm_

std::pair< double, double >	EEtimeFitLimits_

std::vector< double >	EEtimeFitParameters_

double	gainRatios [3]

edm::ESHandle< EcalGainRatios >	gains

edm::ESGetToken < EcalGainRatios, EcalGainRatiosRcd >	gainsToken_

double	pedRMSVec [3]

edm::ESHandle< EcalPedestals >	peds

edm::ESGetToken< EcalPedestals, EcalPedestalsRcd >	pedsToken_

double	pedVec [3]

edm::ESHandle< EcalSampleMask >	sampleMaskHand_

edm::ESGetToken < EcalSampleMask, EcalSampleMaskRcd >	sampleMaskToken_

EcalUncalibRecHitRatioMethodAlgo < EBDataFrame >	uncalibMaker_barrel_

EcalUncalibRecHitRatioMethodAlgo < EEDataFrame >	uncalibMaker_endcap_

Detailed Description

Definition at line 29 of file EcalUncalibRecHitWorkerRatio.h.

Constructor & Destructor Documentation

EcalUncalibRecHitWorkerRatio::EcalUncalibRecHitWorkerRatio	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	c
	)

Definition at line 11 of file EcalUncalibRecHitWorkerRatio.cc.

References EBamplitudeFitParameters_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EEamplitudeFitParameters_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, edm::ConsumesCollector::esConsumes(), gainsToken_, edm::ParameterSet::getParameter(), pedsToken_, and sampleMaskToken_.

     : EcalUncalibRecHitWorkerRunOneDigiBase(ps, c) {
   EBtimeFitParameters_ = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
   EEtimeFitParameters_ = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
 
   EBamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
   EEamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
 
   EBtimeFitLimits_.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
   EBtimeFitLimits_.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
 
   EEtimeFitLimits_.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
   EEtimeFitLimits_.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
 
   EBtimeConstantTerm_ = ps.getParameter<double>("EBtimeConstantTerm");
   EEtimeConstantTerm_ = ps.getParameter<double>("EEtimeConstantTerm");
 
   pedsToken_ = c.esConsumes<EcalPedestals, EcalPedestalsRcd>();
   gainsToken_ = c.esConsumes<EcalGainRatios, EcalGainRatiosRcd>();
   sampleMaskToken_ = c.esConsumes<EcalSampleMask, EcalSampleMaskRcd>();
 }

EcalUncalibRecHitWorkerRatio::EcalUncalibRecHitWorkerRatio ( )

inline

Definition at line 32 of file EcalUncalibRecHitWorkerRatio.h.

32 {};

EcalUncalibRecHitWorkerRatio::~EcalUncalibRecHitWorkerRatio ( )

inlineoverride

Definition at line 33 of file EcalUncalibRecHitWorkerRatio.h.

33 {};

Member Function Documentation

edm::ParameterSetDescription EcalUncalibRecHitWorkerRatio::getAlgoDescription ( )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 119 of file EcalUncalibRecHitWorkerRatio.cc.

References edm::ParameterSetDescription::addNode().

                                                                             {
   edm::ParameterSetDescription psd;
   std::vector<double> dSet1 = {-2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277};
   std::vector<double> dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621};
 
   psd.addNode(edm::ParameterDescription<double>("EEtimeFitLimits_Upper", 1.4, true) and
               edm::ParameterDescription<double>("EEtimeConstantTerm", 0.18, true) and
               edm::ParameterDescription<double>("EBtimeFitLimits_Lower", 0.2, true) and
               edm::ParameterDescription<double>("EBtimeConstantTerm", 0.26, true) and
               edm::ParameterDescription<double>("EEtimeFitLimits_Lower", 0.2, true) and
               edm::ParameterDescription<std::vector<double>>("EEtimeFitParameters", dSet1, true) and
               edm::ParameterDescription<std::vector<double>>("EEamplitudeFitParameters", {1.89, 1.4}, true) and
               edm::ParameterDescription<double>("EBtimeFitLimits_Upper", 1.4, true) and
               edm::ParameterDescription<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652}, true) and
               edm::ParameterDescription<std::vector<double>>("EBtimeFitParameters", dSet2, true));
 
   return psd;
 }

bool EcalUncalibRecHitWorkerRatio::run	(	const edm::Event &	evt,
		const EcalDigiCollection::const_iterator &	digi,
		EcalUncalibratedRecHitCollection &	result
	)

overridevirtual

Implements EcalUncalibRecHitWorkerRunOneDigiBase.

Definition at line 41 of file EcalUncalibRecHitWorkerRatio.cc.

References EBamplitudeFitParameters_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EcalEndcap, EEamplitudeFitParameters_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, EcalUncalibRecHitRatioMethodAlgo< C >::fixMGPAslew(), EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), gainRatios, gains, EcalUncalibRecHitRatioMethodAlgo< C >::getCalculatedRecHit(), ecalpyutils::hashedIndex(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EcalUncalibRecHitRatioMethodAlgo< C >::makeRecHit(), pedRMSVec, peds, pedVec, funct::pow(), edm::ESHandle< class >::product(), edm::SortedCollection< T, SORT >::push_back(), sampleMaskHand_, EcalUncalibratedRecHit::setAmplitude(), EcalUncalibratedRecHit::setJitter(), EcalUncalibratedRecHit::setJitterError(), mathSSE::sqrt(), uncalibMaker_barrel_, and uncalibMaker_endcap_.

                                                                                  {
   DetId detid(itdg->id());
 
   const EcalSampleMask* sampleMask_ = sampleMaskHand_.product();
 
   const EcalPedestals::Item* aped = nullptr;
   const EcalMGPAGainRatio* aGain = nullptr;
 
   if (detid.subdetId() == EcalEndcap) {
     unsigned int hashedIndex = EEDetId(detid).hashedIndex();
     aped = &peds->endcap(hashedIndex);
     aGain = &gains->endcap(hashedIndex);
   } else {
     unsigned int hashedIndex = EBDetId(detid).hashedIndex();
     aped = &peds->barrel(hashedIndex);
     aGain = &gains->barrel(hashedIndex);
   }
 
   pedVec[0] = aped->mean_x12;
   pedVec[1] = aped->mean_x6;
   pedVec[2] = aped->mean_x1;
   pedRMSVec[0] = aped->rms_x12;
   pedRMSVec[1] = aped->rms_x6;
   pedRMSVec[2] = aped->rms_x1;
   gainRatios[0] = 1.;
   gainRatios[1] = aGain->gain12Over6();
   gainRatios[2] = aGain->gain6Over1() * aGain->gain12Over6();
 
   float clockToNsConstant = 25.;
   EcalUncalibratedRecHit uncalibRecHit;
 
   if (detid.subdetId() == EcalEndcap) {
     uncalibRecHit = uncalibMaker_endcap_.makeRecHit(*itdg,
                                                     *sampleMask_,
                                                     pedVec,
                                                     pedRMSVec,
                                                     gainRatios,
                                                     EEtimeFitParameters_,
                                                     EEamplitudeFitParameters_,
                                                     EEtimeFitLimits_);  //GF pass mask here
 
     EcalUncalibRecHitRatioMethodAlgo<EEDataFrame>::CalculatedRecHit crh = uncalibMaker_endcap_.getCalculatedRecHit();
     uncalibRecHit.setAmplitude(crh.amplitudeMax);
     uncalibRecHit.setJitter(crh.timeMax - 5);
     uncalibRecHit.setJitterError(
         std::sqrt(pow(crh.timeError, 2) + std::pow(EEtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
 
   } else {
     bool gainSwitch = uncalibMaker_barrel_.fixMGPAslew(*itdg);
 
     uncalibRecHit = uncalibMaker_barrel_.makeRecHit(*itdg,
                                                     *sampleMask_,
                                                     pedVec,
                                                     pedRMSVec,
                                                     gainRatios,
                                                     EBtimeFitParameters_,
                                                     EBamplitudeFitParameters_,
                                                     EBtimeFitLimits_);  //GF pass mask here
 
     EcalUncalibRecHitRatioMethodAlgo<EBDataFrame>::CalculatedRecHit crh = uncalibMaker_barrel_.getCalculatedRecHit();
 
     uncalibRecHit.setAmplitude(crh.amplitudeMax);
     if (gainSwitch) {
       // introduce additional 1ns shift
       uncalibRecHit.setJitter(crh.timeMax - 5 - 0.04);
     } else {
       uncalibRecHit.setJitter(crh.timeMax - 5);
     }
     uncalibRecHit.setJitterError(
         std::sqrt(pow(crh.timeError, 2) + std::pow(EBtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
   }
   result.push_back(uncalibRecHit);
 
   return true;
 }

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

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 33 of file EcalUncalibRecHitWorkerRatio.cc.

References gains, gainsToken_, edm::EventSetup::getHandle(), peds, pedsToken_, sampleMaskHand_, and sampleMaskToken_.

                                                               {
   // which of the samples need be used
   sampleMaskHand_ = es.getHandle(sampleMaskToken_);
 
   gains = es.getHandle(gainsToken_);
   peds = es.getHandle(pedsToken_);
 }