#include <EcalUncalibRecHitWorkerRatio.h>

Inheritance diagram for EcalUncalibRecHitWorkerRatio:

Public Member Functions
	EcalUncalibRecHitWorkerRatio ()

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

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 ()

	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p)

	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p, edm::ConsumesCollector &c)

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

	~EcalUncalibRecHitWorkerRunOneDigiBase () override

Public Member Functions inherited from EcalUncalibRecHitWorkerBaseClass
	EcalUncalibRecHitWorkerBaseClass ()

	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &)

	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &, edm::ConsumesCollector &c)

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

double	pedRMSVec [3]

edm::ESHandle< EcalPedestals >	peds

double	pedVec [3]

edm::ESHandle< EcalSampleMask >	sampleMaskHand_

EcalUncalibRecHitRatioMethodAlgo< EBDataFrame >	uncalibMaker_barrel_

EcalUncalibRecHitRatioMethodAlgo< EEDataFrame >	uncalibMaker_endcap_

Detailed Description

Definition at line 25 of file EcalUncalibRecHitWorkerRatio.h.

Constructor & Destructor Documentation

◆ EcalUncalibRecHitWorkerRatio() [1/2]

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

Definition at line 15 of file EcalUncalibRecHitWorkerRatio.cc.

     : 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");
 }

References EBamplitudeFitParameters_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EEamplitudeFitParameters_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, and edm::ParameterSet::getParameter().

◆ EcalUncalibRecHitWorkerRatio() [2/2]

EcalUncalibRecHitWorkerRatio::EcalUncalibRecHitWorkerRatio ( )

inline

Definition at line 28 of file EcalUncalibRecHitWorkerRatio.h.

28 {};

◆ ~EcalUncalibRecHitWorkerRatio()

EcalUncalibRecHitWorkerRatio::~EcalUncalibRecHitWorkerRatio ( )

inlineoverride

Definition at line 29 of file EcalUncalibRecHitWorkerRatio.h.

29 {};

Member Function Documentation

◆ getAlgoDescription()

edm::ParameterSetDescription EcalUncalibRecHitWorkerRatio::getAlgoDescription ( )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 119 of file EcalUncalibRecHitWorkerRatio.cc.

                                                                             {
   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;
 }

References edm::ParameterSetDescription::addNode().

◆ run()

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.

                                                                                  {
   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;
 }

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(), EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, pedRMSVec, peds, pedVec, funct::pow(), edm::ESHandle< T >::product(), mps_fire::result, EcalPedestal::rms_x1, EcalPedestal::rms_x12, EcalPedestal::rms_x6, sampleMaskHand_, EcalUncalibratedRecHit::setAmplitude(), EcalUncalibratedRecHit::setJitter(), EcalUncalibratedRecHit::setJitterError(), mathSSE::sqrt(), uncalibMaker_barrel_, and uncalibMaker_endcap_.

◆ set()

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

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 33 of file EcalUncalibRecHitWorkerRatio.cc.

                                                               {
   // which of the samples need be used
   es.get<EcalSampleMaskRcd>().get(sampleMaskHand_);
  
   es.get<EcalGainRatiosRcd>().get(gains);
   es.get<EcalPedestalsRcd>().get(peds);
 }