EcalUncalibRecHitMultiFitAlgo Class Reference

#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...
	~EcalUncalibRecHitMultiFitAlgo ()

Private Attributes
bool	_computeErrors
PulseChiSqSNNLS	_pulsefunc

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.

                                                             : 
  _computeErrors(true) { 
}

EcalUncalibRecHitMultiFitAlgo::~EcalUncalibRecHitMultiFitAlgo ( )

inline

Definition at line 27 of file EcalUncalibRecHitMultiFitAlgo.h.

{ };

Member Function Documentation

void EcalUncalibRecHitMultiFitAlgo::disableErrorCalculation ( )

inline

Definition at line 29 of file EcalUncalibRecHitMultiFitAlgo.h.

References _computeErrors.

Referenced by EcalUncalibRecHitWorkerMultiFit::set().

{ _computeErrors = false; }

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 13 of file EcalUncalibRecHitMultiFitAlgo.cc.

References _computeErrors, _pulsefunc, EcalMGPASample::adc(), PulseChiSqSNNLS::BXs(), PulseChiSqSNNLS::ChiSq(), PulseChiSqSNNLS::disableErrorCalculation(), PulseChiSqSNNLS::DoFit(), PulseChiSqSNNLS::Errors(), flags, EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), ecalMGPA::gainId(), EcalMGPASample::gainId(), EcalDataFrame::id(), 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(), ntuplemaker::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();
  
  double pedval = 0.;
  double pedrms = 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();
    }

    amplitude = ((double)(sample.adc()) - pedestal) * gainratio;
    
    if (gainId == 0) {
      //saturation
      amplitude = (4095. - pedestal) * gainratio;
    }
        
    amplitudes[iSample] = amplitude;
    
    if (amplitude>maxamplitude) {
    //if (iSample==5) {
      maxamplitude = amplitude;
      pedval = pedestal;
      pedrms = pederr*gainratio;
    }    
        
  }
  
  if(!_computeErrors) _pulsefunc.disableErrorCalculation();
  bool status = _pulsefunc.DoFit(amplitudes,noisecor,pedrms,activeBX,fullpulse,fullpulsecov);
  double 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;
    }
  }
  
  double amplitude = status ? _pulsefunc.X()[ipulseintime] : 0.;
  double 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);
  
  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;
}

Member Data Documentation

bool EcalUncalibRecHitMultiFitAlgo::_computeErrors

private

Definition at line 33 of file EcalUncalibRecHitMultiFitAlgo.h.

Referenced by disableErrorCalculation(), and makeRecHit().

PulseChiSqSNNLS EcalUncalibRecHitMultiFitAlgo::_pulsefunc

private

Definition at line 32 of file EcalUncalibRecHitMultiFitAlgo.h.

Referenced by makeRecHit().