#include <EcalUncalibRecHitWorkerGlobal.h>

Inheritance diagram for EcalUncalibRecHitWorkerGlobal:

Public Member Functions
	EcalUncalibRecHitWorkerGlobal (const edm::ParameterSet &, edm::ConsumesCollector &c)

	EcalUncalibRecHitWorkerGlobal (const edm::ParameterSet &)

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

void	set (const edm::EventSetup &es)

virtual	~EcalUncalibRecHitWorkerGlobal ()

Public Member Functions inherited from EcalUncalibRecHitWorkerBaseClass
	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &, edm::ConsumesCollector &c)

	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &)

virtual	~EcalUncalibRecHitWorkerBaseClass ()

Protected Member Functions
template<class C >
int	isSaturated (const C &digi)

double	timeCorrection (float ampli, const std::vector< float > &amplitudeBins, const std::vector< float > &shiftBins)

Protected Attributes
double	amplitudeThreshEB_

double	amplitudeThreshEE_

const EcalWeightSet::EcalChi2WeightMatrix *	chi2mat [2]

double	chi2ThreshEB_

double	chi2ThreshEE_

std::vector< double >	EBamplitudeFitParameters_

std::vector< double >	EBchi2Parameters_

std::vector< double >	ebPulseShape_

double	ebSpikeThresh_

double	EBtimeConstantTerm_

std::pair< double, double >	EBtimeFitLimits_

std::vector< double >	EBtimeFitParameters_

double	EBtimeNconst_

std::vector< double >	EEamplitudeFitParameters_

std::vector< double >	EEchi2Parameters_

std::vector< double >	eePulseShape_

double	EEtimeConstantTerm_

std::pair< double, double >	EEtimeFitLimits_

std::vector< double >	EEtimeFitParameters_

double	EEtimeNconst_

double	gainRatios [3]

edm::ESHandle< EcalGainRatios >	gains

edm::ESHandle < EcalWeightXtalGroups >	grps

edm::ESHandle < EcalTimeCalibConstants >	itime

bool	kPoorRecoFlagEB_

bool	kPoorRecoFlagEE_

EcalUncalibRecHitLeadingEdgeAlgo < EBDataFrame >	leadingEdgeMethod_barrel_

EcalUncalibRecHitLeadingEdgeAlgo < EEDataFrame >	leadingEdgeMethod_endcap_

edm::ESHandle < EcalTimeOffsetConstant >	offtime

double	outOfTimeThreshG12mEB_

double	outOfTimeThreshG12mEE_

double	outOfTimeThreshG12pEB_

double	outOfTimeThreshG12pEE_

double	outOfTimeThreshG61mEB_

double	outOfTimeThreshG61mEE_

double	outOfTimeThreshG61pEB_

double	outOfTimeThreshG61pEE_

double	pedRMSVec [3]

edm::ESHandle< EcalPedestals >	peds

double	pedVec [3]

EcalUncalibRecHitRatioMethodAlgo < EBDataFrame >	ratioMethod_barrel_

EcalUncalibRecHitRatioMethodAlgo < EEDataFrame >	ratioMethod_endcap_

edm::ESHandle< EcalSampleMask >	sampleMaskHand_

const EBShape	testbeamEBShape

const EEShape	testbeamEEShape

edm::ESHandle < EcalTimeBiasCorrections >	timeCorrBias_

const EcalWeightSet::EcalWeightMatrix *	weights [2]

EcalUncalibRecHitRecWeightsAlgo < EBDataFrame >	weightsMethod_barrel_

EcalUncalibRecHitRecWeightsAlgo < EEDataFrame >	weightsMethod_endcap_

edm::ESHandle< EcalTBWeights >	wgts

Detailed Description

Definition at line 36 of file EcalUncalibRecHitWorkerGlobal.h.

Constructor & Destructor Documentation

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

Definition at line 17 of file EcalUncalibRecHitWorkerGlobal.cc.

