ZDC unpacker, cleaner commit

Configuration/StandardSequences/python/AlCaRecoStreamsHeavyIons_cff.py

@@ -496,4 +496,3 @@
 
 
 from Configuration.StandardSequences.AlCaRecoStream_SpecialsHI_cff import *
-

Configuration/StandardSequences/python/RawToDigi_cff.py

@@ -46,7 +46,7 @@
 muonRPCDigis = EventFilter.RPCRawToDigi.rpcUnpacker_cfi.rpcunpacker.clone()
 
 from EventFilter.CastorRawToDigi.CastorRawToDigi_cff import *
-castorDigis = EventFilter.CastorRawToDigi.CastorRawToDigi_cfi.castorDigis.clone( FEDs = cms.untracked.vint32(690,691,692) )
+castorDigis = EventFilter.CastorRawToDigi.CastorRawToDigi_cfi.castorDigis.clone( FEDs = cms.untracked.vint32(690,691,692, 693,722) )
 
 from EventFilter.ScalersRawToDigi.ScalersRawToDigi_cfi import *
 
@@ -63,10 +63,10 @@
                          +ecalDigis
                          +ecalPreshowerDigis
                          +hcalDigis
+                         +castorDigis
                          +muonCSCDigis
                          +muonDTDigis
                          +muonRPCDigis
-                         +castorDigis
                          +scalersRawToDigi
                          +tcdsDigis)
 
@@ -78,10 +78,10 @@
                               +ecalDigis
                               +ecalPreshowerDigis
                               +hcalDigis
+                              +castorDigis
                               +muonCSCDigis
                               +muonDTDigis
                               +muonRPCDigis
-                              +castorDigis
                               +scalersRawToDigi
                               +tcdsDigis)
 

EventFilter/CastorRawToDigi/interface/CastorRawCollections.h

@@ -21,6 +21,7 @@ class CastorRawCollections
    CastorRawCollections();
    ~CastorRawCollections();
     std::vector<CastorDataFrame>* castorCont;
+    std::vector<ZDCDataFrame>* zdcCont;
     std::vector<HcalCalibDataFrame>* calibCont;
     std::vector<CastorTriggerPrimitiveDigi>* tpCont;
 	std::vector<HcalTTPDigi>* ttp;

EventFilter/CastorRawToDigi/interface/ZdcUnpacker.h

@@ -0,0 +1,36 @@
+/* -*- C++ -*- */
+#ifndef EventFilter_CastorRawToDigi_ZdcUnpacker_h
+#define EventFilter_CastorRawToDigi_ZdcUnpacker_h 1
+
+#include "DataFormats/HcalDigi/interface/ZDCDataFrame.h"
+#include "DataFormats/HcalDigi/interface/HcalCalibDataFrame.h"
+#include "DataFormats/HcalDigi/interface/HcalTriggerPrimitiveDigi.h"
+#include "DataFormats/HcalDigi/interface/HcalUnpackerReport.h"
+#include "DataFormats/FEDRawData/interface/FEDRawData.h"
+#include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h"
+#include "CondFormats/CastorObjects/interface/CastorElectronicsMap.h"
+#include <set>
+#include "DataFormats/HcalDigi/interface/HcalQIESample.h"
+#include "EventFilter/CastorRawToDigi/interface/CastorRawCollections.h"
+
+
+class ZdcUnpacker {
+public:
+
+  /// for normal data
+  ZdcUnpacker(int sourceIdOffset, int beg, int end) ;
+  void setExpectedOrbitMessageTime(int time) { expectedOrbitMessageTime_=time; }
+  /// For histograms, no begin and end
+  // void unpack(const FEDRawData& raw, const ZdcElectronicsMap& emap, std::vector<HcalHistogramDigi>& histoDigis);
+  void unpack(const FEDRawData& raw, const CastorElectronicsMap& emap, CastorRawCollections& conts, HcalUnpackerReport& report, bool silent=false);
+  void unpackOld(const FEDRawData& raw, const HcalElectronicsMap& emap, CastorRawCollections& conts, HcalUnpackerReport& report, bool silent=false);
+private:
+  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)
+  std::set<HcalElectronicsId> unknownIds_,unknownIdsTrig_; ///< Recorded to limit number of times a log message is generated
+  int mode_;
+};
+
+#endif // ZdcUnpacker_h_included

