Add the possibility of a FrontEnd map for HCAL

CalibCalorimetry/HcalAlgos/interface/HcalDbASCIIIO.h

@@ -34,6 +34,8 @@ Text file formats for different data types is as following:
   if electronics channel is known to be unconnected, either "subdet" or "eta" should be NA
 - HcalDcsMap:
   line# Ring Slice Subchannel Type Subdetector Eta Phi Depth
+- HcalFrontEndMap:
+  eta(int)  phi(int) depth(int) det(HB,HE,HF) RM# RBX#
 */
 namespace HcalDbASCIIIO {
   bool getObject (std::istream& fInput, HcalPedestals* fObject);
@@ -66,6 +68,8 @@ namespace HcalDbASCIIIO {
   bool dumpObject (std::ostream& fOutput, const HcalZSThresholds& fObject);
   bool getObject (std::istream& fInput, HcalL1TriggerObjects* fObject);
   bool dumpObject (std::ostream& fOutput, const HcalL1TriggerObjects& fObject);
+  bool getObject (std::istream& fInput, HcalFrontEndMap* fObject);
+  bool dumpObject (std::ostream& fOutput, const HcalFrontEndMap& fObject);
 
   bool getObject (std::istream& fInput, HcalValidationCorrs* fObject);
   bool dumpObject (std::ostream& fOutput, const HcalValidationCorrs& fObject);

CalibCalorimetry/HcalAlgos/interface/HcalDbHardcode.h

@@ -16,6 +16,7 @@
 #include "CondFormats/HcalObjects/interface/HcalQIEType.h"
 #include "CondFormats/HcalObjects/interface/HcalCalibrationQIECoder.h"
 #include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h"
+#include "CondFormats/HcalObjects/interface/HcalFrontEndMap.h"
 #include "DataFormats/HcalDetId/interface/HcalDcsDetId.h"
 #include "CondFormats/HcalObjects/interface/HcalDcsMap.h"
 #include "CondFormats/HcalObjects/interface/HcalRecoParam.h"

CalibCalorimetry/HcalAlgos/src/HcalDbASCIIIO.cc

@@ -1204,7 +1204,7 @@ bool HcalDbASCIIIO::getObject (std::istream& fInput, HcalQIEData* fObject) {
 }
 
 bool HcalDbASCIIIO::dumpObject (std::ostream& fOutput, const HcalQIEData& fObject) {
-  std::cout <<"dumping object\n";
+
   char buffer [1024];
 
   fOutput << "# QIE data" << std::endl;
@@ -1838,3 +1838,46 @@ bool HcalDbASCIIIO::dumpObject (std::ostream& fOutput, const HcalFlagHFDigiTimeP
 }
 
 
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+bool HcalDbASCIIIO::getObject (std::istream& fInput, HcalFrontEndMap* fObject) {
+  char buffer [1024];
+  unsigned int all(0), good(0);
+  while (fInput.getline(buffer, 1024)) {
+    ++all;
+    if (buffer [0] == '#') continue; //ignore comment
+    std::vector <std::string> items = splitString (std::string (buffer));
+    if (items.size () != 6) {
+      edm::LogError("MapFormat") << "HcalFrontEndMap-> line ignored: " << buffer;
+      continue;
+    }
+    ++good;
+    //    std::cout << "HcalFrontEndMap-> processing line: " << buffer << std::endl;
+    DetId id = HcalDbASCIIIO::getId (items);
+    int   rm = atoi (items [5].c_str());
+    fObject->loadObject (id, rm, items[4]);
+  }
+  fObject->sort ();
+  edm::LogInfo("MapFormat") << "HcalFrontEndMap:: processed " << good << " records in " << all << " record" << std::endl;
+  return true;
+}
+
+bool HcalDbASCIIIO::dumpObject (std::ostream& fOutput, const HcalFrontEndMap& fObject) {
+
+  char buffer [1024];
+  sprintf (buffer, "# %15s %15s %15s %15s %8s %8s\n", "eta", "phi", "dep", "det", "rbx", "rm");
+  fOutput << buffer;
+
+  std::vector<DetId> channels = fObject.allDetIds();
+  std::sort (channels.begin(), channels.end(), DetIdLess ());
+  for (std::vector<DetId>::iterator channel = channels.begin ();
+       channel !=  channels.end (); ++channel) {
+    const std::string rbx = fObject.lookupRBX(*channel);
+    const int         rm  = fObject.lookupRM(*channel);
+    dumpId (fOutput, *channel);
+    sprintf (buffer, " %8s %8d \n", rbx.c_str(), rm);
+    fOutput << buffer;
+  }
+  return true;
+  return true;
+}
+

CalibCalorimetry/HcalPlugins/src/HcalDbProducer.cc

@@ -60,6 +60,7 @@ HcalDbProducer::HcalDbProducer( const edm::ParameterSet& fConfig)
 			  &HcalDbProducer::zsThresholdsCallback &
 			  &HcalDbProducer::L1triggerObjectsCallback &
 			  &HcalDbProducer::electronicsMapCallback &
+			  &HcalDbProducer::frontEndMapCallback &
 			  &HcalDbProducer::lutMetadataCallback 
 			  )
 		   );
@@ -350,6 +351,16 @@ void HcalDbProducer::electronicsMapCallback (const HcalElectronicsMapRcd& fRecor
   }
 }
 