References amplitudeThreshEB_, amplitudeThreshEE_, chi2ThreshEB_, chi2ThreshEE_, EBamplitudeFitParameters_, EBchi2Parameters_, ebPulseShape_, ebSpikeThresh_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EBtimeNconst_, EEamplitudeFitParameters_, EEchi2Parameters_, eePulseShape_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, EEtimeNconst_, edm::ParameterSet::getParameter(), kPoorRecoFlagEB_, kPoorRecoFlagEE_, outOfTimeThreshG12mEB_, outOfTimeThreshG12mEE_, outOfTimeThreshG12pEB_, outOfTimeThreshG12pEE_, outOfTimeThreshG61mEB_, outOfTimeThreshG61mEE_, outOfTimeThreshG61pEB_, and outOfTimeThreshG61pEE_.

                                                                                                              :
   EcalUncalibRecHitWorkerBaseClass(ps,c)
 {
         // ratio method parameters
         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");
         EBtimeNconst_=ps.getParameter<double>("EBtimeNconst");
         EEtimeConstantTerm_=ps.getParameter<double>("EEtimeConstantTerm");
         EEtimeNconst_=ps.getParameter<double>("EEtimeNconst");
         outOfTimeThreshG12pEB_ = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
         outOfTimeThreshG12mEB_ = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
         outOfTimeThreshG61pEB_ = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
         outOfTimeThreshG61mEB_ = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
         outOfTimeThreshG12pEE_ = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
         outOfTimeThreshG12mEE_ = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
         outOfTimeThreshG61pEE_ = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
         outOfTimeThreshG61mEE_ = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
         amplitudeThreshEB_ = ps.getParameter<double>("amplitudeThresholdEB");
         amplitudeThreshEE_ = ps.getParameter<double>("amplitudeThresholdEE");
 
     // spike threshold
         ebSpikeThresh_ = ps.getParameter<double>("ebSpikeThreshold");
         // leading edge parameters
         ebPulseShape_ = ps.getParameter<std::vector<double> >("ebPulseShape");
         eePulseShape_ = ps.getParameter<std::vector<double> >("eePulseShape");
     // chi2 parameters
         kPoorRecoFlagEB_ = ps.getParameter<bool>("kPoorRecoFlagEB");
     kPoorRecoFlagEE_ = ps.getParameter<bool>("kPoorRecoFlagEE");;
         chi2ThreshEB_=ps.getParameter<double>("chi2ThreshEB_");
     chi2ThreshEE_=ps.getParameter<double>("chi2ThreshEE_");
         EBchi2Parameters_ = ps.getParameter<std::vector<double> >("EBchi2Parameters");
         EEchi2Parameters_ = ps.getParameter<std::vector<double> >("EEchi2Parameters");
 }

EcalUncalibRecHitWorkerGlobal::EcalUncalibRecHitWorkerGlobal ( const edm::ParameterSet & ps )

Definition at line 60 of file EcalUncalibRecHitWorkerGlobal.cc.

References amplitudeThreshEB_, amplitudeThreshEE_, chi2ThreshEB_, chi2ThreshEE_, EBamplitudeFitParameters_, EBchi2Parameters_, ebPulseShape_, ebSpikeThresh_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EBtimeNconst_, EEamplitudeFitParameters_, EEchi2Parameters_, eePulseShape_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, EEtimeNconst_, edm::ParameterSet::getParameter(), kPoorRecoFlagEB_, kPoorRecoFlagEE_, outOfTimeThreshG12mEB_, outOfTimeThreshG12mEE_, outOfTimeThreshG12pEB_, outOfTimeThreshG12pEE_, outOfTimeThreshG61mEB_, outOfTimeThreshG61mEE_, outOfTimeThreshG61pEB_, and outOfTimeThreshG61pEE_.

                                                                                      :
   EcalUncalibRecHitWorkerBaseClass(ps)
 {
         // ratio method parameters
         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");
         EBtimeNconst_=ps.getParameter<double>("EBtimeNconst");
         EEtimeConstantTerm_=ps.getParameter<double>("EEtimeConstantTerm");
         EEtimeNconst_=ps.getParameter<double>("EEtimeNconst");
         outOfTimeThreshG12pEB_ = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
         outOfTimeThreshG12mEB_ = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
         outOfTimeThreshG61pEB_ = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
         outOfTimeThreshG61mEB_ = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
         outOfTimeThreshG12pEE_ = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
         outOfTimeThreshG12mEE_ = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
         outOfTimeThreshG61pEE_ = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
         outOfTimeThreshG61mEE_ = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
         amplitudeThreshEB_ = ps.getParameter<double>("amplitudeThresholdEB");
         amplitudeThreshEE_ = ps.getParameter<double>("amplitudeThresholdEE");
 
     // spike threshold
         ebSpikeThresh_ = ps.getParameter<double>("ebSpikeThreshold");
         // leading edge parameters
         ebPulseShape_ = ps.getParameter<std::vector<double> >("ebPulseShape");
         eePulseShape_ = ps.getParameter<std::vector<double> >("eePulseShape");
     // chi2 parameters
         kPoorRecoFlagEB_ = ps.getParameter<bool>("kPoorRecoFlagEB");
     kPoorRecoFlagEE_ = ps.getParameter<bool>("kPoorRecoFlagEE");;
         chi2ThreshEB_=ps.getParameter<double>("chi2ThreshEB_");
     chi2ThreshEE_=ps.getParameter<double>("chi2ThreshEE_");
         EBchi2Parameters_ = ps.getParameter<std::vector<double> >("EBchi2Parameters");
         EEchi2Parameters_ = ps.getParameter<std::vector<double> >("EEchi2Parameters");
 }

