Merge pull request #5197 from bendavid/ecalMultifit_minimal720p4

New Ecal Local Reconstruction with Multifit

Configuration/StandardSequences/python/Reconstruction_cff.py

@@ -101,7 +101,8 @@
 modulesToRemove.append(dt1DCosmicRecHits)
 modulesToRemove.append(csc2DRecHits)
 modulesToRemove.append(rpcRecHits)
-modulesToRemove.append(ecalGlobalUncalibRecHit)
+#modulesToRemove.append(ecalGlobalUncalibRecHit)
+modulesToRemove.append(ecalMultiFitUncalibRecHit)
 modulesToRemove.append(ecalDetIdToBeRecovered)
 modulesToRemove.append(ecalRecHit)
 modulesToRemove.append(ecalCompactTrigPrim)

DQM/EcalMonitorTasks/python/CollectionTags_cfi.py

@@ -22,12 +22,12 @@
     PnDiodeDigi = cms.untracked.InputTag("ecalDigis"),
     TrigPrimDigi = cms.untracked.InputTag("ecalDigis", "EcalTriggerPrimitives"),
     TrigPrimEmulDigi = cms.untracked.InputTag("valEcalTriggerPrimitiveDigis"),
-    EBUncalibRecHit = cms.untracked.InputTag("ecalGlobalUncalibRecHit", "EcalUncalibRecHitsEB"),
-    EEUncalibRecHit = cms.untracked.InputTag("ecalGlobalUncalibRecHit", "EcalUncalibRecHitsEE"),
+    EBUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEB"),
+    EEUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEE"),
 #    EBLaserLedUncalibRecHit = cms.untracked.InputTag("ecalLaserLedUncalibRecHit", "EcalUncalibRecHitsEB"),
 #    EELaserLedUncalibRecHit = cms.untracked.InputTag("ecalLaserLedUncalibRecHit", "EcalUncalibRecHitsEE"),
-    EBLaserLedUncalibRecHit = cms.untracked.InputTag("ecalGlobalUncalibRecHit", "EcalUncalibRecHitsEB"),
-    EELaserLedUncalibRecHit = cms.untracked.InputTag("ecalGlobalUncalibRecHit", "EcalUncalibRecHitsEE"),
+    EBLaserLedUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEB"),
+    EELaserLedUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEE"),
     EBTestPulseUncalibRecHit = cms.untracked.InputTag("ecalTestPulseUncalibRecHit", "EcalUncalibRecHitsEB"),
     EETestPulseUncalibRecHit = cms.untracked.InputTag("ecalTestPulseUncalibRecHit", "EcalUncalibRecHitsEE"),
     EBRecHit = cms.untracked.InputTag("ecalRecHit", "EcalRecHitsEB"),

DQM/EcalMonitorTasks/src/EnergyTask.cc

@@ -53,7 +53,7 @@ namespace ecaldqm
       if(isPhysicsRun_ && hitItr->checkFlagMask(notGood)) continue;
       if(!isPhysicsRun_ && hitItr->checkFlagMask(neitherGoodNorOOT)) continue;
 
-      float energy(isPhysicsRun_ ? hitItr->energy() : hitItr->outOfTimeEnergy());
+      float energy(hitItr->energy());
 
       if(energy < 0.) continue;
 

DQM/Integration/python/test/ecal_dqm_sourceclient-live_cfg.py

@@ -27,7 +27,7 @@
 process.load("Geometry.CMSCommonData.cmsIdealGeometryXML_cfi")
 process.load("Geometry.EcalMapping.EcalMapping_cfi")
 process.load("Geometry.EcalMapping.EcalMappingRecord_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi")
+process.load("RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi")
 process.load("RecoLocalCalo.EcalRecProducers.ecalDetIdToBeRecovered_cfi")
 process.load("RecoLocalCalo.EcalRecProducers.ecalRecHit_cfi")
 process.load("RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi")
@@ -168,7 +168,7 @@
 ### Sequences ###
 
 process.ecalPreRecoSequence = cms.Sequence(process.ecalDigis)
