Merge pull request #22385 from jkunkle/HcalUnpackerUpdates

Create new collection for Hcal lasermon digis + Hcal unpacker updates

CalibFormats/HcalObjects/src/HcalText2DetIdConverter.cc

@@ -148,6 +148,11 @@ bool HcalText2DetIdConverter::init (DetId fId) {
       setField (1, calibId.channel());
       setField (2, -999);
       setField (3, -999);
+    } else if (calibId.calibFlavor()==HcalCalibDetId::LASERMON) {
+      flavorName="LASMON";
+      setField (1, calibId.ieta());
+      setField (2, calibId.iphi());
+      setField (3, calibId.cboxChannel() );
     } else if (calibId.calibFlavor()==HcalCalibDetId::CastorRadFacility) {
       flavorName="CRF";
       setField (1, calibId.rm());
@@ -233,6 +238,12 @@ bool HcalText2DetIdConverter::init (const std::string& fFlavor, const std::strin
     int channel=getField(1);
     mId = HcalCalibDetId (HcalCalibDetId::uMNqie,channel);
   }
+  else if (flavorName == "LASMON" ) {
+    int ieta = getField(1);
+    int iphi = getField(2);
+    int channel = getField(3);
+    mId = HcalCalibDetId (HcalCalibDetId::LASERMON, ieta, iphi, channel);
+  }
   else if (flavorName=="CRF") {
     int rm=getField(1);
     int fiber=getField(2);

DataFormats/HcalDetId/interface/HcalCalibDetId.h

@@ -35,7 +35,7 @@
 class HcalCalibDetId : public HcalOtherDetId {
 public:
   /** Type identifier within calibration det ids */
-  enum CalibDetType { CalibrationBox = 1, HOCrosstalk = 2, uMNqie = 3, CastorRadFacility = 4 };
+  enum CalibDetType { CalibrationBox = 1, HOCrosstalk = 2, uMNqie = 3, CastorRadFacility = 4, LASERMON = 5 };
 
   /** Create a null det id */
   HcalCalibDetId();

DataFormats/HcalDetId/src/HcalCalibDetId.cc

@@ -67,19 +67,19 @@ HcalCalibDetId& HcalCalibDetId::operator=(const DetId& gen) {
 }
 
 int HcalCalibDetId::cboxChannel() const {
-  return (calibFlavor()==CalibrationBox)?(id_&0xF):(0);
+  return (calibFlavor()==CalibrationBox || calibFlavor() == LASERMON)?(id_&0xF):(0);
 }
 
 HcalSubdetector HcalCalibDetId::hcalSubdet() const {  
   return (HcalSubdetector)((calibFlavor()==CalibrationBox)?((id_>>14)&0x7):(0));
 }
 
 int HcalCalibDetId::ieta() const {
-  return (calibFlavor()==CalibrationBox)?(((id_>>11)&0x7)-2):((calibFlavor()==HOCrosstalk)?(((id_>>7)&0xF)*zside()):(0));
+  return (calibFlavor()==CalibrationBox)?(((id_>>11)&0x7)-2):((calibFlavor()==HOCrosstalk)?(((id_>>7)&0xF)*zside()):(calibFlavor()==LASERMON?((id_>>10)&0x3F):(0)));
 }
 
 int HcalCalibDetId::iphi() const {
-  return (calibFlavor()==CalibrationBox)?((id_>>4)&0x7F):((calibFlavor()==HOCrosstalk)?(id_&0x7F):(0));
+  return (calibFlavor()==CalibrationBox)?((id_>>4)&0x7F):((calibFlavor()==HOCrosstalk)?(id_&0x7F):(calibFlavor()==LASERMON?((id_>>5)&0x1F):(0)));
 }
 
 int HcalCalibDetId::zside() const {
@@ -126,6 +126,8 @@ std::ostream& operator<<(std::ostream& s,const HcalCalibDetId& id) {
 	     << ')';
   case (HcalCalibDetId::uMNqie):
     return s << "(uMNqie " << id.channel() << ')';
+  case (HcalCalibDetId::LASERMON):
+    return s << "(LASERMON" << id.channel() << ')';
   case (HcalCalibDetId::CastorRadFacility):
     return s << "(CastorRadFacility " << id.rm() << " / " << id.fiber() << " / " << id.channel() << ')';
   default: return s;

EventFilter/HcalRawToDigi/interface/HcalUnpacker.h

@@ -33,13 +33,17 @@ class HcalUnpacker {
     std::vector<HcalTTPDigi>* ttp;
     QIE10DigiCollection* qie10;
     QIE10DigiCollection* qie10ZDC;
+    QIE10DigiCollection* qie10Lasermon;
     QIE11DigiCollection* qie11;
+    // additional qie10 and qie11 data collections
+    std::unordered_map<int, QIE10DigiCollection*> qie10Addtl;
+    std::unordered_map<int, QIE11DigiCollection*> qie11Addtl;
     HcalUMNioDigi* umnio;
 
   };
 
   /// for normal data
-  HcalUnpacker(int sourceIdOffset, int beg, int end) : sourceIdOffset_(sourceIdOffset), startSample_(beg), endSample_(end), expectedOrbitMessageTime_(-1), mode_(0) { }
+  HcalUnpacker(int sourceIdOffset, int beg, int end) : sourceIdOffset_(sourceIdOffset), startSample_(beg), endSample_(end), expectedOrbitMessageTime_(-1), mode_(0), nPrinted_ (0){ }
   /// For histograms, no begin and end
   HcalUnpacker(int sourceIdOffset) : sourceIdOffset_(sourceIdOffset), startSample_(-1), endSample_(-1),  expectedOrbitMessageTime_(-1), mode_(0) { }
   void setExpectedOrbitMessageTime(int time) { expectedOrbitMessageTime_=time; }
@@ -51,13 +55,16 @@ class HcalUnpacker {
   void unpackUTCA(const FEDRawData& raw, const HcalElectronicsMap& emap, Collections& conts, HcalUnpackerReport& report, bool silent=false);
   void unpackUMNio(const FEDRawData& raw, int slot, Collections& colls);
 
+  void printInvalidDataMessage( const std::string &coll_type, int default_ns, int conflict_ns, bool extended=false );
 
   int sourceIdOffset_; ///< number to subtract from the source id to get the dcc id
   int startSample_; ///< first sample from fed raw data to copy 
   int endSample_; ///< last sample from fed raw data to copy (if present)
   int expectedOrbitMessageTime_; ///< Expected orbit bunch time (needed to evaluate time differences)
   int mode_;
   std::set<HcalElectronicsId> unknownIds_,unknownIdsTrig_; ///< Recorded to limit number of times a log message is generated
+
+  int nPrinted_;
 };
 
 #endif // HcalUnpacker_h_included

EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.cc

@@ -23,6 +23,10 @@ HcalRawToDigi::HcalRawToDigi(edm::ParameterSet const& conf):
   unpackZDC_(conf.getUntrackedParameter<bool>("UnpackZDC",false)),
   unpackTTP_(conf.getUntrackedParameter<bool>("UnpackTTP",false)),
   unpackUMNio_(conf.getUntrackedParameter<bool>("UnpackUMNio",false)),
+  saveQIE10DataNSamples_(conf.getUntrackedParameter<std::vector<int> >("saveQIE10DataNSamples", std::vector<int>())),
+  saveQIE10DataTags_(conf.getUntrackedParameter<std::vector<std::string> >("saveQIE10DataTags", std::vector<std::string>())),
+  saveQIE11DataNSamples_(conf.getUntrackedParameter<std::vector<int> >("saveQIE11DataNSamples", std::vector<int>())),
+  saveQIE11DataTags_(conf.getUntrackedParameter<std::vector<std::string> >("saveQIE11DataTags", std::vector<std::string>())),
   silent_(conf.getUntrackedParameter<bool>("silent",true)),
   complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData",false)),
   unpackerMode_(conf.getUntrackedParameter<int>("UnpackerMode",0)),
@@ -65,8 +69,68 @@ HcalRawToDigi::HcalRawToDigi(edm::ParameterSet const& conf):
     produces<HcalUMNioDigi>();
   produces<QIE10DigiCollection>();
   produces<QIE11DigiCollection>();
+
   produces<QIE10DigiCollection>("ZDC");
-
+  produces<QIE10DigiCollection>("LASERMON");
+
+  // Print a warning if an already
+  // used tag was requested
+  if( std::find( saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "ZDC") 
+          != saveQIE10DataTags_.end()  ) {
+    edm::LogWarning("HcalRawToDigi") << "Cannot create an additional QIE10 sample with name ZDC, it is already created!  It must be removed along with the corresponding entry in saveQIE10DataNSamples" << std::endl;
+    saveQIE10DataTags_.clear();
+    saveQIE10DataNSamples_.clear();
+  }
+  // Print a warning if an already
+  // used tag was requested
+  if( std::find( saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "LASERMON") 
+          != saveQIE10DataTags_.end()  ) {
+    edm::LogWarning("HcalRawToDigi") << "Cannot create an additional QIE10 sample with name LASERMON, it is already created!  It must be removed along with the corresponding entry in saveQIE10DataNSamples" << std::endl;
+    saveQIE10DataTags_.clear();
+    saveQIE10DataNSamples_.clear();
+  }
+
+  // Print a warning if the two vectors
+  // for additional qie10 or qie11 data
+  // are not the same length
+  if( saveQIE10DataTags_.size() != saveQIE10DataNSamples_.size() ) {
+    edm::LogWarning("HcalRawToDigi") << "The saveQIE10DataTags and saveQIE10DataNSamples inputs must be the same length!  These will be ignored" << std::endl;
+    saveQIE10DataTags_.clear();
+    saveQIE10DataNSamples_.clear();
+  }
+  if( saveQIE11DataTags_.size() != saveQIE11DataNSamples_.size() ) {
+    edm::LogWarning("HcalRawToDigi") << "The saveQIE11DataTags and saveQIE11DataNSamples inputs must be the same length!  These will be ignored" << std::endl;
+    saveQIE11DataTags_.clear();
+    saveQIE11DataNSamples_.clear();
+  }
+
+
+  // If additional qie10 samples were requested,
+  // declare that we will produce this collection
+  // with the given tag.  Also store the map
+  // from nSamples to tag for later use
+  for( unsigned idx = 0; idx < saveQIE10DataNSamples_.size(); ++idx ) {
+      int nsamples = saveQIE10DataNSamples_[idx];
+      std::string tag = saveQIE10DataTags_[idx];
+
+      produces<QIE10DigiCollection>(tag);
+
+      saveQIE10Info_[nsamples] = tag;
+  }
+
+  // If additional qie11 samples were requested,
+  // declare that we will produce this collection
+  // with the given tag.  Also store the map
+  // from nSamples to tag for later use
+  for( unsigned idx = 0; idx < saveQIE11DataNSamples_.size(); ++idx ) {
+      int nsamples = saveQIE11DataNSamples_[idx];
+      std::string tag = saveQIE11DataTags_[idx];
+
+      produces<QIE11DigiCollection>(tag);
+
+      saveQIE11Info_[nsamples] = tag;
+  }
+
   memset(&stats_,0,sizeof(stats_));
 
 }
@@ -86,6 +150,10 @@ void HcalRawToDigi::fillDescriptions(edm::ConfigurationDescriptions& description
   desc.addUntracked<bool>("UnpackUMNio",true);
   desc.addUntracked<bool>("UnpackTTP",true);
   desc.addUntracked<bool>("silent",true);
+  desc.addUntracked<std::vector<int> >("saveQIE10DataNSamples", std::vector<int>());
+  desc.addUntracked<std::vector<std::string> >("saveQIE10DataTags", std::vector<std::string>());
+  desc.addUntracked<std::vector<int> >("saveQIE11DataNSamples", std::vector<int>());
+  desc.addUntracked<std::vector<std::string> >("saveQIE11DataTags", std::vector<std::string>());
   desc.addUntracked<bool>("ComplainEmptyData",false);
   desc.addUntracked<int>("UnpackerMode",0);
   desc.addUntracked<int>("ExpectedOrbitMessageTime",-1);
@@ -142,7 +210,17 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
   colls.zdcCont=&zdc;
   colls.umnio=&umnio;
   if (unpackTTP_) colls.ttp=&ttp;
-
+
+  // make an entry for each additional qie10 collection that is requested
+  for( const auto &info : saveQIE10Info_ ) {
+      colls.qie10Addtl[info.first] = new QIE10DigiCollection(info.first);
+  }
+
+  // make an entry for each additional qie11 collection that is requested
+  for( const auto &info : saveQIE11Info_ ) {
+      colls.qie11Addtl[info.first] = new QIE11DigiCollection(info.first);
+  }
+
   // Step C: unpack all requested FEDs
   for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
     const FEDRawData& fed = rawraw->FEDData(*i);
@@ -194,25 +272,72 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
   }
   if( cntHFdup ) edm::LogError("HcalRawToDigi") << "Duplicated HF digis found for "<<cntHFdup<<" times"<<std::endl;
 
+  // Check that additional QIE10 and QIE11 collections
+  // do not duplicate the default collections
+  for( const auto & addtl: colls.qie10Addtl ) {
+      if( addtl.second->samples() == colls.qie10->samples() ) {
+          std::string tag = saveQIE10Info_[addtl.second->samples()];
+          edm::LogWarning("HcalRawToDigi") << "QIE10 data requested to be stored in tag " 
+              << tag << " is already stored in the default QIE10 collection.  "
+              << "To avoid duplicating, remove the tag " << tag 
+              << " from the saveQIE10DataTags and the value of " 
+              << addtl.second->samples() << " from the saveQIE10DataNSamples "
+              << "configurables to HcalRawToDigi" << std::endl;
+      }
+  }
+  for( const auto & addtl: colls.qie11Addtl ) {
+      if( addtl.second->samples() == colls.qie11->samples() ) {
+          std::string tag = saveQIE11Info_[addtl.second->samples()];
+          edm::LogWarning("HcalRawToDigi") << "QIE11 data requested to be stored in tag " 
+              << tag << " is already stored in the default QIE11 collection.  "
+              << "To avoid duplicating, remove the tag " << tag 
+              << " from the saveQIE11DataTags and the value of " 
+              << addtl.second->samples() << " from the saveQIE11DataNSamples "
+              << "configurables to HcalRawToDigi" << std::endl;
+      }
+  }
+
   // Step B: encapsulate vectors in actual collections
   auto hbhe_prod = std::make_unique<HBHEDigiCollection>();
   auto hf_prod = std::make_unique<HFDigiCollection>();
   auto ho_prod = std::make_unique<HODigiCollection>();
   auto htp_prod = std::make_unique<HcalTrigPrimDigiCollection>();
   auto hotp_prod = std::make_unique<HOTrigPrimDigiCollection>();
+  // make qie10 collection if it wasn't made in theunpacker
   if (colls.qie10 == nullptr) {
     colls.qie10 = new QIE10DigiCollection(); 
   }
   std::unique_ptr<QIE10DigiCollection> qie10_prod(colls.qie10);
+
+  // make qie10ZDC collection if it wasn't made in theunpacker
   if (colls.qie10ZDC == nullptr) {
     colls.qie10ZDC = new QIE10DigiCollection(); 
   }
   std::unique_ptr<QIE10DigiCollection> qie10ZDC_prod(colls.qie10ZDC);
+
+  // make qie10Lasermon collection if it wasn't made in theunpacker
+  if (colls.qie10Lasermon == nullptr) {
+    colls.qie10Lasermon = new QIE10DigiCollection(); 
+  }
+  std::unique_ptr<QIE10DigiCollection> qie10Lasermon_prod(colls.qie10Lasermon);
+
   if (colls.qie11 == nullptr) {
     colls.qie11 = new QIE11DigiCollection(); 
   }
   std::unique_ptr<QIE11DigiCollection> qie11_prod(colls.qie11);
 
+
+  // follow the procedure for other collections.  Copy the unpacked
+  // data so that it can be filtered and sorted
+  std::unordered_map<int, std::unique_ptr<QIE10DigiCollection> > qie10_prodAddtl;
+  std::unordered_map<int, std::unique_ptr<QIE11DigiCollection> > qie11_prodAddtl;
+  for( const auto & orig : colls.qie10Addtl ) {
+      qie10_prodAddtl[orig.first] = std::unique_ptr<QIE10DigiCollection>(orig.second);
+  }
+  for( const auto & orig : colls.qie11Addtl ) {
+      qie11_prodAddtl[orig.first] = std::unique_ptr<QIE11DigiCollection>(orig.second);
+  }
+
   hbhe_prod->swap_contents(hbhe);
   if( !cntHFdup ) hf_prod->swap_contents(hf);
   ho_prod->swap_contents(ho);
@@ -226,14 +351,26 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
     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);
-  }
 
+    // apply filter to additional collections
+    for( auto & prod : qie10_prodAddtl ) {
+      QIE10DigiCollection filtered_qie10=filter_.filter(*(prod.second),*report);
+      prod.second->swap(filtered_qie10);
+    }
+
+    for( auto & prod : qie11_prodAddtl ) {
+      QIE11DigiCollection filtered_qie11=filter_.filter(*(prod.second),*report);
+      prod.second->swap(filtered_qie11);
+    }
+
+
+  }
 
   // Step D: Put outputs into event
   // just until the sorting is proven
@@ -244,17 +381,38 @@ void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
   hotp_prod->sort();
   qie10_prod->sort();
   qie10ZDC_prod->sort();
+  qie10Lasermon_prod->sort();
   qie11_prod->sort();
 
+  // sort the additional collections
+  for( auto & prod : qie10_prodAddtl ) {
+    prod.second->sort();
+  }
+  for( auto & prod : qie11_prodAddtl ) {
+    prod.second->sort();
+  }
+
   e.put(std::move(hbhe_prod));
   e.put(std::move(ho_prod));
   e.put(std::move(hf_prod));
   e.put(std::move(htp_prod));
   e.put(std::move(hotp_prod));
   e.put(std::move(qie10_prod));
-  e.put(std::move(qie10ZDC_prod),"ZDC");
+  e.put(std::move(qie10ZDC_prod), "ZDC");
+  e.put(std::move(qie10Lasermon_prod), "LASERMON");
   e.put(std::move(qie11_prod));
 
+  // put the qie10 and qie11 collections into the event
+  for( auto & prod : qie10_prodAddtl ) {
+    std::string tag = saveQIE10Info_[prod.first];
+    e.put(std::move(prod.second), tag);
+  }
+
+  for( auto & prod : qie11_prodAddtl ) {
+    std::string tag = saveQIE11Info_[prod.first];
+    e.put(std::move(prod.second), tag);
+  }
+
   /// calib
   if (unpackCalib_) {
     auto hc_prod = std::make_unique<HcalCalibDigiCollection>();

EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.h

@@ -41,10 +41,25 @@ class HcalRawToDigi : public edm::stream::EDProducer <>
   const int firstFED_;
   const bool unpackCalib_, unpackZDC_, unpackTTP_;
   bool unpackUMNio_;
+
+  // input configs for additional QIE10 samples
+  std::vector<int> saveQIE10DataNSamples_;
+  std::vector<std::string> saveQIE10DataTags_;
+
+  // input configs for additional QIE11 samples
+  std::vector<int> saveQIE11DataNSamples_;
+  std::vector<std::string> saveQIE11DataTags_;
+
   const bool silent_, complainEmptyData_;
   const int unpackerMode_, expectedOrbitMessageTime_;
   std::string electronicsMapLabel_;
 
+  // maps to easily associate nSamples to 
+  // the tag for additional qie10 and qie11 info
+  std::unordered_map<int, std::string> saveQIE10Info_;
+  std::unordered_map<int, std::string> saveQIE11Info_;
+
+
   struct Statistics {
     int max_hbhe, ave_hbhe;
     int max_ho, ave_ho;