virtual EcalUncalibRecHitWorkerGlobal::~EcalUncalibRecHitWorkerGlobal ( )

inlinevirtual

Definition at line 41 of file EcalUncalibRecHitWorkerGlobal.h.

41 {};

Member Function Documentation

template<class C >

int EcalUncalibRecHitWorkerGlobal::isSaturated ( const C & digi )

protected

Definition at line 140 of file EcalUncalibRecHitWorkerGlobal.cc.

References i, and j.

 {
         //bool saturated_ = 0;
         int cnt;
         for (int j = 0; j < C::MAXSAMPLES - 5; ++j) {
                 cnt = 0;
                 for (int i = j; i < (j + 5) && i < C::MAXSAMPLES; ++i) {
                         if ( dataFrame.sample(i).gainId() == 0 ) ++cnt;
                 }
                 if ( cnt == 5 ) return j-1 ; // the last unsaturated sample
         }
         return -1; // no saturation found
 }

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

virtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 220 of file EcalUncalibRecHitWorkerGlobal.cc.

 {
         DetId detid(itdg->id());
 
     const EcalSampleMask  *sampleMask_ = sampleMaskHand_.product();        
 
         // intelligence for recHit computation
         EcalUncalibratedRecHit uncalibRecHit;
         
         
         const EcalPedestals::Item * aped = 0;
         const EcalMGPAGainRatio * aGain = 0;
         const EcalXtalGroupId * gid = 0;
     float offsetTime = 0;
 
         if (detid.subdetId()==EcalEndcap) {
                 unsigned int hashedIndex = EEDetId(detid).hashedIndex();
                 aped  = &peds->endcap(hashedIndex);
                 aGain = &gains->endcap(hashedIndex);
                 gid   = &grps->endcap(hashedIndex);
         offsetTime = offtime->getEEValue();
         } else {
                 unsigned int hashedIndex = EBDetId(detid).hashedIndex();
                 aped  = &peds->barrel(hashedIndex);
                 aGain = &gains->barrel(hashedIndex);
                 gid   = &grps->barrel(hashedIndex);
         offsetTime = offtime->getEBValue();
         }
 
         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();
 
     // compute the right bin of the pulse shape using time calibration constants
     EcalTimeCalibConstantMap::const_iterator it = itime->find( detid );
     EcalTimeCalibConstant itimeconst = 0;
     if( it != itime->end() ) {
           itimeconst = (*it);
     } else {
           edm::LogError("EcalRecHitError") << "No time intercalib const found for xtal "
           << detid.rawId()
           << "! something wrong with EcalTimeCalibConstants in your DB? ";
     }
 
 
         // === amplitude computation ===
         int leadingSample = -1;
         if (detid.subdetId()==EcalEndcap) {
                 leadingSample = ((EcalDataFrame)(*itdg)).lastUnsaturatedSample();
         } else {
                 leadingSample = ((EcalDataFrame)(*itdg)).lastUnsaturatedSample();
         }
 
         if ( leadingSample >= 0 ) { // saturation
                 if ( leadingSample != 4 ) {
                         // all samples different from the fifth are not reliable for the amplitude estimation
                         // put by default the energy at the saturation threshold and flag as saturated
                         float sratio = 1;
                         if ( detid.subdetId()==EcalBarrel) {
                                 sratio = ebPulseShape_[5] / ebPulseShape_[4];
                         } else {
                                 sratio = eePulseShape_[5] / eePulseShape_[4];
                         }
             uncalibRecHit = EcalUncalibratedRecHit( (*itdg).id(), 4095*12*sratio, 0, 0, 0);
                         uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kSaturated );
                 } else {
                         // float clockToNsConstant = 25.;
                         // reconstruct the rechit
                         if (detid.subdetId()==EcalEndcap) {
                                 leadingEdgeMethod_endcap_.setPulseShape( eePulseShape_ );
                                 // float mult = (float)eePulseShape_.size() / (float)(*itdg).size();
                                 // bin (or some analogous mapping) will be used instead of the leadingSample
                                 //int bin  = (int)(( (mult * leadingSample + mult/2) * clockToNsConstant + itimeconst ) / clockToNsConstant);
                                 // bin is not uset for the moment
                                 leadingEdgeMethod_endcap_.setLeadingEdgeSample( leadingSample );
                                 uncalibRecHit = leadingEdgeMethod_endcap_.makeRecHit(*itdg, pedVec, gainRatios, 0, 0);
                                 uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kLeadingEdgeRecovered );
                                 leadingEdgeMethod_endcap_.setLeadingEdgeSample( -1 );
                         } else {
                                 leadingEdgeMethod_barrel_.setPulseShape( ebPulseShape_ );
                                 // float mult = (float)ebPulseShape_.size() / (float)(*itdg).size();
                                 // bin (or some analogous mapping) will be used instead of the leadingSample
                                 //int bin  = (int)(( (mult * leadingSample + mult/2) * clockToNsConstant + itimeconst ) / clockToNsConstant);
                                 // bin is not uset for the moment
                                 leadingEdgeMethod_barrel_.setLeadingEdgeSample( leadingSample );
                                 uncalibRecHit = leadingEdgeMethod_barrel_.makeRecHit(*itdg, pedVec, gainRatios, 0, 0);
                                 uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kLeadingEdgeRecovered );
                                 leadingEdgeMethod_barrel_.setLeadingEdgeSample( -1 );
                         }
                 }
         // do not propagate the default chi2 = -1 value to the calib rechit (mapped to 64), set it to 0 when saturation
                 uncalibRecHit.setChi2(0);
         uncalibRecHit.setOutOfTimeChi2(0);
         } else {
                 // weights method
                 EcalTBWeights::EcalTDCId tdcid(1);
                 EcalTBWeights::EcalTBWeightMap const & wgtsMap = wgts->getMap();
                 EcalTBWeights::EcalTBWeightMap::const_iterator wit;
                 wit = wgtsMap.find( std::make_pair(*gid,tdcid) );
                 if( wit == wgtsMap.end() ) {
                         edm::LogError("EcalUncalibRecHitError") << "No weights found for EcalGroupId: " 
                                 << gid->id() << " and  EcalTDCId: " << tdcid
                                 << "\n  skipping digi with id: " << detid.rawId();
 
                         return false;
                 }
                 const EcalWeightSet& wset = wit->second; // this is the EcalWeightSet
 
                 const EcalWeightSet::EcalWeightMatrix& mat1 = wset.getWeightsBeforeGainSwitch();
                 const EcalWeightSet::EcalWeightMatrix& mat2 = wset.getWeightsAfterGainSwitch();
 
                 weights[0] = &mat1;
                 weights[1] = &mat2;
 
                 // get uncalibrated recHit from weights
         if (detid.subdetId()==EcalEndcap) {
                  uncalibRecHit = weightsMethod_endcap_.makeRecHit(*itdg, pedVec, pedRMSVec, gainRatios, weights, testbeamEEShape);
         } else {
              uncalibRecHit = weightsMethod_barrel_.makeRecHit(*itdg, pedVec, pedRMSVec, gainRatios, weights, testbeamEBShape);
         }
 
                 // === time computation ===
                 // ratio method
                 float const clockToNsConstant = 25.;
                 if (detid.subdetId()==EcalEndcap) {
                             ratioMethod_endcap_.init( *itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios );
                                 ratioMethod_endcap_.computeTime( EEtimeFitParameters_, EEtimeFitLimits_, EEamplitudeFitParameters_ );
                                 ratioMethod_endcap_.computeAmplitude( EEamplitudeFitParameters_);
                                 EcalUncalibRecHitRatioMethodAlgo<EEDataFrame>::CalculatedRecHit crh = ratioMethod_endcap_.getCalculatedRecHit();
                 double theTimeCorrectionEE = timeCorrection(uncalibRecHit.amplitude(),
                     timeCorrBias_->EETimeCorrAmplitudeBins, timeCorrBias_->EETimeCorrShiftBins);
 
                                 uncalibRecHit.setJitter( crh.timeMax - 5 + theTimeCorrectionEE);
                                 uncalibRecHit.setJitterError( std::sqrt(pow(crh.timeError,2) + std::pow(EEtimeConstantTerm_,2)/std::pow(clockToNsConstant,2)) );
                                 uncalibRecHit.setOutOfTimeEnergy( crh.amplitudeMax );
                 // consider flagging as kOutOfTime only if above noise
                 if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEE_){
                   float outOfTimeThreshP = outOfTimeThreshG12pEE_;
                   float outOfTimeThreshM = outOfTimeThreshG12mEE_;
                   // determine if gain has switched away from gainId==1 (x12 gain)
                   // and determine cuts (number of 'sigmas') to ose for kOutOfTime
                   // >3k ADC is necessasry condition for gain switch to occur
                   if (uncalibRecHit.amplitude() > 3000.){
                     for (int iSample = 0; iSample < EEDataFrame::MAXSAMPLES; iSample++) {
                       int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
                       if (GainId!=1) {
                     outOfTimeThreshP = outOfTimeThreshG61pEE_;
                     outOfTimeThreshM = outOfTimeThreshG61mEE_;
                     break;
                       }
                     }}
                   float correctedTime = (crh.timeMax-5) * clockToNsConstant + itimeconst + offsetTime;
                   float cterm         = EEtimeConstantTerm_;
                   float sigmaped      = pedRMSVec[0];  // approx for lower gains
                   float nterm         = EEtimeNconst_*sigmaped/uncalibRecHit.amplitude();
                   float sigmat        = std::sqrt( nterm*nterm  + cterm*cterm   );
                   if ( ( correctedTime > sigmat*outOfTimeThreshP )   ||
                        ( correctedTime < (-1.*sigmat*outOfTimeThreshM) )) 
                     {  uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kOutOfTime ); }
                 }
                 
                 } else {
                         ratioMethod_barrel_.init( *itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios );
                 ratioMethod_barrel_.fixMGPAslew(*itdg);
                                 ratioMethod_barrel_.computeTime( EBtimeFitParameters_, EBtimeFitLimits_, EBamplitudeFitParameters_ );
                                 ratioMethod_barrel_.computeAmplitude( EBamplitudeFitParameters_);
                                 EcalUncalibRecHitRatioMethodAlgo<EBDataFrame>::CalculatedRecHit crh = ratioMethod_barrel_.getCalculatedRecHit();
 
                 double theTimeCorrectionEB = timeCorrection(uncalibRecHit.amplitude(),
                     timeCorrBias_->EBTimeCorrAmplitudeBins, timeCorrBias_->EBTimeCorrShiftBins);
 
                 uncalibRecHit.setJitter( crh.timeMax - 5 + theTimeCorrectionEB);
 
                                 uncalibRecHit.setJitterError( std::sqrt(std::pow(crh.timeError,2) + std::pow(EBtimeConstantTerm_,2)/std::pow(clockToNsConstant,2)) );
                                 uncalibRecHit.setOutOfTimeEnergy( crh.amplitudeMax );
                 // consider flagging as kOutOfTime only if above noise
                 if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEB_){
                   float outOfTimeThreshP = outOfTimeThreshG12pEB_;
                   float outOfTimeThreshM = outOfTimeThreshG12mEB_;
                   // determine if gain has switched away from gainId==1 (x12 gain)
                   // and determine cuts (number of 'sigmas') to ose for kOutOfTime
                   // >3k ADC is necessasry condition for gain switch to occur
                   if (uncalibRecHit.amplitude() > 3000.){
                     for (int iSample = 0; iSample < EBDataFrame::MAXSAMPLES; iSample++) {
                       int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
                       if (GainId!=1) {
                     outOfTimeThreshP = outOfTimeThreshG61pEB_;
                     outOfTimeThreshM = outOfTimeThreshG61mEB_;
                     break;}
                     } }
                   float correctedTime = (crh.timeMax-5) * clockToNsConstant + itimeconst + offsetTime;
                   float cterm         = EBtimeConstantTerm_;
                   float sigmaped      = pedRMSVec[0];  // approx for lower gains
                   float nterm         = EBtimeNconst_*sigmaped/uncalibRecHit.amplitude();
                   float sigmat        = std::sqrt( nterm*nterm  + cterm*cterm   );
                   if ( ( correctedTime > sigmat*outOfTimeThreshP )   ||
                        ( correctedTime < (-1.*sigmat*outOfTimeThreshM) )) 
                     {   uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kOutOfTime );  }
                 }
         }
         
         // === chi2express ===
         if (detid.subdetId()==EcalEndcap) {
               
             double amplitude = uncalibRecHit.amplitude();
             double amplitudeOutOfTime = uncalibRecHit.outOfTimeEnergy();
                     double jitter= uncalibRecHit.jitter();
 
 
         
             EcalUncalibRecHitRecChi2Algo<EEDataFrame>chi2expressEE_(
                                         *itdg, 
                                         amplitude, 
                                         (itimeconst + offsetTime), 
                                         amplitudeOutOfTime, 
                                         jitter, 
                                         pedVec, 
                                         pedRMSVec, 
                                         gainRatios, 
                                         testbeamEEShape,
                                         EEchi2Parameters_
             );
             double chi2 = chi2expressEE_.chi2();
             uncalibRecHit.setChi2(chi2);
             double chi2OutOfTime = chi2expressEE_.chi2OutOfTime();
             uncalibRecHit.setOutOfTimeChi2(chi2OutOfTime);
 
                     if(kPoorRecoFlagEE_)
             {
             
               if (chi2>chi2ThreshEE_) {
 
             // first check if all samples are ok, if not don't use chi2 to flag
             bool samplesok = true;
             for (int sample =0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
               if (!sampleMask_->useSampleEE(sample)) {
                 samplesok = false;
                 break;
               }
             }
             if (samplesok) uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kPoorReco);
               }
 
 
             }               
             
         } else {
             double amplitude = uncalibRecHit.amplitude();
             double amplitudeOutOfTime = uncalibRecHit.outOfTimeEnergy();
                     double jitter= uncalibRecHit.jitter();
           
             EcalUncalibRecHitRecChi2Algo<EBDataFrame>chi2expressEB_(
                                         *itdg, 
                                         amplitude, 
                                         (itimeconst + offsetTime), 
                                         amplitudeOutOfTime, 
                                         jitter, 
                                         pedVec, 
                                         pedRMSVec, 
                                         gainRatios, 
                                         testbeamEBShape,
                                                 EBchi2Parameters_       
             );
             double chi2 = chi2expressEB_.chi2();
             uncalibRecHit.setChi2(chi2);
             double chi2OutOfTime = chi2expressEB_.chi2OutOfTime();
             uncalibRecHit.setOutOfTimeChi2(chi2OutOfTime);
 
                     if(kPoorRecoFlagEB_)
             {
 
               if(chi2>chi2ThreshEB_){
                 // first check if all samples are ok, if not don't use chi2 to flag
             bool samplesok = true;
             for (int sample =0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
               if (!sampleMask_->useSampleEB(sample)) {
                 samplesok = false;
                 break;
               }
             }
             if (samplesok) uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kPoorReco);
               }
 
             }               
         }
         }
 
     // set flags if gain switch has occurred
     if( ((EcalDataFrame)(*itdg)).hasSwitchToGain6()  ) uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kHasSwitchToGain6 );
     if( ((EcalDataFrame)(*itdg)).hasSwitchToGain1()  ) uncalibRecHit.setFlagBit( EcalUncalibratedRecHit::kHasSwitchToGain1 );
 
         // put the recHit in the collection
         if (detid.subdetId()==EcalEndcap) {
                 result.push_back( uncalibRecHit );
         } else {
                 result.push_back( uncalibRecHit );
         }
 
         return true;
 }

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

virtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 114 of file EcalUncalibRecHitWorkerGlobal.cc.

References gains, edm::EventSetup::get(), grps, itime, offtime, peds, sampleMaskHand_, timeCorrBias_, and wgts.

Referenced by betterConfigParser.BetterConfigParser::getGeneral().

 {
         // common setup
         es.get<EcalGainRatiosRcd>().get(gains);
         es.get<EcalPedestalsRcd>().get(peds);
 
         // for the weights method
         es.get<EcalWeightXtalGroupsRcd>().get(grps);
         es.get<EcalTBWeightsRcd>().get(wgts);
 
     // which of the samples need be used
     es.get<EcalSampleMaskRcd>().get(sampleMaskHand_);
 
         // for the ratio method
 
         // for the leading edge method
         es.get<EcalTimeCalibConstantsRcd>().get(itime);
         es.get<EcalTimeOffsetConstantRcd>().get(offtime);
 
         // for the time correction methods
         es.get<EcalTimeBiasCorrectionsRcd>().get(timeCorrBias_);
 }

double EcalUncalibRecHitWorkerGlobal::timeCorrection	(	float	ampli,
		const std::vector< float > &	amplitudeBins,
		const std::vector< float > &	shiftBins
	)

protected

Amplitude-dependent time corrections; EE and EB have separate corrections: EXtimeCorrAmplitudes (ADC) and EXtimeCorrShifts (ns) need to have the same number of elements Bins must be ordered in amplitude. First-last bins take care of under-overflows.