-process.ecalRecoSequence = cms.Sequence((process.ecalGlobalUncalibRecHit+process.ecalDetIdToBeRecovered+process.ecalRecHit)+(process.simEcalTriggerPrimitiveDigis+process.gtDigis)+(process.hybridClusteringSequence+process.multi5x5ClusteringSequence))
+process.ecalRecoSequence = cms.Sequence((process.ecalMultiFitUncalibRecHit+process.ecalDetIdToBeRecovered+process.ecalRecHit)+(process.simEcalTriggerPrimitiveDigis+process.gtDigis)+(process.hybridClusteringSequence+process.multi5x5ClusteringSequence))
 process.multi5x5ClusteringSequence = cms.Sequence(process.multi5x5BasicClustersCleaned+process.multi5x5SuperClustersCleaned+process.multi5x5BasicClustersUncleaned+process.multi5x5SuperClustersUncleaned+process.multi5x5SuperClusters)
 process.hybridClusteringSequence = cms.Sequence(process.cleanedHybridSuperClusters+process.uncleanedHybridSuperClusters+process.hybridSuperClusters+process.correctedHybridSuperClusters+process.uncleanedOnlyCorrectedHybridSuperClusters)
 

DQM/Integration/rcms/eb_dqm_sourceclient-live_cfg.py

@@ -125,8 +125,8 @@
 if (onlyEE == 1) :
   process.ecalEBunpacker.FEDs = [ 601, 602, 603, 604, 605, 606, 607, 608, 609, 646, 647, 648, 649, 650, 651, 652, 653, 654 ]
 
-import RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi
-process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi.ecalGlobalUncalibRecHit.clone()
+import RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi
+process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi.ecalMultiFitUncalibRecHit.clone()
 
 import RecoLocalCalo.EcalRecProducers.ecalFixedAlphaBetaFitUncalibRecHit_cfi
 process.ecalUncalibHit1 = RecoLocalCalo.EcalRecProducers.ecalFixedAlphaBetaFitUncalibRecHit_cfi.ecalFixedAlphaBetaFitUncalibRecHit.clone()

DQM/Integration/rcms/ee_dqm_sourceclient-live_cfg.py

@@ -125,8 +125,8 @@
 if (onlyEE == 1) :
   process.ecalEBunpacker.FEDs = [ 601, 602, 603, 604, 605, 606, 607, 608, 609, 646, 647, 648, 649, 650, 651, 652, 653, 654 ]
 
-import RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi
-process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi.ecalGlobalUncalibRecHit.clone()
+import RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi
+process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi.ecalMultiFitUncalibRecHit.clone()
 
 import RecoLocalCalo.EcalRecProducers.ecalFixedAlphaBetaFitUncalibRecHit_cfi
 process.ecalUncalibHit1 = RecoLocalCalo.EcalRecProducers.ecalFixedAlphaBetaFitUncalibRecHit_cfi.ecalFixedAlphaBetaFitUncalibRecHit.clone()

DataFormats/EcalRecHit/interface/EcalRecHit.h

