#include <EcalUncalibRecHitMultiFitAlgo.h>

Public Member Functions
void	disableErrorCalculation ()

	EcalUncalibRecHitMultiFitAlgo ()

EcalUncalibratedRecHit	makeRecHit (const EcalDataFrame &dataFrame, const EcalPedestals::Item aped, const EcalMGPAGainRatio aGain, const SampleMatrix &noisecor, const FullSampleVector &fullpulse, const FullSampleMatrix &fullpulsecov, const BXVector &activeBX)
	compute rechits More...

void	setDoPrefit (bool b)

void	setGainSwitchUseMaxSample (bool b)

void	setPrefitMaxChiSq (double x)

	~EcalUncalibRecHitMultiFitAlgo ()

Private Attributes
bool	_computeErrors

bool	_doPrefit

bool	_gainSwitchUseMaxSample

double	_prefitMaxChiSq

PulseChiSqSNNLS	_pulsefunc

PulseChiSqSNNLS	_pulsefuncSingle

BXVector	_singlebx

Detailed Description

Amplitude reconstucted by the multi-template fit

Author: J.Bendavid, E.Di Marco

Definition at line 21 of file EcalUncalibRecHitMultiFitAlgo.h.

Constructor & Destructor Documentation

EcalUncalibRecHitMultiFitAlgo::EcalUncalibRecHitMultiFitAlgo ( )

Definition at line 8 of file EcalUncalibRecHitMultiFitAlgo.cc.

References _pulsefuncSingle, _singlebx, PulseChiSqSNNLS::disableErrorCalculation(), BXVector< T >::resize(), PulseChiSqSNNLS::setMaxIters(), and PulseChiSqSNNLS::setMaxIterWarnings().

                                                              : 
   _computeErrors(true),
   _doPrefit(false),
   _prefitMaxChiSq(1.0),
   _gainSwitchUseMaxSample(false){
     
   _singlebx.resize(1);
   _singlebx << 0;
   
   _pulsefuncSingle.disableErrorCalculation();
   _pulsefuncSingle.setMaxIters(1);
   _pulsefuncSingle.setMaxIterWarnings(false);
     
 }

EcalUncalibRecHitMultiFitAlgo::~EcalUncalibRecHitMultiFitAlgo ( )

inline

Definition at line 27 of file EcalUncalibRecHitMultiFitAlgo.h.

27 { };

Member Function Documentation

void EcalUncalibRecHitMultiFitAlgo::disableErrorCalculation ( )

inline

Definition at line 30 of file EcalUncalibRecHitMultiFitAlgo.h.

References _computeErrors.

Referenced by EcalUncalibRecHitWorkerMultiFit::set().

30 { _computeErrors = false; }

EcalUncalibRecHitMultiFitAlgo::_computeErrors

bool _computeErrors

Definition: EcalUncalibRecHitMultiFitAlgo.h:37

EcalUncalibratedRecHit EcalUncalibRecHitMultiFitAlgo::makeRecHit	(	const EcalDataFrame &	dataFrame,
		const EcalPedestals::Item *	aped,
		const EcalMGPAGainRatio *	aGain,
		const SampleMatrix &	noisecor,
		const FullSampleVector &	fullpulse,
		const FullSampleMatrix &	fullpulsecov,
		const BXVector &	activeBX
	)

compute rechits

Definition at line 24 of file EcalUncalibRecHitMultiFitAlgo.cc.

References _computeErrors, _doPrefit, _gainSwitchUseMaxSample, _prefitMaxChiSq, _pulsefunc, _pulsefuncSingle, _singlebx, EcalMGPASample::adc(), PulseChiSqSNNLS::BXs(), PulseChiSqSNNLS::ChiSq(), PulseChiSqSNNLS::disableErrorCalculation(), PulseChiSqSNNLS::DoFit(), PulseChiSqSNNLS::Errors(), flags, EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), ecalMGPA::gainId(), EcalMGPASample::gainId(), EcalDataFrame::id(), bookConverter::max, EcalDataFrame::MAXSAMPLES, EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, EcalCondDBWriter_cfi::pedestal, EcalPedestal::rms_x1, EcalPedestal::rms_x12, EcalPedestal::rms_x6, compare_using_db::sample, EcalDataFrame::sample(), EcalUncalibratedRecHit::setAmplitudeError(), mps_update::status, and PulseChiSqSNNLS::X().