The algorithm is the same for EE and EB, only the correction vectors are different.

Returns: Jitter (in clock cycles) which will be added to UncalibRechit.setJitter(), 0 if no correction is applied.

Definition at line 163 of file EcalUncalibRecHitWorkerGlobal.cc.

References newFWLiteAna::bin.

Referenced by run().

                                        {
 
   // computed initially in ns. Than turned in the BX's, as
   // EcalUncalibratedRecHit need be.
   double theCorrection = 0;
 
   // sanity check for arrays
   if (amplitudeBins.size() == 0) {
     edm::LogError("EcalRecHitError")
         << "timeCorrAmplitudeBins is empty, forcing no time bias corrections.";
 
     return 0;
   }
 
   if (amplitudeBins.size() != shiftBins.size()) {
     edm::LogError("EcalRecHitError")
         << "Size of timeCorrAmplitudeBins different from "
            "timeCorrShiftBins. Forcing no time bias corrections. ";
 
     return 0;
   }
 
   int myBin = -1;
   for (int bin = 0; bin < (int) amplitudeBins.size(); bin++) {
     if (ampli > amplitudeBins.at(bin)) {
       myBin = bin;
     } else {
       break;
     }
   }
 
   if (myBin == -1) {
     theCorrection = shiftBins.at(0);
   } else if (myBin == ((int)(amplitudeBins.size() - 1))) {
     theCorrection = shiftBins.at(myBin);
   } else if (-1 < myBin && myBin < ((int) amplitudeBins.size() - 1)) {
     // interpolate linearly between two assingned points
     theCorrection = (shiftBins.at(myBin + 1) - shiftBins.at(myBin));
     theCorrection *= (((double) ampli) - amplitudeBins.at(myBin)) /
                      (amplitudeBins.at(myBin + 1) - amplitudeBins.at(myBin));
     theCorrection += shiftBins.at(myBin);
   } else {
     edm::LogError("EcalRecHitError")
         << "Assigning time correction impossible. Setting it to 0 ";
     theCorrection = 0.;
   }
 
   // convert ns into clocks
   return theCorrection / 25.;
 }

