#include <EcalUncalibRecHitWorkerFixedAlphaBetaFit.h>

Inheritance diagram for EcalUncalibRecHitWorkerFixedAlphaBetaFit:

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

	EcalUncalibRecHitWorkerFixedAlphaBetaFit ()

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

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

Private Member Functions
bool	setAlphaBeta ()

Private Attributes
EcalUncalibRecHitFixedAlphaBetaAlgo< EBDataFrame >	algoEB_

EcalUncalibRecHitFixedAlphaBetaAlgo< EEDataFrame >	algoEE_

std::string	alphabetaFilename_

std::vector< std::vector< std::pair< double, double > > >	alphaBetaValues_

double	alphaEB_

double	alphaEE_

double	AmplThrEB_

double	AmplThrEE_

double	betaEB_

double	betaEE_

edm::ESGetToken< EcalPedestals, EcalPedestalsRcd >	pedestalsToken_

edm::ESHandle< EcalPedestals >	pedHandle

edm::ESHandle< EcalGainRatios >	pRatio

edm::ESGetToken< EcalGainRatios, EcalGainRatiosRcd >	ratiosToken_

bool	useAlphaBetaArray_

Detailed Description

Definition at line 25 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

Constructor & Destructor Documentation

◆ EcalUncalibRecHitWorkerFixedAlphaBetaFit() [1/2]

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

