#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::ESHandle< EcalPedestals >	pedHandle

edm::ESHandle< EcalGainRatios >	pRatio

bool	useAlphaBetaArray_

Detailed Description

Definition at line 23 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

Constructor & Destructor Documentation

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

Definition at line 34 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 )
 {
         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::EcalUncalibRecHitWorkerFixedAlphaBetaFit ( )

inline

Definition at line 27 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

27 {};

EcalUncalibRecHitWorkerFixedAlphaBetaFit::~EcalUncalibRecHitWorkerFixedAlphaBetaFit ( )

inlineoverride

Definition at line 28 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.h.

References mps_fire::result, and findQualityFiles::run.

28 {};

Member Function Documentation

edm::ParameterSetDescription EcalUncalibRecHitWorkerFixedAlphaBetaFit::getAlgoDescription ( )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 193 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References edm::ParameterSetDescription::addNode(), and DEFINE_EDM_PLUGIN.

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

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

overridevirtual

Implements EcalUncalibRecHitWorkerRunOneDigiBase.

Definition at line 107 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(), EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, pedHandle, pRatio, edm::SortedCollection< T, SORT >::push_back(), 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;
 }

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

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 58 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

References edm::EventSetup::get(), LogDebug, pedHandle, and pRatio.

 {
         // Gain Ratios
         LogDebug("EcalUncalibRecHitDebug") << "fetching gainRatios....";
         es.get<EcalGainRatiosRcd>().get(pRatio);
         LogDebug("EcalUncalibRecHitDebug") << "done." ;
 
         // fetch the pedestals from the cond DB via EventSetup
         LogDebug("EcalUncalibRecHitDebug") << "fetching pedestals....";
         es.get<EcalPedestalsRcd>().get( pedHandle );
         LogDebug("EcalUncalibRecHitDebug") << "done." ;
 }

bool EcalUncalibRecHitWorkerFixedAlphaBetaFit::setAlphaBeta ( )

private

Definition at line 73 of file EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc.

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

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