EcalUncalibRecHitWorkerMultiFit.h

Go to the documentation of this file.

#ifndef RecoLocalCalo_EcalRecProducers_EcalUncalibRecHitRecWorkerGlobal_hh
#define RecoLocalCalo_EcalRecProducers_EcalUncalibRecHitRecWorkerGlobal_hh

#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitMultiFitAlgo.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitTimeWeightsAlgo.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitRecChi2Algo.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitRatioMethodAlgo.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitLeadingEdgeAlgo.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h"
#include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
#include "CondFormats/EcalObjects/interface/EcalPedestals.h"
#include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
#include "CondFormats/EcalObjects/interface/EcalWeightXtalGroups.h"
#include "CondFormats/EcalObjects/interface/EcalTBWeights.h"
#include "CondFormats/EcalObjects/interface/EcalSampleMask.h"
#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrections.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EigenMatrixTypes.h"

namespace edm {
        class Event;
        class EventSetup;
        class ParameterSet;
}

class EcalUncalibRecHitWorkerMultiFit : public EcalUncalibRecHitWorkerBaseClass {

        public:
                EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&, edm::ConsumesCollector& c);
                //EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&);
                virtual ~EcalUncalibRecHitWorkerMultiFit() {};

                void set(const edm::EventSetup& es) override;
                void set(const edm::Event& evt) override;
                bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) override;

        protected:

                edm::ParameterSet EcalPulseShapeParameters_;

                double pedVec[3];
        double pedRMSVec[3];
                double gainRatios[3];

                edm::ESHandle<EcalPedestals> peds;
                edm::ESHandle<EcalGainRatios>  gains;

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

                const SampleMatrix &noisecor(bool barrel, int gain) const;                
                
                // multifit method
                SampleMatrix noisecorEBg12;
                SampleMatrix noisecorEEg12;
                SampleMatrix noisecorEBg6;
                SampleMatrix noisecorEEg6;
                SampleMatrix noisecorEBg1;
                SampleMatrix noisecorEEg1;
                FullSampleVector fullpulseEB;
                FullSampleVector fullpulseEE;
                FullSampleMatrix fullpulsecovEB;
                FullSampleMatrix fullpulsecovEE;
                BXVector activeBX;
                bool ampErrorCalculation_;
                bool useLumiInfoRunHeader_;
                EcalUncalibRecHitMultiFitAlgo multiFitMethod_;
                
                edm::EDGetTokenT<int> bunchSpacing_; 

                // determine which of the samples must actually be used by ECAL local reco
                edm::ESHandle<EcalSampleMask> sampleMaskHand_;                
                
                // time algorithm to be used to set the jitter and its uncertainty
                std::string timealgo_;

                // time weights method
                edm::ESHandle<EcalWeightXtalGroups>  grps;
                edm::ESHandle<EcalTBWeights> wgts;
                const EcalWeightSet::EcalWeightMatrix* weights[2];
                EcalUncalibRecHitTimeWeightsAlgo<EBDataFrame> weightsMethod_barrel_;
                EcalUncalibRecHitTimeWeightsAlgo<EEDataFrame> weightsMethod_endcap_;

                // ratio method
                std::vector<double> EBtimeFitParameters_; 
                std::vector<double> EEtimeFitParameters_; 
                std::vector<double> EBamplitudeFitParameters_; 
                std::vector<double> EEamplitudeFitParameters_; 
                std::pair<double,double> EBtimeFitLimits_;  
                std::pair<double,double> EEtimeFitLimits_;  

                EcalUncalibRecHitRatioMethodAlgo<EBDataFrame> ratioMethod_barrel_;
                EcalUncalibRecHitRatioMethodAlgo<EEDataFrame> ratioMethod_endcap_;

                double EBtimeConstantTerm_;
                double EEtimeConstantTerm_;

                edm::ESHandle<EcalTimeBiasCorrections> timeCorrBias_;

                // leading edge method
                edm::ESHandle<EcalTimeCalibConstants> itime;
        edm::ESHandle<EcalTimeOffsetConstant> offtime;
                std::vector<double> ebPulseShape_;
                std::vector<double> eePulseShape_;
                EcalUncalibRecHitLeadingEdgeAlgo<EBDataFrame> leadingEdgeMethod_barrel_;
                EcalUncalibRecHitLeadingEdgeAlgo<EEDataFrame> leadingEdgeMethod_endcap_;


                // chi2 thresholds for flags settings
                bool kPoorRecoFlagEB_;
                bool kPoorRecoFlagEE_;
                double chi2ThreshEB_;
                double chi2ThreshEE_;
                bool doPrefitEB_;
                bool doPrefitEE_;
        double prefitMaxChiSqEB_;
        double prefitMaxChiSqEE_;

 private:
                void fillInputs(const edm::ParameterSet& params);

};

#endif