EventFilter/CastorRawToDigi/plugins/CastorRawToDigi.cc

@@ -5,33 +5,41 @@ using namespace std;
 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/Run.h"
-
+#include <fstream>
 #include "CalibFormats/CastorObjects/interface/CastorDbService.h"
 #include "CalibFormats/CastorObjects/interface/CastorDbRecord.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include <iostream>
 #include "EventFilter/CastorRawToDigi/interface/CastorRawCollections.h"
+#include "CalibCalorimetry/HcalPlugins/src/HcalTextCalibrations.h"
+#include "CalibCalorimetry/HcalAlgos/interface/HcalDbASCIIIO.h"
+#include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h"
+#include "Geometry/CaloTopology/interface/HcalTopology.h"
+#include "FWCore/ParameterSet/interface/FileInPath.h"
+
 
 CastorRawToDigi::CastorRawToDigi(edm::ParameterSet const& conf):
   dataTag_(conf.getParameter<edm::InputTag>("InputLabel")),
   unpacker_(conf.getParameter<int>("CastorFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
+  zdcunpacker_(conf.getParameter<int>("ZDCFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
   ctdcunpacker_(conf.getParameter<int>("CastorFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
   filter_(conf.getParameter<bool>("FilterDataQuality"),conf.getParameter<bool>("FilterDataQuality"),false,0,0,-1),
   fedUnpackList_(conf.getUntrackedParameter<std::vector<int> >("FEDs",std::vector<int>())),
   firstFED_(conf.getParameter<int>("CastorFirstFED")),
   complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData",false)),
   usingctdc_(conf.getParameter<bool>("CastorCtdc")),
   unpackTTP_(conf.getParameter<bool>("UnpackTTP")),
+  unpackZDC_(conf.getParameter<bool>("UnpackZDC")),
   silent_(conf.getUntrackedParameter<bool>("silent",true)),
   usenominalOrbitMessageTime_(conf.getParameter<bool>("UseNominalOrbitMessageTime")),
   expectedOrbitMessageTime_(conf.getParameter<int>("ExpectedOrbitMessageTime"))
-
+  
 {
   if (fedUnpackList_.empty()) {
     for (int i=FEDNumbering::MINCASTORFEDID; i<=FEDNumbering::MAXCASTORFEDID; i++)
-     fedUnpackList_.push_back(i);
+      fedUnpackList_.push_back(i);
   } 
-
+  
   unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);  
   std::ostringstream ss;
   for (unsigned int i=0; i<fedUnpackList_.size(); i++) 
@@ -40,13 +48,17 @@ CastorRawToDigi::CastorRawToDigi(edm::ParameterSet const& conf):
 
   // products produced...
   produces<CastorDigiCollection>();
+  produces<ZDCDigiCollection>();
   produces<CastorTrigPrimDigiCollection>();
   produces<HcalUnpackerReport>();
   if (unpackTTP_)
     produces<HcalTTPDigiCollection>();
 
   tok_input_ = consumes<FEDRawDataCollection>(dataTag_);
 
+
+
+
 }
 
 // Virtual destructor needed.
@@ -63,69 +75,137 @@ void CastorRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
   es.get<CastorDbRecord>().get( pSetup );
   const CastorElectronicsMap* readoutMap=pSetup->getCastorMapping();
 
+
+
   // Step B: Create empty output  : three vectors for three classes...
   std::vector<CastorDataFrame> castor;
+  std::vector<ZDCDataFrame> zdc;
   std::vector<HcalTTPDigi> ttp;
   std::vector<CastorTriggerPrimitiveDigi> htp;
 
   std::auto_ptr<HcalUnpackerReport> report(new HcalUnpackerReport);
 
   CastorRawCollections colls;
   colls.castorCont=&castor;
+  colls.zdcCont=&zdc;
   if (unpackTTP_) colls.ttp=&ttp;
   colls.tpCont=&htp;
 
   // Step C: unpack all requested FEDs
+  const FEDRawData& fed722 = rawraw->FEDData(722);
+  const int fed722size = fed722.size();
+  const FEDRawData& fed693 = rawraw->FEDData(693);
+  const int fed693size = fed693.size();
   for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
     const FEDRawData& fed = rawraw->FEDData(*i);
-    if (fed.size()==0) {
-      if (complainEmptyData_) {
-	edm::LogWarning("EmptyData") << "No data for FED " << *i;
-	report->addError(*i);
-      }
-    } else if (fed.size()<8*3) {
-      edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
-      report->addError(*i);
-    } else {
-      try {
-		  if ( usingctdc_ ) { 
-			  ctdcunpacker_.unpack(fed,*readoutMap,colls, *report);
-		  } else {
-			  unpacker_.unpack(fed,*readoutMap,colls, *report);
+    //std::cout<<"Fed number "<<*i<<"is being worked on"<<std::endl;
+    if (*i == 693 && fed693size == 0 && fed722size != 0)
+      continue;
+    if (*i == 722 && fed722size == 0 && fed693size != 0)
+      continue;      
+      
+    if (*i!=693 && *i!=722)
+      {
+	if (fed.size()==0) 
+	  {
+	    if (complainEmptyData_) 
+	      {
+		edm::LogWarning("EmptyData") << "No data for FED " << *i;
+		report->addError(*i);
 	      }
-	      report->addUnpacked(*i);
-      } catch (cms::Exception& e) {
-	edm::LogWarning("Unpacking error") << e.what();
-	report->addError(*i);
-      } catch (...) {
-	edm::LogWarning("Unpacking exception");
-	report->addError(*i);
+	  } 
+	else if (fed.size()<8*3) 
+	  {
+	    edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
+	    report->addError(*i);
+	  } 
+	else 
+	  {
+	    try 
+	      {
+		if ( usingctdc_ ) 
+		  { 
+		    ctdcunpacker_.unpack(fed,*readoutMap,colls, *report);
+		  } 
+		else 
+		  {
+		    unpacker_.unpack(fed,*readoutMap,colls, *report);
+		  }
+		report->addUnpacked(*i);
+	      } 
+	    catch (cms::Exception& e) 
+	      {
+		edm::LogWarning("Unpacking error") << e.what();
+		report->addError(*i);
+	      } catch (...) 
+	      {
+		edm::LogWarning("Unpacking exception");
+		report->addError(*i);
+	      }
+	  }
       }
-    }
-  }
+
+    if (*i==693 && unpackZDC_)
+      {
+	if (fed.size()==0)
+	  {
+	    edm::LogWarning("EmptyData") << "No data for FED "<< *i;
+	    report->addError(*i);
+	  }
+	if (fed.size()!=0)
+	  {
+	    zdcunpacker_.unpack(fed,*readoutMap,colls,*report);
+	    report->addUnpacked(*i); 
+	  }
+      }
+
+    if (*i==722 && unpackZDC_)
+      {
+	if (fed.size()==0)
+	  {
+	    edm::LogWarning("EmptyData") << "No data for FED "<< *i;
+	    report->addError(*i);
+	  }
+	if (fed.size()!=0)
+	  {
+	    zdcunpacker_.unpack(fed,*readoutMap,colls,*report);
+	    report->addUnpacked(*i);
+	  }
+      }      
+
+  }//end of loop over feds
 
   // Step B: encapsulate vectors in actual collections
   std::auto_ptr<CastorDigiCollection> castor_prod(new CastorDigiCollection()); 
   std::auto_ptr<CastorTrigPrimDigiCollection> htp_prod(new CastorTrigPrimDigiCollection());  
-
-  castor_prod->swap_contents(castor);
-  htp_prod->swap_contents(htp);
-
-  // Step C2: filter FEDs, if required
-  if (filter_.active()) {
+   
+   castor_prod->swap_contents(castor);
+   htp_prod->swap_contents(htp);
+  
+   // Step C2: filter FEDs, if required
+   if (filter_.active()) {
     CastorDigiCollection filtered_castor=filter_.filter(*castor_prod,*report);
 
     castor_prod->swap(filtered_castor);
-  }
-
-  // Step D: Put outputs into event
-  // just until the sorting is proven
-  castor_prod->sort();
-  htp_prod->sort();
-
-  e.put(castor_prod);
-  e.put(htp_prod);
-
+   }
+
+   // Step D: Put outputs into event
+   // just until the sorting is proven
+   castor_prod->sort();
+   htp_prod->sort();
+
+   if(unpackZDC_)
+     {
+       std::auto_ptr<ZDCDigiCollection> zdc_prod(new ZDCDigiCollection());
+       zdc_prod->swap_contents(zdc);
+
+       zdc_prod->sort();
+       e.put(zdc_prod);
+     }
+
+   e.put(castor_prod);
+   e.put(htp_prod);
+
   if (unpackTTP_) {
     std::auto_ptr<HcalTTPDigiCollection> prod(new HcalTTPDigiCollection());
     prod->swap_contents(ttp);

EventFilter/CastorRawToDigi/plugins/CastorRawToDigi.h

@@ -25,6 +25,12 @@
 #include "EventFilter/CastorRawToDigi/interface/CastorUnpacker.h"
 #include "EventFilter/CastorRawToDigi/interface/CastorCtdcUnpacker.h"
 #include "EventFilter/CastorRawToDigi/interface/CastorDataFrameFilter.h"
+#include "DataFormats/HcalDigi/interface/ZDCDataFrame.h"
+#include "EventFilter/CastorRawToDigi/interface/ZdcUnpacker.h"
+#include "CondFormats/DataRecord/interface/HcalAllRcds.h"
+#include <map>
+//#include "Geometry/Records/interface/HcalRecNumberingRecord.h"
+
 
 class CastorRawToDigi : public edm::stream::EDProducer<>
 {
@@ -37,18 +43,21 @@ class CastorRawToDigi : public edm::stream::EDProducer<>
 private:
   edm::InputTag dataTag_;
   CastorUnpacker unpacker_;
+  ZdcUnpacker zdcunpacker_;
   CastorCtdcUnpacker ctdcunpacker_;
   CastorDataFrameFilter filter_;
   std::vector<int> fedUnpackList_;
   int firstFED_;
   bool complainEmptyData_;
   bool usingctdc_;
   bool unpackTTP_;
+  bool unpackZDC_;
   bool silent_;
   bool usenominalOrbitMessageTime_;
   int expectedOrbitMessageTime_;
+  std::auto_ptr<HcalElectronicsMap> myEMap;
   edm::EDGetTokenT<FEDRawDataCollection> tok_input_;
-
+  edm::ParameterSet zdcemap;
 };
 
 #endif

EventFilter/CastorRawToDigi/python/CastorRawToDigi_cfi.py

@@ -8,9 +8,10 @@
     # Number of the first CASTOR FED.  If this is not specified, the
     # default from FEDNumbering is used.
     CastorFirstFED = cms.int32(690),
+    ZDCFirstFED = cms.int32(693),                         
     # FED numbers to unpack.  If this is not specified, all FEDs from
     # FEDNumbering will be unpacked.
-    FEDs = cms.untracked.vint32( 690, 691, 692 ),
+    FEDs = cms.untracked.vint32( 690, 691, 692, 693, 722),
     # Do not complain about missing FEDs
     ExceptionEmptyData = cms.untracked.bool(False),
     # Do not complain about missing FEDs
@@ -28,5 +29,7 @@
     InputLabel = cms.InputTag("rawDataCollector"),
     CastorCtdc = cms.bool(False),
     UseNominalOrbitMessageTime = cms.bool(True),
-    ExpectedOrbitMessageTime = cms.int32(-1)
-)
+    ExpectedOrbitMessageTime = cms.int32(-1),
+    UnpackZDC = cms.bool(True),
+
+   )

EventFilter/CastorRawToDigi/src/CastorRawCollections.cc

@@ -2,6 +2,7 @@
 
 CastorRawCollections::CastorRawCollections() {
   castorCont=0;
+  zdcCont=0;
   tpCont=0;
   calibCont=0;
   ttp=0;