Definition at line 29 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References algoEB_, algoEE_, alphabetaFilename_, alphaEB_, alphaEE_, betaEB_, betaEE_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), setAlphaBeta(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::SetDynamicPedestal(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::SetMinAmpl(), AlCaHLTBitMon_QueryRunRegistry::string, and useAlphaBetaArray_.

     : EcalUncalibRecHitWorkerRunOneDigiBase(ps, c),
       ratiosToken_(c.esConsumes<EcalGainRatios, EcalGainRatiosRcd>()),
       pedestalsToken_(c.esConsumes<EcalPedestals, EcalPedestalsRcd>()) {
   alphaEB_ = ps.getParameter<double>("alphaEB");
   betaEB_ = ps.getParameter<double>("betaEB");
   alphaEE_ = ps.getParameter<double>("alphaEE");
   betaEE_ = ps.getParameter<double>("betaEE");
 
   alphabetaFilename_ = ps.getUntrackedParameter<std::string>("AlphaBetaFilename");
   useAlphaBetaArray_ = setAlphaBeta();  // set crystalwise values of alpha and beta
   if (!useAlphaBetaArray_) {
     edm::LogInfo("EcalUncalibRecHitError") << " No alfa-beta file found. Using the deafult values.";
   }
 
   algoEB_.SetMinAmpl(ps.getParameter<double>("MinAmplBarrel"));
   algoEE_.SetMinAmpl(ps.getParameter<double>("MinAmplEndcap"));
 
   bool dyn_pede = ps.getParameter<bool>("UseDynamicPedestal");
   algoEB_.SetDynamicPedestal(dyn_pede);
   algoEE_.SetDynamicPedestal(dyn_pede);
 }

◆ EcalUncalibRecHitWorkerFixedAlphaBetaFit() [2/2]

EcalUncalibRecHitWorkerFixedAlphaBetaFit::EcalUncalibRecHitWorkerFixedAlphaBetaFit ( )

inline

Definition at line 28 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

28 {};

◆ ~EcalUncalibRecHitWorkerFixedAlphaBetaFit()

EcalUncalibRecHitWorkerFixedAlphaBetaFit::~EcalUncalibRecHitWorkerFixedAlphaBetaFit ( )

inlineoverride

Definition at line 29 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

29 {};

Member Function Documentation

◆ getAlgoDescription()

edm::ParameterSetDescription EcalUncalibRecHitWorkerFixedAlphaBetaFit::getAlgoDescription ( )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 179 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References edm::ParameterSetDescription::addNode().

                                                                                         {
   edm::ParameterSetDescription psd;
 
   psd.addNode(edm::ParameterDescription<double>("alphaEB", 1.138, true) and
               edm::ParameterDescription<double>("alphaEE", 1.89, true) and
               edm::ParameterDescription<std::string>("AlphaBetaFilename", "NOFILE", false) and
               edm::ParameterDescription<double>("betaEB", 1.655, true) and
               edm::ParameterDescription<double>("MinAmplEndcap", 14.0, true) and
               edm::ParameterDescription<double>("MinAmplBarrel", 8.0, true) and
               edm::ParameterDescription<double>("betaEE", 1.4, true) and
               edm::ParameterDescription<bool>("UseDynamicPedestal", true, true));
 
   return psd;
 }

◆ run()

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

overridevirtual

Implements EcalUncalibRecHitWorkerRunOneDigiBase.

Definition at line 96 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References a, algoEB_, algoEE_, alphaBetaValues_, alphaEB_, alphaEE_, b, betaEB_, betaEE_, EcalBarrel, EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), EBDetId::ic(), EBDetId::ism(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::makeRecHit(), pedHandle, pRatio, mps_fire::result, EcalUncalibRecHitFixedAlphaBetaAlgo< C >::SetAlphaBeta(), and useAlphaBetaArray_.

                                                                                              {
   const EcalGainRatioMap& gainMap = pRatio.product()->getMap();  // map of gain ratios
   EcalGainRatioMap::const_iterator gainIter;                     // gain iterator
   EcalMGPAGainRatio aGain;                                       // gain object for a single xtal
 
   const EcalPedestalsMap& pedMap = pedHandle.product()->getMap();  // map of pedestals
   EcalPedestalsMapIterator pedIter;                                // pedestal iterator
   EcalPedestals::Item aped;                                        // pedestal object for a single xtal
 
   DetId detid(itdg->id());
 
   // find pedestals for this channel
   //LogDebug("EcalUncalibRecHitDebug") << "looking up pedestal for crystal: " << itdg->id();
   pedIter = pedMap.find(itdg->id());
   if (pedIter != pedMap.end()) {
     aped = (*pedIter);
   } else {
     edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << "error!! could not find pedestals for channel: ";
     if (detid.subdetId() == EcalBarrel) {
       edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << EBDetId(detid);
     } else {
       edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << EEDetId(detid);
     }
     edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << "\n  no uncalib rechit will be made for this digi!";
     return false;
   }
   double pedVec[3];
   pedVec[0] = aped.mean_x12;
   pedVec[1] = aped.mean_x6;
   pedVec[2] = aped.mean_x1;
 
   // find gain ratios
   //LogDebug("EcalUncalibRecHitDebug") << "looking up gainRatios for crystal: " << EBDetId(itdg->id()) ; // FIXME!!!!!!!!
   gainIter = gainMap.find(itdg->id());
   if (gainIter != gainMap.end()) {
     aGain = (*gainIter);
   } else {
     edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << "error!! could not find gain ratios for channel: ";
     if (detid.subdetId() == EcalBarrel) {
       edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << EBDetId(detid);
     } else {
       edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << EEDetId(detid);
     }
     edm::LogError("EcalUncalibRecHitWorkerFixedAlphaBetaFit") << "\n  no uncalib rechit will be made for this digi!";
     return false;
   }
   double gainRatios[3];
   gainRatios[0] = 1.;
   gainRatios[1] = aGain.gain12Over6();
   gainRatios[2] = aGain.gain6Over1() * aGain.gain12Over6();
 
   if (detid.subdetId() == EcalBarrel) {
     // Define Alpha and Beta either by stored values or by default universal values
     EBDetId ebDetId(detid);
     double a, b;
     if (useAlphaBetaArray_) {
       if (!alphaBetaValues_[ebDetId.ism() - 1].empty()) {
         a = alphaBetaValues_[ebDetId.ism() - 1][ebDetId.ic() - 1].first;
         b = alphaBetaValues_[ebDetId.ism() - 1][ebDetId.ic() - 1].second;
         if ((a == -1) && (b == -1)) {
           a = alphaEB_;
           b = betaEB_;
         }
       } else {
         a = alphaEB_;
         b = betaEB_;
       }
     } else {
       a = alphaEB_;
       b = betaEB_;
     }
     algoEB_.SetAlphaBeta(a, b);
     result.push_back(algoEB_.makeRecHit(*itdg, pedVec, gainRatios, nullptr, nullptr));
   } else {
     //FIX ME load in a and b from a file
     algoEE_.SetAlphaBeta(alphaEE_, betaEE_);
     result.push_back(algoEE_.makeRecHit(*itdg, pedVec, gainRatios, nullptr, nullptr));
   }
   return true;
 }

◆ set()

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

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 53 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References edm::EventSetup::getHandle(), LogDebug, pedestalsToken_, pedHandle, pRatio, and ratiosToken_.

                                                                           {
   // Gain Ratios
   LogDebug("EcalUncalibRecHitDebug") << "fetching gainRatios....";
   pRatio = es.getHandle(ratiosToken_);
   LogDebug("EcalUncalibRecHitDebug") << "done.";
 
   // fetch the pedestals from the cond DB via EventSetup
   LogDebug("EcalUncalibRecHitDebug") << "fetching pedestals....";
   pedHandle = es.getHandle(pedestalsToken_);
   LogDebug("EcalUncalibRecHitDebug") << "done.";
 }

◆ setAlphaBeta()

bool EcalUncalibRecHitWorkerFixedAlphaBetaFit::setAlphaBeta ( )

private

Definition at line 66 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References a, alphabetaFilename_, alphaBetaValues_, b, edmScanValgrind::buffer, relativeConstraints::empty, geometryDiff::file, AlCaHLTBitMon_ParallelJobs::p, and runTheMatrix::ret.

Referenced by EcalUncalibRecHitWorkerFixedAlphaBetaFit().

                                                             {
   std::ifstream file(alphabetaFilename_.c_str());
   if (!file.is_open())
     return false;
 
   alphaBetaValues_.resize(36);
 
   char buffer[100];
   int sm, cry, ret;
   float a, b;
   std::pair<double, double> p(-1, -1);
 
   while (!file.getline(buffer, 100).eof()) {
     ret = sscanf(buffer, "%d %d %f %f", &sm, &cry, &a, &b);
     if ((ret != 4) || (sm <= 0) || (sm > 36) || (cry <= 0) || (cry > 1700)) {
       // send warning
       continue;
     }
 
     if (alphaBetaValues_[sm - 1].empty()) {
       alphaBetaValues_[sm - 1].resize(1700, p);
     }
     alphaBetaValues_[sm - 1][cry - 1].first = a;
     alphaBetaValues_[sm - 1][cry - 1].second = b;
   }
 
   file.close();
   return true;
 }