@@ -107,7 +107,7 @@ class EcalRecHit {
 
   /* the new bit structure
    * 0..6   - chi2 in time events (chi2()), offset=0, width=7
-   * 8..20  - energy in out-of-time (outOfTimeEnergy()), offset=8, width=13
+   * 8..20  - energy uncertainty, offset=8, width=13
    * 24..31 - timeError(), offset=24, width=8
    */
   float chi2() const {
@@ -123,18 +123,17 @@ class EcalRecHit {
     uint32_t rawChi2 = lround(chi2 / 64. * ((1<<7)-1));
     extra_ = setMasked(extra_, rawChi2, 0, 7);
   }
-
-
-  float outOfTimeEnergy() const {
+
+  float energyError() const {
     uint32_t rawEnergy = getMasked(extra_, 8, 13);
     uint16_t exponent = rawEnergy >> 10;
     uint16_t significand = ~(0xE<<9) & rawEnergy;
     return (float) significand*pow(10,exponent-5);
   }
 
-  // set the energy for out of time events
+  // set the energy uncertainty
   // (only energy >= 0 will be stored)
-  void setOutOfTimeEnergy(float energy) {
+  void setEnergyError(float energy) {
     uint32_t rawEnergy = 0;
     if (energy > 0.001) {
       uint16_t exponent = lround(floor(log10(energy))) + 3;
@@ -164,10 +163,7 @@ class EcalRecHit {
   void setTimeError(uint8_t timeErrBits) {
     extra_ = setMasked(extra_, timeErrBits & 0xFF, 24, 8);
   }
-
-  float outOfTimeChi2() const { return 0; }
-  void setOutOfTimeChi2(short chi2) { /* not used */ }
-
+
   /// set the flags (from Flags or ESFlags) 
   void setFlag(int flag) {flagBits_|= (0x1 << flag);}
   void unsetFlag(int flag) {flagBits_ &= ~(0x1 << flag);}
@@ -209,7 +205,7 @@ class EcalRecHit {
   /// store rechit condition (see Flags enum) in a bit-wise way 
   uint32_t flagBits_;
 
-  // packed uint32_t for timeError, chi2, outOfTimeEnergy
+  // packed uint32_t for timeError, chi2, energyError
   uint32_t extra_;
 };
 

DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h

@@ -3,6 +3,7 @@
 
 #include <vector>
 #include "DataFormats/DetId/interface/DetId.h"
+#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
 
 class EcalUncalibratedRecHit {
 
@@ -21,32 +22,30 @@ class EcalUncalibratedRecHit {
 
   };
 
-  EcalUncalibratedRecHit() :
-      amplitude_(0.), pedestal_(0.), jitter_(0.), chi2_(10000.), OOTamplitude_(0.), OOTchi2_(10000.), flags_(0), aux_(0) { }
+  EcalUncalibratedRecHit();
 
   EcalUncalibratedRecHit(const DetId& id, float ampl, float ped,
-                          float jit, float chi2, uint32_t flags = 0, uint32_t aux = 0):
-     amplitude_(ampl), pedestal_(ped), jitter_(jit), chi2_(chi2), OOTamplitude_(0.), OOTchi2_(10000.), flags_(flags), aux_(aux), id_(id) { }
+                         float jit, float chi2, uint32_t flags = 0, uint32_t aux = 0);
 
 
   float amplitude() const { return amplitude_; }
+  float amplitudeError() const { return amplitudeError_; }
   float pedestal() const { return pedestal_; }
   float jitter() const { return jitter_; }
   float chi2() const { return chi2_; }
-  float outOfTimeEnergy() const { return OOTamplitude_; }
-  float outOfTimeChi2() const { return OOTchi2_; }
+  float outOfTimeAmplitude(int bx) const { return OOTamplitudes_[bx]; }
 
   uint32_t flags() const { return flags_; }
   float jitterError() const;
   uint8_t jitterErrorBits() const;
   DetId  id() const { return id_; }
 
   void setAmplitude( float amplitude ) { amplitude_ = amplitude; }
+  void setAmplitudeError( float amplitudeerror ) { amplitudeError_ = amplitudeerror; }
   void setPedestal( float pedestal ) { pedestal_ = pedestal; }
   void setJitter( float jitter ) { jitter_ = jitter; }
   void setChi2( float chi2 ) { chi2_ = chi2; }
-  void setOutOfTimeEnergy( float energy ) { OOTamplitude_ = energy; }
-  void setOutOfTimeChi2( float chi2 ){ OOTchi2_ = chi2; }
+  void setOutOfTimeAmplitude( int bx, float amplitude ) { OOTamplitudes_[bx] = amplitude; }
 
   void setJitterError( float jitterErr );
   void setFlags( uint32_t flags ) { flags_ = flags; }
@@ -60,15 +59,16 @@ class EcalUncalibratedRecHit {
   bool isJitterErrorValid() const;
 
  private:
-  float amplitude_;    //< Reconstructed amplitude
-  float pedestal_;     //< Reconstructed pedestal
-  float jitter_;       //< Reconstructed time jitter
-  float chi2_;         //< Chi2 of the pulse
-  float OOTamplitude_; //< Out-Of-Time reconstructed amplitude 
-  float OOTchi2_;      //< Out-Of-Time Chi2 
-  uint32_t flags_;     //< flag to be propagated to RecHit
-  uint32_t aux_;       //< aux word; first 8 bits contain time (jitter) error
-  DetId  id_;          //< Detector ID
+  float amplitude_;           //< Reconstructed amplitude
+  float amplitudeError_;      //< Reconstructed amplitude uncertainty
+  float pedestal_;            //< Reconstructed pedestal
+  float jitter_;              //< Reconstructed time jitter
+  float chi2_;                //< Chi2 of the pulse
+  float OOTamplitudes_[EcalDataFrame::MAXSAMPLES];       //< Out-Of-Time reconstructed amplitude, one for each active BX, from readout sample 0 to 9
+  float OOTchi2_;             //< Out-Of-Time Chi2 
+  uint32_t flags_;            //< flag to be propagated to RecHit
+  uint32_t aux_;              //< aux word; first 8 bits contain time (jitter) error
+  DetId  id_;                 //< Detector ID
 };
 
 #endif

DataFormats/EcalRecHit/src/EcalUncalibratedRecHit.cc

@@ -3,6 +3,18 @@
 #include <cmath>
 
 
+EcalUncalibratedRecHit::EcalUncalibratedRecHit() : 
+  amplitude_(0.), amplitudeError_(0.), pedestal_(0.), jitter_(0.), chi2_(10000.), flags_(0), aux_(0) {
+  const unsigned int nsample = EcalDataFrame::MAXSAMPLES;
+  for(unsigned int ibx=0; ibx<nsample; ++ibx) OOTamplitudes_[ibx] = 0.;
+}
+
+EcalUncalibratedRecHit::  EcalUncalibratedRecHit(const DetId& id, float ampl, float ped,
+                                                 float jit, float chi2, uint32_t flags, uint32_t aux):
+  amplitude_(ampl), amplitudeError_(0.), pedestal_(ped), jitter_(jit), chi2_(chi2), flags_(flags), aux_(aux), id_(id) {
+  const unsigned int nsample = EcalDataFrame::MAXSAMPLES;
+  for(unsigned int ibx=0; ibx<nsample; ++ibx) OOTamplitudes_[ibx] = 0.;  
+}
 
 bool EcalUncalibratedRecHit::isSaturated() const {
   return EcalUncalibratedRecHit::checkFlag(kSaturated);

DataFormats/EcalRecHit/src/classes_def.xml

@@ -1,7 +1,7 @@
 <lcgdict>
-  <class name="EcalUncalibratedRecHit" ClassVersion="11">
+  <class name="EcalUncalibratedRecHit" ClassVersion="12">
+   <version ClassVersion="12" checksum="343844348"/>
    <version ClassVersion="11" checksum="4183938955"/>
-   <version ClassVersion="10" checksum="2325626302"/>
   </class>
   <class name="std::vector<EcalUncalibratedRecHit>"/>
   <class name="edm::SortedCollection<EcalUncalibratedRecHit,edm::StrictWeakOrdering<EcalUncalibratedRecHit> >"/>
@@ -10,9 +10,10 @@
   <class name="edm::RefVector<edm::SortedCollection<EcalUncalibratedRecHit,edm::StrictWeakOrdering<EcalUncalibratedRecHit> >,EcalUncalibratedRecHit,edm::refhelper::FindUsingAdvance<edm::SortedCollection<EcalUncalibratedRecHit,edm::StrictWeakOrdering<EcalUncalibratedRecHit> >,EcalUncalibratedRecHit> >"/>
   <class name="edm::RefProd<edm::SortedCollection<EcalUncalibratedRecHit,edm::StrictWeakOrdering<EcalUncalibratedRecHit> > >"/>
 
-  <class name="EcalRecHit" ClassVersion="11">
+  <class name="EcalRecHit" ClassVersion="12">
    <version ClassVersion="10" checksum="283504841"/>
    <version ClassVersion="11" checksum="3356791847"/>
+   <version ClassVersion="12" checksum="3356791847"/>
   </class>
   <class name="std::vector<EcalRecHit>"/>
   <class name="edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> >"/>

DataFormats/EcalRecHit/test/testEcalRecHit.cppunit.cc

@@ -82,9 +82,9 @@ void testEcalRecHit::testOne() {
   CPPUNIT_ASSERT_DOUBLES_EQUAL(timerr*25, rh.timeError(), 0.5);
   CPPUNIT_ASSERT_DOUBLES_EQUAL(urh.jitterError()*25, rh.timeError(), 0.00001);
 
-  // test outOfTimeEnergy
-  rh.setOutOfTimeEnergy(1.8);
-  CPPUNIT_ASSERT_DOUBLES_EQUAL(1.8, rh.outOfTimeEnergy(), 0.01);
-  rh.setOutOfTimeEnergy(50.8);
-  CPPUNIT_ASSERT_DOUBLES_EQUAL(50.8, rh.outOfTimeEnergy(), 0.01);
+  // test energyError
+  rh.setEnergyError(0.51);
+  CPPUNIT_ASSERT_DOUBLES_EQUAL(0.51, rh.energyError(), 0.01);
+  rh.setEnergyError(50.8);
+  CPPUNIT_ASSERT_DOUBLES_EQUAL(50.8, rh.energyError(), 0.01);
 }