Merge pull request #19100 from kpedro88/filter-invalid-hcal-upgrade-data

Filter invalid hcal upgrade data

EventFilter/HcalRawToDigi/BuildFile.xml

@@ -4,6 +4,8 @@
 <use   name="FWCore/MessageLogger"/>
 <use   name="CondFormats/HcalObjects"/>
 <use   name="FWCore/Utilities"/>
+<use   name="CalibFormats/HcalObjects"/>
+<use   name="CalibFormats/CaloObjects"/>
 <use   name="boost"/>
 <export>
   <lib   name="1"/>

EventFilter/HcalRawToDigi/interface/HcalDataFrameFilter.h

@@ -3,6 +3,7 @@
 
 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
 #include "DataFormats/HcalDigi/interface/HcalUnpackerReport.h"
+#include "CalibFormats/HcalObjects/interface/HcalDbService.h"
 
 /** \class HcalDataFrameFilter
     
@@ -28,14 +29,21 @@ class HcalDataFrameFilter {
   HcalCalibDigiCollection filter(const HcalCalibDigiCollection& incol, HcalUnpackerReport& r);
   /// filter ZDC data frames
   ZDCDigiCollection filter(const ZDCDigiCollection& incol, HcalUnpackerReport& r);
+  /// filter QIE10 data frames
+  QIE10DigiCollection filter(const QIE10DigiCollection& incol, HcalUnpackerReport& r);
+  /// filter QIE11 data frames
+  QIE11DigiCollection filter(const QIE11DigiCollection& incol, HcalUnpackerReport& r);
   /// whether any filters are on
   bool active() const;
+  /// get conditions
+  void setConditions(const HcalDbService* conditions);
 private:
   bool requireCapid_;
   bool requireDVER_;
   bool energyFilter_;
   int firstSample_, lastSample_;
   double minimumAmplitude_;
+  const HcalDbService* conditions_;
 };
 
 

EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.cc

@@ -107,6 +107,7 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
   edm::ESHandle<HcalElectronicsMap> item;
   es.get<HcalElectronicsMapRcd>().get(electronicsMapLabel_, item);
   const HcalElectronicsMap* readoutMap = item.product();
+  filter_.setConditions(pSetup.product());
 
   // Step B: Create empty output  : three vectors for three classes...
   std::vector<HBHEDataFrame> hbhe;
@@ -223,10 +224,14 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
     HBHEDigiCollection filtered_hbhe=filter_.filter(*hbhe_prod,*report);
     HODigiCollection filtered_ho=filter_.filter(*ho_prod,*report);
     HFDigiCollection filtered_hf=filter_.filter(*hf_prod,*report);
+    QIE10DigiCollection filtered_qie10=filter_.filter(*qie10_prod,*report);
+    QIE11DigiCollection filtered_qie11=filter_.filter(*qie11_prod,*report);
 
     hbhe_prod->swap(filtered_hbhe);
     ho_prod->swap(filtered_ho);
     hf_prod->swap(filtered_hf);    
+    qie10_prod->swap(filtered_qie10);
+    qie11_prod->swap(filtered_qie11);
   }
 
 

EventFilter/HcalRawToDigi/src/HcalDataFrameFilter.cc

@@ -1,4 +1,8 @@
 #include "EventFilter/HcalRawToDigi/interface/HcalDataFrameFilter.h"
+#include "CalibFormats/HcalObjects/interface/HcalCoderDb.h"
+#include "CalibFormats/CaloObjects/interface/CaloSamples.h"
+#include "CondFormats/HcalObjects/interface/HcalQIECoder.h"
+#include "CondFormats/HcalObjects/interface/HcalQIEShape.h"
 
 namespace HcalDataFrameFilter_impl {
 
@@ -18,20 +22,56 @@ namespace HcalDataFrameFilter_impl {
     return true;
   }
 
+  template<>
+  bool check<QIE10DataFrame>(const QIE10DataFrame& df, bool capcheck, bool linkerrcheck) {
+    if (linkerrcheck && df.linkError()) return false;
+    if (capcheck) {
+      for (int i=0; i<df.samples(); i++) {
+	if (!df[i].ok()) return false;
+      }
+    }
+    return true;
+  }
+
+  template<>
+  bool check<QIE11DataFrame>(const QIE11DataFrame& df, bool capcheck, bool linkerrcheck) {
+    if (linkerrcheck && df.linkError()) return false;
+    if (capcheck && df.capidError()) return false;
+    return true;
+  }
+
+
   template <class DataFrame> 
-  double energySum(const DataFrame& df, int fs, int ls) {
+  double energySum(const DataFrame& df, int fs, int ls, const HcalDbService* conditions=nullptr) {
     double es=0;
     for (int i=fs; i<=ls && i<=df.size(); i++) 
       es+=df[i].nominal_fC();
     return es;
   }
 
+  template <>
+  double energySum<QIE11DataFrame>(const QIE11DataFrame& df, int fs, int ls, const HcalDbService* conditions) {
+    const HcalQIECoder* channelCoder = conditions->getHcalCoder(df.id());
+    const HcalQIEShape* shape = conditions->getHcalShape(channelCoder);
+    CaloSamples tool;
+    HcalCoderDb coder(*channelCoder, *shape);
+    coder.adc2fC(df, tool);
+    double es=0;
+    for (int i=fs; i<=ls && i<=(int)df.samples(); i++)
+      es+=tool[i];
+    return es;
+  }
+
 }
 
 
 HcalDataFrameFilter::HcalDataFrameFilter(bool requireCapid, bool requireDVER, bool energyFilter, int firstSample, int lastSample, double minAmpl) :
   requireCapid_(requireCapid), requireDVER_(requireDVER), energyFilter_(energyFilter),
-  firstSample_(firstSample), lastSample_(lastSample), minimumAmplitude_(minAmpl) {
+  firstSample_(firstSample), lastSample_(lastSample), minimumAmplitude_(minAmpl), conditions_(nullptr) {
+}
+
+void HcalDataFrameFilter::setConditions(const HcalDbService* conditions) {
+  conditions_ = conditions;
 }
 
 HBHEDigiCollection HcalDataFrameFilter::filter(const HBHEDigiCollection& incol, HcalUnpackerReport& r) {
@@ -92,6 +132,31 @@ ZDCDigiCollection HcalDataFrameFilter::filter(const ZDCDigiCollection& incol, Hc
   return output;
 }
 
+QIE10DigiCollection HcalDataFrameFilter::filter(const QIE10DigiCollection& incol, HcalUnpackerReport& r) {
+  QIE10DigiCollection output(incol.samples());
+  for (QIE10DigiCollection::const_iterator i=incol.begin(); i!=incol.end(); i++) {
+    QIE10DataFrame df(*i);
+    if (!HcalDataFrameFilter_impl::check(df,requireCapid_,requireDVER_))
+      r.countBadQualityDigi(i->id());
+    // Never exclude QIE10 digis as their absence would be
+    // treated as a digi with zero charged deposited in that channel
+    output.push_back(df);
+  }
+  return output;
+}
+
+QIE11DigiCollection HcalDataFrameFilter::filter(const QIE11DigiCollection& incol, HcalUnpackerReport& r) {
+  QIE11DigiCollection output(incol.samples());
+  for (QIE11DigiCollection::const_iterator i=incol.begin(); i!=incol.end(); i++) {
+    QIE11DataFrame df(*i);
+    if (!HcalDataFrameFilter_impl::check(df,requireCapid_,requireDVER_))
+      r.countBadQualityDigi(i->id());
+    else if (!energyFilter_ || minimumAmplitude_<HcalDataFrameFilter_impl::energySum(df,firstSample_,lastSample_,conditions_))
+      output.push_back(df);
+  }
+  return output;
+}
+
 
 bool HcalDataFrameFilter::active() const {
   return requireCapid_|requireDVER_|energyFilter_;