+void HcalDbProducer::frontEndMapCallback (const HcalFrontEndMapRcd& fRecord) {
+  edm::ESHandle <HcalFrontEndMap> item;
+  fRecord.get (item);
+  mService->setData (item.product ());
+  if (std::find (mDumpRequest.begin(), mDumpRequest.end(), std::string ("FrontEndMap")) != mDumpRequest.end()) {
+    *mDumpStream << "New HCAL FrontEnd Map set" << std::endl;
+    HcalDbASCIIIO::dumpObject (*mDumpStream, *(item.product ()));
+  }
+}
+
 void HcalDbProducer::lutMetadataCallback (const HcalLutMetadataRcd& fRecord) {
   edm::ESTransientHandle <HcalLutMetadata> item;
   fRecord.get (item);

CalibCalorimetry/HcalPlugins/src/HcalDbProducer.h

@@ -52,6 +52,7 @@ class HcalDbProducer : public edm::ESProducer {
   void respCorrsCallback (const HcalRespCorrsRcd& fRecord);
   void L1triggerObjectsCallback (const HcalL1TriggerObjectsRcd& fRecord);
   void electronicsMapCallback (const HcalElectronicsMapRcd& fRecord);
+  void frontEndMapCallback (const HcalFrontEndMapRcd& fRecord);
   void timeCorrsCallback (const HcalTimeCorrsRcd& fRecord);
   void LUTCorrsCallback (const HcalLUTCorrsRcd& fRecord);
   void PFCorrsCallback (const HcalPFCorrsRcd& fRecord);

CalibCalorimetry/HcalPlugins/src/HcalTextCalibrations.cc

@@ -35,6 +35,7 @@ HcalTextCalibrations::HcalTextCalibrations ( const edm::ParameterSet& iConfig )
     std::string objectName = request->getParameter<std::string> ("object");
     edm::FileInPath fp = request->getParameter<edm::FileInPath>("file");
     mInputs [objectName] = fp.fullPath();
+//   std::cout << objectName << " with file " << fp.fullPath() << std::endl;
     if (objectName == "Pedestals") {
       setWhatProduced (this, &HcalTextCalibrations::producePedestals);
       findingRecord <HcalPedestalsRcd> ();
@@ -91,6 +92,10 @@ HcalTextCalibrations::HcalTextCalibrations ( const edm::ParameterSet& iConfig )
       setWhatProduced (this, &HcalTextCalibrations::produceElectronicsMap);
       findingRecord <HcalElectronicsMapRcd> ();
     }
+    else if (objectName == "FrontEndMap") {
+      setWhatProduced (this, &HcalTextCalibrations::produceFrontEndMap);
+      findingRecord <HcalFrontEndMapRcd> ();
+    }
     else if (objectName == "ValidationCorrs") {
       setWhatProduced (this, &HcalTextCalibrations::produceValidationCorrs);
       findingRecord <HcalValidationCorrsRcd> ();
@@ -143,7 +148,7 @@ HcalTextCalibrations::HcalTextCalibrations ( const edm::ParameterSet& iConfig )
       std::cerr << "HcalTextCalibrations-> Unknown object name '" << objectName 
 		<< "', known names are: "
 		<< "Pedestals PedestalWidths Gains GainWidths QIEData QIETypes ChannelQuality ElectronicsMap "
-		<< "ZSThresholds RespCorrs LUTCorrs PFCorrs TimeCorrs L1TriggerObjects "
+		<< "FrontEndMap ZSThresholds RespCorrs LUTCorrs PFCorrs TimeCorrs L1TriggerObjects "
 		<< "ValidationCorrs LutMetadata DcsValues DcsMap CholeskyMatrices CovarianceMatrices "
 		<< "RecoParams LongRecoParams ZDCLowGainFraction FlagHFDigiTimeParams MCParams "
 		<< std::endl;
@@ -296,6 +301,10 @@ std::unique_ptr<HcalElectronicsMap> HcalTextCalibrations::produceElectronicsMap
   return produce_impl<HcalElectronicsMap> (mInputs ["ElectronicsMap"]);
 }
 
+std::unique_ptr<HcalFrontEndMap> HcalTextCalibrations::produceFrontEndMap (const HcalFrontEndMapRcd& rcd) {
+  return produce_impl<HcalFrontEndMap> (mInputs ["FrontEndMap"]);
+}
+
 std::unique_ptr<HcalValidationCorrs> HcalTextCalibrations::produceValidationCorrs (const HcalValidationCorrsRcd& rcd) {
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);

CalibCalorimetry/HcalPlugins/src/HcalTextCalibrations.h

@@ -20,6 +20,7 @@ class HcalQIEDataRcd;
 class HcalQIETypesRcd;
 class HcalChannelQualityRcd;
 class HcalElectronicsMapRcd;
+class HcalFrontEndMapRcd;
 class HcalRespCorrsRcd;
 class HcalTimeCorrsRcd;
 class HcalLUTCorrsRcd;
@@ -40,7 +41,7 @@ class HcalFlagHFDigiTimeParamsRcd;
 class HcalTimingParamsRcd;
 
 class HcalTextCalibrations : public edm::ESProducer,
-		       public edm::EventSetupRecordIntervalFinder
+  public edm::EventSetupRecordIntervalFinder
 {
 public:
   HcalTextCalibrations (const edm::ParameterSet& );
@@ -61,6 +62,7 @@ class HcalTextCalibrations : public edm::ESProducer,
   std::unique_ptr<HcalQIETypes> produceQIETypes (const HcalQIETypesRcd& rcd);
   std::unique_ptr<HcalChannelQuality> produceChannelQuality (const HcalChannelQualityRcd& rcd);
   std::unique_ptr<HcalElectronicsMap> produceElectronicsMap (const HcalElectronicsMapRcd& rcd);
+  std::unique_ptr<HcalFrontEndMap> produceFrontEndMap (const HcalFrontEndMapRcd& rcd);
 
   std::unique_ptr<HcalRespCorrs> produceRespCorrs (const HcalRespCorrsRcd& rcd);
   std::unique_ptr<HcalZSThresholds> produceZSThresholds (const HcalZSThresholdsRcd& rcd);

CalibFormats/HcalObjects/interface/HcalDbRecord.h

@@ -30,7 +30,7 @@ class HcalDbRecord : public edm::eventsetup::DependentRecordImplementation <Hcal
   boost::mpl::vector<IdealGeometryRecord, HcalPedestalsRcd, HcalPedestalWidthsRcd, HcalGainsRcd, HcalGainWidthsRcd, 
   HcalQIEDataRcd, HcalQIETypesRcd, HcalChannelQualityRcd, HcalZSThresholdsRcd, HcalRespCorrsRcd, 
   HcalL1TriggerObjectsRcd, HcalElectronicsMapRcd, HcalTimeCorrsRcd, HcalLUTCorrsRcd, HcalPFCorrsRcd,
-  HcalLutMetadataRcd > > {}; 
+  HcalFrontEndMapRcd, HcalLutMetadataRcd > > {}; 
 
 #endif /* HCALDBPRODUCER_HCALDBRECORD_H */
 

CalibFormats/HcalObjects/interface/HcalDbService.h

@@ -41,6 +41,7 @@ class HcalDbService {
   const HcalQIEShape* getHcalShape (const HcalGenericDetId& fId) const;
   const HcalQIEShape* getHcalShape (const HcalQIECoder *coder) const;
   const HcalElectronicsMap* getHcalMapping () const;
+  const HcalFrontEndMap* getHcalFrontEndMapping () const;
   const HcalRespCorr* getHcalRespCorr (const HcalGenericDetId& fId) const;
   const HcalTimeCorr* getHcalTimeCorr (const HcalGenericDetId& fId) const;
   const HcalL1TriggerObject* getHcalL1TriggerObject (const HcalGenericDetId& fId) const;
@@ -59,6 +60,7 @@ class HcalDbService {
   void setData (const HcalQIETypes* fItem) {mQIETypes = fItem; mCalibSet = nullptr; }
   void setData (const HcalChannelQuality* fItem) {mChannelQuality = fItem;}
   void setData (const HcalElectronicsMap* fItem) {mElectronicsMap = fItem;}
+  void setData (const HcalFrontEndMap* fItem) {mFrontEndMap = fItem;}
   void setData (const HcalRespCorrs* fItem) {mRespCorrs = fItem; mCalibSet = nullptr; }
   void setData (const HcalTimeCorrs* fItem) {mTimeCorrs = fItem; mCalibSet = nullptr; }
   void setData (const HcalZSThresholds* fItem) {mZSThresholds = fItem;}
@@ -82,6 +84,7 @@ class HcalDbService {
   const HcalQIETypes* mQIETypes;
   const HcalChannelQuality* mChannelQuality;
   const HcalElectronicsMap* mElectronicsMap;
+  const HcalFrontEndMap* mFrontEndMap;
   const HcalRespCorrs* mRespCorrs;
   const HcalZSThresholds* mZSThresholds;
   const HcalL1TriggerObjects* mL1TriggerObjects;

CalibFormats/HcalObjects/src/HcalDbService.cc

@@ -18,7 +18,7 @@ HcalDbService::HcalDbService (const edm::ParameterSet& cfg):
   mGains (0), mGainWidths (0),  
   mQIEData(0),
   mQIETypes(0),
-  mElectronicsMap(0),
+  mElectronicsMap(0), mFrontEndMap(0),
   mRespCorrs(0),
   mL1TriggerObjects(0),
   mTimeCorrs(0),
@@ -251,6 +251,10 @@ const HcalElectronicsMap* HcalDbService::getHcalMapping () const {
   return mElectronicsMap;
 }
 
+const HcalFrontEndMap* HcalDbService::getHcalFrontEndMapping () const {
+  return mFrontEndMap;
+}
+
 const HcalL1TriggerObject* HcalDbService::getHcalL1TriggerObject (const HcalGenericDetId& fId) const
 {
   return mL1TriggerObjects->getValues (fId);

CondCore/HcalPlugins/src/plugin.cc

@@ -44,6 +44,7 @@ REGISTER_PLUGIN(HcalPedestalWidthsRcd,HcalPedestalWidths);
 REGISTER_PLUGIN(HcalGainsRcd,HcalGains);
 REGISTER_PLUGIN(HcalGainWidthsRcd,HcalGainWidths);
 REGISTER_PLUGIN(HcalElectronicsMapRcd,HcalElectronicsMap);
+REGISTER_PLUGIN(HcalFrontEndMapRcd,HcalFrontEndMap);
 REGISTER_PLUGIN(HcalChannelQualityRcd,HcalChannelQuality);
 REGISTER_PLUGIN(HcalQIEDataRcd,HcalQIEData);
 REGISTER_PLUGIN(HcalQIETypesRcd,HcalQIETypes);

CondFormats/DataRecord/interface/HcalAllRcds.h

@@ -4,6 +4,7 @@
 #include "CondFormats/DataRecord/interface/HcalCalibrationQIEDataRcd.h"
 #include "CondFormats/DataRecord/interface/HcalChannelQualityRcd.h"
 #include "CondFormats/DataRecord/interface/HcalElectronicsMapRcd.h"
+#include "CondFormats/DataRecord/interface/HcalFrontEndMapRcd.h"
 #include "CondFormats/DataRecord/interface/HcalGainsRcd.h"
 #include "CondFormats/DataRecord/interface/HcalGainWidthsRcd.h"
 #include "CondFormats/DataRecord/interface/HcalL1TriggerObjectsRcd.h"

CondFormats/DataRecord/interface/HcalFrontEndMapRcd.h

@@ -0,0 +1,5 @@
+#ifndef HcalFrontEndMapRcd_H
+#define HcalFrontEndMapRcd_H
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+class HcalFrontEndMapRcd : public edm::eventsetup::EventSetupRecordImplementation<HcalFrontEndMapRcd> {};
+#endif

CondFormats/DataRecord/src/HcalFrontEndMapRcd.cc

@@ -0,0 +1,3 @@
+#include "CondFormats/DataRecord/interface/HcalFrontEndMapRcd.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+EVENTSETUP_RECORD_REG(HcalFrontEndMapRcd);

CondFormats/HcalObjects/interface/AllObjects.h

@@ -36,5 +36,5 @@
 #include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h"
 #include "CondFormats/HcalObjects/interface/HBHEChannelGroups.h"
 #include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h"
-
+#include "CondFormats/HcalObjects/interface/HcalFrontEndMap.h"
 #endif

CondFormats/HcalObjects/interface/HcalFrontEndMap.h

@@ -0,0 +1,76 @@
+#ifndef HcalFrontEndMap_h
+#define HcalFrontEndMap_h
+
+#include "CondFormats/Serialization/interface/Serializable.h"
+
+#include <vector>
+#include <algorithm>
+#include <boost/cstdint.hpp>
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
+#include <atomic>
+#endif
+
+#include "DataFormats/DetId/interface/DetId.h"
+#include "DataFormats/HcalDetId/interface/HcalDetId.h"
+// 
+class HcalFrontEndMap {
+public:
+  HcalFrontEndMap();
+  ~HcalFrontEndMap();
+
+  // swap function
+  void swap(HcalFrontEndMap& other);
+  // copy-ctor
+  HcalFrontEndMap(const HcalFrontEndMap& src);
+  // copy assignment operator
+  HcalFrontEndMap& operator=(const HcalFrontEndMap& rhs);
+  // move constructor
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
+  HcalFrontEndMap(HcalFrontEndMap&& other);
+#endif
+
+  /// load a new entry
+  bool loadObject(DetId fId, int rm, std::string rbx);
+
+  /// brief lookup the RM associated with the given logical id
+  //return Null item if no such mapping
+  const int lookupRM(DetId fId) const;
+
+  /// brief lookup the RBX associated with the given logical id
+  //return Null item if no such mapping
+  const std::string lookupRBX(DetId fId) const;
+  const int         lookupRBXIndex(DetId fId) const;
+
+  std::vector <DetId>       allDetIds() const;
+  std::vector <int>         allRMs() const;
+  std::vector <std::string> allRBXs() const;
+
+  // sorting
+  void sortById () const;
+  void sort() {}
+
+  class PrecisionItem { 
+  public:
+    PrecisionItem () {mId = mRM = 0; mRBX = "";}
+    PrecisionItem (uint32_t fId, int fRM, std::string fRBX) 
+      : mId (fId), mRM (fRM), mRBX (fRBX) {}
+    uint32_t    mId;
+    int         mRM;
+    std::string mRBX;
+
+    COND_SERIALIZABLE;
+  };
+protected:
+  const PrecisionItem* findById (uint32_t fId) const;
+
+  std::vector<PrecisionItem> mPItems;
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
+  mutable std::atomic<std::vector<const PrecisionItem*>*> mPItemsById COND_TRANSIENT;
+#else
+  mutable std::vector<const PrecisionItem*>* mPItemsById COND_TRANSIENT;
+#endif
+
+  COND_SERIALIZABLE;
+};
+
+#endif