Member Data Documentation

double EcalUncalibRecHitWorkerGlobal::amplitudeThreshEB_

protected

Definition at line 96 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::amplitudeThreshEE_

protected

Definition at line 97 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

const EcalWeightSet::EcalChi2WeightMatrix* EcalUncalibRecHitWorkerGlobal::chi2mat[2]

protected

Definition at line 64 of file EcalUncalibRecHitWorkerGlobal.h.

double EcalUncalibRecHitWorkerGlobal::chi2ThreshEB_

protected

Definition at line 113 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::chi2ThreshEE_

protected

Definition at line 114 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBamplitudeFitParameters_

protected

Definition at line 76 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBchi2Parameters_

protected

Definition at line 115 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::ebPulseShape_

protected

Definition at line 105 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::ebSpikeThresh_

protected

Definition at line 98 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal().

double EcalUncalibRecHitWorkerGlobal::EBtimeConstantTerm_

protected

Definition at line 84 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::pair<double,double> EcalUncalibRecHitWorkerGlobal::EBtimeFitLimits_

protected

Definition at line 78 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBtimeFitParameters_

protected

Definition at line 74 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::EBtimeNconst_

protected

Definition at line 85 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEamplitudeFitParameters_

protected

Definition at line 77 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEchi2Parameters_