Referenced by EcalUncalibRecHitWorkerMultiFit::run().

                                                                                                                                                                                                                                                                                                  {
 
   uint32_t flags = 0;
   
   const unsigned int nsample = EcalDataFrame::MAXSAMPLES;
   
   double maxamplitude = -std::numeric_limits<double>::max();
   const unsigned int iSampleMax = 5;  
   const unsigned int iFullPulseMax = 9;
 
   double pedval = 0.;
   double pedrms = 0.;
   int iGainSwitch = 0;
   
   SampleVector amplitudes;
   for(unsigned int iSample = 0; iSample < nsample; iSample++) {
     
     const EcalMGPASample &sample = dataFrame.sample(iSample);
     
     double amplitude = 0.;
     int gainId = sample.gainId();
    
     double pedestal = 0.;
     double pederr = 0.;
     double gainratio = 1.;
         
     if (gainId==0 || gainId==3) {
       pedestal = aped->mean_x1;
       pederr = aped->rms_x1;
       gainratio = aGain->gain6Over1()*aGain->gain12Over6();
     }
     else if (gainId==1) {
       pedestal = aped->mean_x12;
       pederr = aped->rms_x12;
       gainratio = 1.;
     }
     else if (gainId==2) {
       pedestal = aped->mean_x6;
       pederr = aped->rms_x6;
       gainratio = aGain->gain12Over6();
     }
     if ( (gainId != 1) && (iSample==4 || iSample==5 || iSample==6) ) iGainSwitch = 1;
 
     amplitude = ((double)(sample.adc()) - pedestal) * gainratio;
     
     if (gainId == 0) {
       //saturation
       amplitude = (4095. - pedestal) * gainratio;
     }
         
     amplitudes[iSample] = amplitude;
     
     if (iSample==iSampleMax) {
       maxamplitude = amplitude;
       pedval = pedestal;
       pedrms = pederr*gainratio;
     }    
         
   }
   
   double amplitude, amperr, chisq;
   bool status = false;
 
   // for legacy re-reco of 2016 data, max-sample can be used for EB w/o impact on data/MC consistency
   // in case of gain switch, just use max-sample
   if(iGainSwitch && _gainSwitchUseMaxSample) {
     double maxpulseamplitude = maxamplitude / fullpulse[iFullPulseMax];
     EcalUncalibratedRecHit rh( dataFrame.id(), maxpulseamplitude, pedval, 0., 0., flags );
     rh.setAmplitudeError(0.);
     for (unsigned int ipulse=0; ipulse<_pulsefunc.BXs().rows(); ++ipulse) {
       int bx = _pulsefunc.BXs().coeff(ipulse);
       if (bx!=0) {
         rh.setOutOfTimeAmplitude(bx+5, 0.0);
       }
     }
     return rh;
   }
     
   //optimized one-pulse fit for hlt
   bool usePrefit = false;
   if (_doPrefit) {
     status = _pulsefuncSingle.DoFit(amplitudes,noisecor,pedrms,_singlebx,fullpulse,fullpulsecov);
     amplitude = status ? _pulsefuncSingle.X()[0] : 0.;
     amperr = status ? _pulsefuncSingle.Errors()[0] : 0.;
     chisq = _pulsefuncSingle.ChiSq();
     
     if (chisq < _prefitMaxChiSq) {
       usePrefit = true;
     }
   }
   
   if (!usePrefit) {
   
     if(!_computeErrors) _pulsefunc.disableErrorCalculation();
     status = _pulsefunc.DoFit(amplitudes,noisecor,pedrms,activeBX,fullpulse,fullpulsecov);
     chisq = _pulsefunc.ChiSq();
     
     if (!status) {
       edm::LogWarning("EcalUncalibRecHitMultiFitAlgo::makeRecHit") << "Failed Fit" << std::endl;
     }
 
     unsigned int ipulseintime = 0;
     for (unsigned int ipulse=0; ipulse<_pulsefunc.BXs().rows(); ++ipulse) {
       if (_pulsefunc.BXs().coeff(ipulse)==0) {
         ipulseintime = ipulse;
         break;
       }
     }
     
     amplitude = status ? _pulsefunc.X()[ipulseintime] : 0.;
     amperr = status ? _pulsefunc.Errors()[ipulseintime] : 0.;
   
   }
   
   double jitter = 0.;
   
   //printf("status = %i\n",int(status));
   //printf("amplitude = %5f +- %5f, chisq = %5f\n",amplitude,amperr,chisq);
   
   EcalUncalibratedRecHit rh( dataFrame.id(), amplitude , pedval, jitter, chisq, flags );
   rh.setAmplitudeError(amperr);
   
   if (!usePrefit) {
     for (unsigned int ipulse=0; ipulse<_pulsefunc.BXs().rows(); ++ipulse) {
       int bx = _pulsefunc.BXs().coeff(ipulse);
       if (bx!=0) {
         rh.setOutOfTimeAmplitude(bx+5, status ? _pulsefunc.X().coeff(ipulse) : 0.);
       }
     }
   }
   
   return rh;
 }