protected

Definition at line 116 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::eePulseShape_

protected

Definition at line 106 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::EEtimeConstantTerm_

protected

Definition at line 86 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::pair<double,double> EcalUncalibRecHitWorkerGlobal::EEtimeFitLimits_

protected

Definition at line 79 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEtimeFitParameters_

protected

Definition at line 75 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::EEtimeNconst_

protected

Definition at line 87 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::gainRatios[3]

protected

Definition at line 50 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalGainRatios> EcalUncalibRecHitWorkerGlobal::gains

protected

Definition at line 53 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

edm::ESHandle<EcalWeightXtalGroups> EcalUncalibRecHitWorkerGlobal::grps

protected

Definition at line 61 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

edm::ESHandle<EcalTimeCalibConstants> EcalUncalibRecHitWorkerGlobal::itime

protected

Definition at line 103 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

bool EcalUncalibRecHitWorkerGlobal::kPoorRecoFlagEB_

protected

Definition at line 111 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

bool EcalUncalibRecHitWorkerGlobal::kPoorRecoFlagEE_

protected

Definition at line 112 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EcalUncalibRecHitLeadingEdgeAlgo<EBDataFrame> EcalUncalibRecHitWorkerGlobal::leadingEdgeMethod_barrel_

protected

Definition at line 107 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

EcalUncalibRecHitLeadingEdgeAlgo<EEDataFrame> EcalUncalibRecHitWorkerGlobal::leadingEdgeMethod_endcap_

protected

Definition at line 108 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalTimeOffsetConstant> EcalUncalibRecHitWorkerGlobal::offtime

protected

Definition at line 104 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12mEB_

protected

Definition at line 89 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12mEE_

protected

Definition at line 93 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12pEB_

protected

Definition at line 88 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12pEE_

protected

Definition at line 92 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61mEB_

protected

Definition at line 91 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61mEE_

protected

Definition at line 95 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61pEB_

protected

Definition at line 90 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61pEE_

protected

Definition at line 94 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

double EcalUncalibRecHitWorkerGlobal::pedRMSVec[3]

protected

Definition at line 49 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalPedestals> EcalUncalibRecHitWorkerGlobal::peds

protected

Definition at line 52 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

double EcalUncalibRecHitWorkerGlobal::pedVec[3]

protected

Definition at line 48 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

EcalUncalibRecHitRatioMethodAlgo<EBDataFrame> EcalUncalibRecHitWorkerGlobal::ratioMethod_barrel_

protected

Definition at line 81 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

EcalUncalibRecHitRatioMethodAlgo<EEDataFrame> EcalUncalibRecHitWorkerGlobal::ratioMethod_endcap_

protected

Definition at line 82 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalSampleMask> EcalUncalibRecHitWorkerGlobal::sampleMaskHand_

protected

Definition at line 71 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

const EBShape EcalUncalibRecHitWorkerGlobal::testbeamEBShape

protected

Definition at line 68 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

const EEShape EcalUncalibRecHitWorkerGlobal::testbeamEEShape

protected

Definition at line 67 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalTimeBiasCorrections> EcalUncalibRecHitWorkerGlobal::timeCorrBias_

protected

Definition at line 100 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

const EcalWeightSet::EcalWeightMatrix* EcalUncalibRecHitWorkerGlobal::weights[2]

protected

Definition at line 63 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

EcalUncalibRecHitRecWeightsAlgo<EBDataFrame> EcalUncalibRecHitWorkerGlobal::weightsMethod_barrel_

protected

Definition at line 65 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

EcalUncalibRecHitRecWeightsAlgo<EEDataFrame> EcalUncalibRecHitWorkerGlobal::weightsMethod_endcap_

protected

Definition at line 66 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

edm::ESHandle<EcalTBWeights> EcalUncalibRecHitWorkerGlobal::wgts

protected

Definition at line 62 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation