HcalUnpacker.cc

Go to the documentation of this file.

#include "EventFilter/HcalRawToDigi/interface/HcalUnpacker.h"
#include "EventFilter/HcalRawToDigi/interface/HcalDCCHeader.h"
#include "EventFilter/HcalRawToDigi/interface/HcalDTCHeader.h"
#include "EventFilter/HcalRawToDigi/interface/AMC13Header.h"
#include "EventFilter/HcalRawToDigi/interface/HcalHTRData.h"
#include "EventFilter/HcalRawToDigi/interface/HcalUHTRData.h"
#include "DataFormats/HcalDetId/interface/HcalOtherDetId.h"
#include "DataFormats/HcalDigi/interface/HcalQIESample.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "EventFilter/HcalRawToDigi/interface/HcalTTPUnpacker.h"
#include "EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.h"

//#define DebugLog

namespace HcalUnpacker_impl {
  template <class DigiClass>
  const HcalQIESample* unpack(const HcalQIESample* startPoint, const HcalQIESample* limit, DigiClass& digi, int presamples, const HcalElectronicsId& eid, int startSample, int endSample, int expectedTime, const HcalHTRData& hhd) {
    // set parameters
    digi.setPresamples(presamples);
    digi.setReadoutIds(eid);

    int fiber=startPoint->fiber();
    int fiberchan=startPoint->fiberChan();
    uint32_t zsmask=hhd.zsBunchMask()>>startSample;
    digi.setZSInfo(hhd.isUnsuppressed(),hhd.wasMarkAndPassZS(fiber,fiberchan),zsmask);

    if (expectedTime>=0 && !hhd.isUnsuppressed()) {
#ifdef DebugLog
      std::cout << hhd.getFibOrbMsgBCN(fiber) << " " << expectedTime << std::endl;
#endif
      digi.setFiberIdleOffset(hhd.getFibOrbMsgBCN(fiber)-expectedTime);
    }

    // what is my sample number?
    int myFiberChan=startPoint->fiberAndChan();
    int ncurr=0,ntaken=0;
    const HcalQIESample* qie_work=startPoint;
    while (qie_work!=limit && qie_work->fiberAndChan()==myFiberChan) {
      if (ncurr>=startSample && ncurr<=endSample) {
    digi.setSample(ntaken,*qie_work);
    ++ntaken;
      }
      ncurr++;
      qie_work++;
    }
    digi.setSize(ntaken);
    return qie_work;
  }


  template <class DigiClass>
  const unsigned short* unpack_compact(const unsigned short* startPoint, const unsigned short* limit, DigiClass& digi, 
                       int presamples, const HcalElectronicsId& eid, int startSample, int endSample, 
                       int expectedTime, const HcalHTRData& hhd) {
    // set parameters
    digi.setPresamples(presamples);
    digi.setReadoutIds(eid);
    int flavor, error_flags, capid0, channelid;

    HcalHTRData::unpack_per_channel_header(*startPoint,flavor,error_flags,capid0,channelid);
    bool isCapRotating=!(error_flags&0x1);
    bool fiberErr=(error_flags&0x2);
    bool dataValid=!(error_flags&0x2);
    int fiberchan=channelid&0x3;
    int fiber=((channelid>>2)&0x7)+1;

    uint32_t zsmask=hhd.zsBunchMask()>>startSample;
    digi.setZSInfo(hhd.isUnsuppressed(),hhd.wasMarkAndPassZS(fiber,fiberchan),zsmask);

    if (expectedTime>=0 && !hhd.isUnsuppressed()) {
#ifdef DebugLog
      std::cout << hhd.getFibOrbMsgBCN(fiber) << " " << expectedTime << std::endl;
#endif
      digi.setFiberIdleOffset(hhd.getFibOrbMsgBCN(fiber)-expectedTime);
    }

    // what is my sample number?
    int ncurr=0,ntaken=0;
    const unsigned short* qie_work=startPoint;
    // we branch here between normal (flavor=5) and error mode (flavor=6)
    if (flavor==5) {
      for (qie_work++; qie_work!=limit && !HcalHTRData::is_channel_header(*qie_work); qie_work++) {
    int capidn=(isCapRotating)?((capid0+ncurr)%4):(capid0);
    int capidn1=(isCapRotating)?((capid0+ncurr+1)%4):(capid0);
    // two samples in one...
    HcalQIESample s0((*qie_work)&0x7F,capidn,fiber,fiberchan,dataValid,fiberErr);
    HcalQIESample s1(((*qie_work)>>8)&0x7F,capidn1,fiber,fiberchan,dataValid,fiberErr);
    
    if (ncurr>=startSample && ncurr<=endSample) {
      digi.setSample(ntaken,s0);
      ++ntaken;
    }
    ncurr++;
    if (ncurr>=startSample && ncurr<=endSample) {
      digi.setSample(ntaken,s1);
      ++ntaken;
    }
    ncurr++;
      }
      digi.setSize(ntaken);
    } else if (flavor==6) {
      for (qie_work++; qie_work!=limit && !HcalHTRData::is_channel_header(*qie_work); qie_work++) {
    if (ncurr>=startSample && ncurr<=endSample) {
      HcalQIESample sample((*qie_work)&0x7F,((*qie_work)>>8)&0x3,fiber,fiberchan,((*qie_work)>>10)&0x1,((*qie_work)>>11)&0x1);
      digi.setSample(ntaken,sample);
      ++ntaken;
    }

    ncurr++;
      }
      digi.setSize(ntaken);
    } else {
      edm::LogWarning("Bad Data") << "Invalid flavor " << flavor;
      qie_work=limit;
    }
    return qie_work;
  }
  
  template <class DigiClass>
  void unpack_compact(HcalUHTRData::const_iterator& i, const HcalUHTRData::const_iterator& iend, DigiClass& digi, 
              int presamples, const HcalElectronicsId& eid, int startSample, int endSample) {
    // set parameters
    digi.setPresamples(presamples-startSample);
    digi.setReadoutIds(eid);
    int error_flags=i.errFlags();
    int capid0=i.capid0();
    int flavor = i.flavor();

    bool isCapRotating=!(error_flags&0x1);
    bool fiberErr=(error_flags&0x2);
    bool dataValid=!(error_flags&0x2);
    int fiberchan=i.channelid()&0x3;
    int fiber=((i.channelid()>>2)&0x7)+1;

    //    digi.setZSInfo(hhd.isUnsuppressed(),hhd.wasMarkAndPassZS(fiber,fiberchan),zsmask);

    // what is my sample number?
    int ncurr=0,ntaken=0;
    if(flavor==5){
      for (++i; i!=iend && !i.isHeader(); ++i) {
        int capidn=(isCapRotating)?((capid0+ncurr)%4):(capid0);
      
        HcalQIESample s(i.adc(),capidn,fiber,fiberchan,dataValid,fiberErr);
      
        if (ncurr>=startSample && ncurr<=endSample) {
          digi.setSample(ntaken,s);
          ++ntaken;
        }
        ncurr++;
      }
      digi.setSize(ntaken);
    }
    else if(flavor==7){ //similar to VME flavor 6, used for premix in MC
      for (++i; i!=iend && !i.isHeader(); ++i) {
        if (ncurr>=startSample && ncurr<=endSample) {
          HcalQIESample sample(i.adc(),i.capid(),fiber,fiberchan,i.dataValid(),i.errFlags());
          digi.setSample(ntaken,sample);
          ++ntaken;
        }
        ncurr++;
      }
      digi.setSize(ntaken);
    }
  }

}


static inline bool isTPGSOI(const HcalTriggerPrimitiveSample& s) {
  return (s.raw()&0x200)!=0;
}


struct HOUnrolledTP { // parts of an HO trigger primitive, unpacked
  bool valid, checked;
  int ieta, iphi, samples, soi;
  unsigned int databits;
  HOUnrolledTP() {
    valid=false;
    checked=false;
    ieta=0;
    iphi=0;
    samples=0;
    soi=0;
    databits=0;
  }
  void setbit(int i) { databits|=(1<<i); }    
};

void HcalUnpacker::unpack(const FEDRawData& raw, const HcalElectronicsMap& emap,
              Collections& colls, HcalUnpackerReport& report, bool silent) {

  if (raw.size()<16) {
    if (!silent) edm::LogWarning("Invalid Data") << "Empty/invalid data, size = " << raw.size();
    return;
  }

  // get the DCC header
  const HcalDCCHeader* dccHeader=(const HcalDCCHeader*)(raw.data());

  if (dccHeader->BOEshouldBeZeroAlways()==0) // also includes uTCA before the common AMC13XG firmware
    unpackVME(raw,emap,colls,report,silent);
  else unpackUTCA(raw,emap,colls,report,silent);
}

static int slb(uint16_t theSample) { return ((theSample>>13)&0x7); }
static int slbChan(uint16_t theSample) { return (theSample>>11)&0x3; }
static int slbAndChan(uint16_t theSample) { return (theSample>>11)&0x1F; }


void HcalUnpacker::unpackVME(const FEDRawData& raw, const HcalElectronicsMap& emap,
              Collections& colls, HcalUnpackerReport& report, bool silent) {

  // get the DCC header
  const HcalDCCHeader* dccHeader=(const HcalDCCHeader*)(raw.data());
  const HcalDTCHeader* dtcHeader=(const HcalDTCHeader*)(raw.data());
  bool is_VME_DCC=(dccHeader->getDCCDataFormatVersion()<0x10) || ((mode_&0x1)==0);
  
  int dccid=(is_VME_DCC)?(dccHeader->getSourceId()-sourceIdOffset_):(dtcHeader->getSourceId()-sourceIdOffset_);

  // check the summary status
  
  // walk through the HTR data.  For the uTCA, use spigot=slot+1
  HcalHTRData htr;
  const unsigned short* daq_first, *daq_last, *tp_first, *tp_last;
  const HcalQIESample* qie_begin, *qie_end, *qie_work;
  const HcalTriggerPrimitiveSample *tp_begin, *tp_end, *tp_work; 
  for (int spigot=0; spigot<HcalDCCHeader::SPIGOT_COUNT; spigot++) {
    
    if (is_VME_DCC) {
      if (!dccHeader->getSpigotPresent(spigot)) continue;

      int retval=dccHeader->getSpigotData(spigot,htr,raw.size());
      if (retval!=0) {
    if (retval==-1) {
      if (!silent) edm::LogWarning("Invalid Data") << "Invalid HTR data (data beyond payload size) observed on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
      report.countSpigotFormatError();
    }
    continue;
      }
      // check
      if (dccHeader->getSpigotCRCError(spigot)) {
    if (!silent) 
      edm::LogWarning("Invalid Data") << "CRC Error on HTR data observed on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
    report.countSpigotFormatError();
    continue;
      } 
    } else { // is_uTCA (!is_VME_DCC)
      int slot=spigot+1;
      if (slot>HcalDTCHeader::MAXIMUM_SLOT) continue;

      if (!dtcHeader->getSlotPresent(slot)) continue;

      int retval=dtcHeader->getSlotData(slot,htr,raw.size());
      if (retval!=0) {
    if (retval==-1) {
      if (!silent) edm::LogWarning("Invalid Data") << "Invalid uHTR data (data beyond payload size) observed on slot " << slot << " of DTC with source id " << dtcHeader->getSourceId();
      report.countSpigotFormatError();
    }
    continue;
      }
      // check
      if (dtcHeader->getSlotCRCError(slot)) {
    if (!silent) 
      edm::LogWarning("Invalid Data") << "CRC Error on uHTR data observed on slot " << slot << " of DTC with source id " << dtcHeader->getSourceId();
    report.countSpigotFormatError();
    continue;
      } 
    }


    // check for EE
    if (htr.isEmptyEvent()) {
      report.countEmptyEventSpigot();
    }
    if (htr.isOverflowWarning()) {
      report.countOFWSpigot();
    }
    if (htr.isBusy()) {
      report.countBusySpigot();
    }
    if (!htr.check()) {
      if (!silent) 
    edm::LogWarning("Invalid Data") << "Invalid HTR data observed on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
      report.countSpigotFormatError();
      continue;
    }  
    if (htr.isHistogramEvent()) {
      if (!silent) edm::LogWarning("Invalid Data") << "Histogram data passed to non-histogram unpacker on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
      continue;
    }
    if ((htr.getFirmwareFlavor()&0xE0)==0x80) { // some kind of TTP data
      if (colls.ttp!=nullptr) {
    HcalTTPUnpacker ttpUnpack;
    colls.ttp->push_back(HcalTTPDigi());
    ttpUnpack.unpack(htr,colls.ttp->back());
      } else {
    LogDebug("HcalTechTrigProcessor") << "Skipping data on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId() << " which is from the TechTrigProcessor (use separate unpacker!)";
      }
      continue;
    }
    if (htr.getFirmwareFlavor()>=0x80) {
      if (!silent) edm::LogWarning("HcalUnpacker") << "Skipping data on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId() << " which is of unknown flavor " << htr.getFirmwareFlavor();
      continue;
    }

    // calculate "real" number of presamples
    int nps=htr.getNPS()-startSample_;
    
    // get pointers
    htr.dataPointers(&daq_first,&daq_last,&tp_first,&tp_last);
    unsigned int smid=htr.getSubmodule();
    int htr_tb=smid&0x1;
    int htr_slot=(smid>>1)&0x1F;
    int htr_cr=(smid>>6)&0x1F;
    
    tp_begin=(const HcalTriggerPrimitiveSample*)tp_first;
    tp_end=(const HcalTriggerPrimitiveSample*)(tp_last+1); // one beyond last..
    
    int currFiberChan=0x3F; // invalid fiber+channel...
    int ncurr=0;
    bool valid=false;

    bool tpgSOIbitInUse=htr.getFormatVersion()>=3; // version 3 and later
    bool isHOtpg=htr.getFormatVersion()>=3 && htr.getFirmwareFlavor()==0; // HO is flavor zero
    int npre=0;
    /*
      Unpack the trigger primitives
    */
    if (isHOtpg) {
      HOUnrolledTP unrolled[24];
      for (tp_work=tp_begin; tp_work!=tp_end; tp_work++) {
    if (tp_work->raw()==0xFFFF) continue; // filler word
    int sector=slbChan(tp_work->raw());
    if (sector>2) continue;

    for (int ibit=0; ibit<8; ibit++) {
      int linear=sector*8+ibit; 
      if (!unrolled[linear].checked) {
        unrolled[linear].checked=true;
        int fiber=(linear/3)+1;
        int fc=(linear%3);
        // electronics id (use precision match for HO TP)
        HcalElectronicsId eid(fc,fiber,spigot,dccid);   
        eid.setHTR(htr_cr,htr_slot,htr_tb);
        DetId did=emap.lookup(eid);
        if (!did.null()) {
          if (did.det()==DetId::Hcal && ((HcalSubdetector)did.subdetId())==HcalOuter ) {
        HcalDetId hid(did);
        unrolled[linear].valid=true;
        unrolled[linear].ieta=hid.ieta();
        unrolled[linear].iphi=hid.iphi();
          }
        } else {
          report.countUnmappedTPDigi(eid);
        }
      }
      if (unrolled[linear].valid) {
        if (isTPGSOI(*tp_work)) unrolled[linear].soi=unrolled[linear].samples;
        if (tp_work->raw()&(1<<ibit)) unrolled[linear].setbit(unrolled[linear].samples);
        unrolled[linear].samples++;
      }
    }
      }
      for (int i=0; i<24; i++) {
    if (unrolled[i].valid) 
      colls.tphoCont->push_back(HOTriggerPrimitiveDigi(
                               unrolled[i].ieta,
                               unrolled[i].iphi,
                               unrolled[i].samples,
                               unrolled[i].soi,
                               unrolled[i].databits));
      }
    } else { // regular TPs (not HO)
      for (tp_work=tp_begin; tp_work!=tp_end; tp_work++) {
    if (tp_work->raw()==0xFFFF) continue; // filler word
    if (slbAndChan(tp_work->raw())!=currFiberChan) { // start new set
      npre=0;
      currFiberChan=slbAndChan(tp_work->raw());
      // lookup the right channel
      HcalElectronicsId eid(slbChan(tp_work->raw()),slb(tp_work->raw()),spigot,dccid,htr_cr,htr_slot,htr_tb);
      DetId did=emap.lookupTrigger(eid);
      if (did.null()) {
        report.countUnmappedTPDigi(eid);
        if (unknownIdsTrig_.find(eid)==unknownIdsTrig_.end()) {
          if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No trigger primitive match found for electronics id :" << eid;
          unknownIdsTrig_.insert(eid);
        }
        valid=false;
        continue;
      } else if (did==HcalTrigTowerDetId::Undefined || 
             (did.det()==DetId::Hcal && did.subdetId()==0)) {
        // known to be unmapped
        valid=false;
        continue;
      }
      HcalTrigTowerDetId id(did);
      colls.tpCont->push_back(HcalTriggerPrimitiveDigi(id));
      // set the various bits
      if (!tpgSOIbitInUse) colls.tpCont->back().setPresamples(nps);
      colls.tpCont->back().setZSInfo(htr.isUnsuppressed(),htr.wasMarkAndPassZSTP(slb(tp_work->raw()),slbChan(tp_work->raw())));

      // no hits recorded for current
      ncurr=0;
      valid=true;
    }      
    // add the word (if within settings or recent firmware [recent firmware ignores startSample/endSample])
    if (valid && ((tpgSOIbitInUse && ncurr<10) || (ncurr>=startSample_ && ncurr<=endSample_))) {
      colls.tpCont->back().setSample(colls.tpCont->back().size(),*tp_work);
      colls.tpCont->back().setSize(colls.tpCont->back().size()+1);
    }
    // set presamples,if SOI
    if (valid && tpgSOIbitInUse && isTPGSOI(*tp_work)) {
      colls.tpCont->back().setPresamples(ncurr);
    }
    ncurr++;
    npre++;
      }
    }

    if (htr.getFormatVersion() < HcalHTRData::FORMAT_VERSION_COMPACT_DATA) {
 
      qie_begin=(const HcalQIESample*)daq_first;
      qie_end=(const HcalQIESample*)(daq_last+1); // one beyond last..


    
      for (qie_work=qie_begin; qie_work!=qie_end; ) {
    if (qie_work->raw()==0xFFFF) {
      qie_work++;
      continue; // filler word
    }
    // always at the beginning ...
    
    // lookup the right channel
    HcalElectronicsId eid(qie_work->fiberChan(),qie_work->fiber(),spigot,dccid);
    eid.setHTR(htr_cr,htr_slot,htr_tb);
    DetId did=emap.lookup(eid);
    
    if (!did.null()) {
      if (did.det()==DetId::Calo && did.subdetId()==HcalZDCDetId::SubdetectorId) {
        colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
        qie_work=HcalUnpacker_impl::unpack<ZDCDataFrame>(qie_work, qie_end, colls.zdcCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr); 
      } else if (did.det()==DetId::Hcal) {
        switch (((HcalSubdetector)did.subdetId())) {
        case (HcalBarrel):
        case (HcalEndcap): {
          colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
          qie_work=HcalUnpacker_impl::unpack<HBHEDataFrame>(qie_work, qie_end, colls.hbheCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
        } break;
        case (HcalOuter): {
          colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
          qie_work=HcalUnpacker_impl::unpack<HODataFrame>(qie_work, qie_end, colls.hoCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
      } break;
        case (HcalForward): {
          colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
          qie_work=HcalUnpacker_impl::unpack<HFDataFrame>(qie_work, qie_end, colls.hfCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
        } break;
        case (HcalOther) : {
          HcalOtherDetId odid(did);
          if (odid.subdet()==HcalCalibration) {
        colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
        qie_work=HcalUnpacker_impl::unpack<HcalCalibDataFrame>(qie_work, qie_end, colls.calibCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr); 
          }
        } break;
        case (HcalEmpty): 
        default: {
          for (int fiberC=qie_work->fiberAndChan();
           qie_work!=qie_end && qie_work->fiberAndChan()==fiberC;
           qie_work++);
        }
        break;
        }
      }
    } else {
      report.countUnmappedDigi(eid);
      if (unknownIds_.find(eid)==unknownIds_.end()) {
        if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
        unknownIds_.insert(eid);
    }
      for (int fiberC=qie_work->fiberAndChan();
           qie_work!=qie_end && qie_work->fiberAndChan()==fiberC;
           qie_work++);
    }
      }
    } else {
      // this is the branch for unpacking the compact data format with per-channel headers
      const unsigned short* ptr_header=daq_first;
      const unsigned short* ptr_end=daq_last+1;
      int flavor, error_flags, capid0, channelid;

      while (ptr_header!=ptr_end) {
    if (*ptr_header==0xFFFF) { // impossible filler word
      ptr_header++;
      continue;
    }
    // unpack the header word
    bool isheader=HcalHTRData::unpack_per_channel_header(*ptr_header,flavor,error_flags,capid0,channelid);
    if (!isheader) {
      ptr_header++;
      continue;
    }

    int fiberchan=channelid&0x3;
    int fiber=((channelid>>2)&0x7)+1;

    // lookup the right channel
    HcalElectronicsId eid(fiberchan,fiber,spigot,dccid);
    eid.setHTR(htr_cr,htr_slot,htr_tb);
    DetId did=emap.lookup(eid);
    
    if (!did.null()) {
      if (did.det()==DetId::Calo && did.subdetId()==HcalZDCDetId::SubdetectorId) {
        colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
        ptr_header=HcalUnpacker_impl::unpack_compact<ZDCDataFrame>(ptr_header, ptr_end, colls.zdcCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr); 
      } else if (did.det()==DetId::Hcal) {
        switch (((HcalSubdetector)did.subdetId())) {
        case (HcalBarrel):
        case (HcalEndcap): {
          colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
          ptr_header=HcalUnpacker_impl::unpack_compact<HBHEDataFrame>(ptr_header, ptr_end, colls.hbheCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
        } break;
        case (HcalOuter): {
          colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
          ptr_header=HcalUnpacker_impl::unpack_compact<HODataFrame>(ptr_header, ptr_end, colls.hoCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
      } break;
        case (HcalForward): {
          colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
          ptr_header=HcalUnpacker_impl::unpack_compact<HFDataFrame>(ptr_header, ptr_end, colls.hfCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr);
        } break;
        case (HcalOther) : {
          HcalOtherDetId odid(did);
          if (odid.subdet()==HcalCalibration) {
        colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
        ptr_header=HcalUnpacker_impl::unpack_compact<HcalCalibDataFrame>(ptr_header, ptr_end, colls.calibCont->back(), nps, eid, startSample_, endSample_, expectedOrbitMessageTime_, htr); 
          }
        } break;
        case (HcalEmpty): 
        default: {
          for (ptr_header++;
           ptr_header!=ptr_end && !HcalHTRData::is_channel_header(*ptr_header);
           ptr_header++);
        }
        break;
        }
      }
    } else {
      report.countUnmappedDigi(eid);
      if (unknownIds_.find(eid)==unknownIds_.end()) {
        if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
        unknownIds_.insert(eid);
      }
      for (ptr_header++;
           ptr_header!=ptr_end && !HcalHTRData::is_channel_header(*ptr_header);
           ptr_header++);
    }
      }

    }
  }
}

void HcalUnpacker::unpackUTCA(const FEDRawData& raw, const HcalElectronicsMap& emap,
                  Collections& colls, HcalUnpackerReport& report, bool silent) {

  const hcal::AMC13Header* amc13=(const hcal::AMC13Header*)(raw.data());

  // how many AMC in this packet
  int namc=amc13->NAMC();
  for (int iamc=0; iamc<namc; iamc++) {
    // if not enabled, ignore
    if (!amc13->AMCEnabled(iamc)) continue; 

    if (!amc13->AMCDataPresent(iamc)) {
      if (!silent) 
    edm::LogWarning("Invalid Data") << "Missing data observed on iamc " << iamc << " of AMC13 with source id " << amc13->sourceId();
      report.countSpigotFormatError();
      continue;     
    }
    if (!amc13->AMCCRCOk(iamc)) {
      if (!silent) 
    edm::LogWarning("Invalid Data") << "CRC Error on uHTR data observed on iamc " << iamc << " of AMC13 with source id " << amc13->sourceId();
      report.countSpigotFormatError();
      //      continue;
    }
    // this unpacker cannot handle segmented data!
    if (amc13->AMCSegmented(iamc)) {
      if (!silent) 
    edm::LogWarning("Invalid Data") << "Unpacker cannot handle segmented data observed on iamc " << iamc << " of AMC13 with source id " << amc13->sourceId();
      report.countSpigotFormatError();
      continue;
    }
    
    // ok, now we're work-able
    int slot=amc13->AMCSlot(iamc);
    int crate=amc13->AMCId(iamc)&0xFF;
    
    HcalUHTRData uhtr(amc13->AMCPayload(iamc),amc13->AMCSize(iamc));
    //Check to make sure uMNio is not unpacked here
    if(uhtr.getFormatVersion() != 1) {
      unpackUMNio(raw, slot, colls);
      continue;
    }  
#ifdef DebugLog
    //debug printouts
    int nwords=uhtr.getRawLengthBytes()/2;
    for (int iw=0; iw<nwords; iw++) 
        printf("%04d %04x\n",iw,uhtr.getRawData16()[iw]);
#endif

    //use uhtr presamples since amc header not properly packed in simulation
    int nps = uhtr.presamples();

    HcalUHTRData::const_iterator i=uhtr.begin(), iend=uhtr.end();
    while (i!=iend) {
#ifdef DebugLog
      std::cout << "This data is flavored:" << i.flavor() << std::endl;
#endif

      if (!i.isHeader()) {
        ++i;
#ifdef DebugLog
        std::cout << "its not a header" << std::endl;
#endif
        continue;
      }
      if (i.flavor() == 1 || i.flavor() == 0) {
          int ifiber=((i.channelid()>>3)&0x1F);
          int ichan=(i.channelid()&0x7);
          HcalElectronicsId eid(crate,slot,ifiber,ichan, false);
          DetId did=emap.lookup(eid);
          // Count from current position to next header, or equal to end
          const uint16_t* head_pos = i.raw();
          int ns = 0;
          for (++i; i != iend && !i.isHeader(); ++i) {
              ns++;
          }
          // Check QEI11 container exists
          if (colls.qie11 == nullptr) {
              colls.qie11 = new QIE11DigiCollection(ns);
          }
          else if (colls.qie11->samples() != ns) {
            // if this sample type hasn't been requested to be saved
            // warn the user to provide a configuration that prompts it to be saved
            if( colls.qie11Addtl.find( ns ) == colls.qie11Addtl.end() ) {
              printInvalidDataMessage( "QIE11", colls.qie11->samples(), ns, true );
            }
          }

          // Insert data
          if (!did.null()) { // unpack and store...
            // only fill the default collection if we have the correct number of samples
            if (colls.qie11->samples() == ns) {
              colls.qie11->addDataFrame(did, head_pos);
            }
            // fill the additional qie11 collections
            if( colls.qie11Addtl.find( ns ) != colls.qie11Addtl.end() ) {
              colls.qie11Addtl[ns]->addDataFrame( did, head_pos );
            }
          } else {
              report.countUnmappedDigi(eid);
              if (unknownIds_.find(eid)==unknownIds_.end()) {
                  if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
                  unknownIds_.insert(eid);
#ifdef DebugLog
                  std::cout << "HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
              }
#ifdef DebugLog
              std::cout << "OH NO! detector id is null!" << std::endl;
#endif
          }
      } else if (i.flavor() == 2){

    int ifiber=((i.channelid()>>3)&0x1F);
    int ichan=(i.channelid()&0x7);
    HcalElectronicsId eid(crate,slot,ifiber,ichan, false);
    DetId did=emap.lookup(eid);

    // Count from current position to next header, or equal to end
    const uint16_t* head_pos = i.raw();
    int ns = 0;
    for (++i; i != iend && !i.isHeader(); ++i) {
      ns++; 
    }

        bool isZDC = (did.det()==DetId::Calo && did.subdetId()==HcalZDCDetId::SubdetectorId);
        bool isLasmon = (did.det()==DetId::Hcal && (HcalSubdetector)did.subdetId() == HcalOther && HcalCalibDetId( did ).calibFlavor() == 5);

    if( isZDC ) {
          if( colls.qie10ZDC == nullptr ) {
            colls.qie10ZDC = new QIE10DigiCollection(ns);
          } else if (colls.qie10ZDC->samples() != ns) {
            printInvalidDataMessage( "QIE10ZDC", colls.qie10ZDC->samples(), ns, false );
          }
    }
        else if( isLasmon ) {
          if (colls.qie10Lasermon == nullptr ) {
            colls.qie10Lasermon = new QIE10DigiCollection(ns);
          } else if (colls.qie10Lasermon->samples() != ns) {
            printInvalidDataMessage( "QIE10LASMON", colls.qie10Lasermon->samples(), ns, false );
          }
        } else { // these are the default qie10 channels
          if (colls.qie10 == nullptr) { 
        colls.qie10 = new QIE10DigiCollection(ns);
          }
          else if (colls.qie10->samples() != ns) {
            // if this sample type hasn't been requested to be saved
            // warn the user to provide a configuration that prompts it to be saved
            if( colls.qie10Addtl.find( ns ) == colls.qie10Addtl.end() ) {
              printInvalidDataMessage( "QIE10", colls.qie10->samples(), ns, true );
            }
          }
        }

    // Insert data
    if (!did.null()) { // unpack and store...
          // fill the additional qie10 collections
          if( isZDC ) colls.qie10ZDC->addDataFrame( did, head_pos );
          else if( isLasmon) colls.qie10Lasermon->addDataFrame( did, head_pos );
          else {

            // only fill the default collection if we have the correct number of samples
            if (colls.qie10->samples() == ns) {
              colls.qie10->addDataFrame(did, head_pos);
            }
              
            // fill the additional qie10 collections
            if( colls.qie10Addtl.find( ns ) != colls.qie10Addtl.end() ) {
              colls.qie10Addtl[ns]->addDataFrame( did, head_pos );
            }
          }
    } else {
        report.countUnmappedDigi(eid);
        if (unknownIds_.find(eid)==unknownIds_.end()) {
            if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
#ifdef DebugLog
            std::cout << "HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
        }
#ifdef DebugLog
        std::cout << "OH NO! HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
    }
      }
      else if (i.flavor()==5 || (i.flavor()==7 && i.technicalDataType()==15)) { // Old-style digis
    int ifiber=((i.channelid()>>2)&0x1F);
    int ichan=(i.channelid()&0x3);
    HcalElectronicsId eid(crate,slot,ifiber,ichan, false);
    DetId did=emap.lookup(eid);

    if (!did.null()) { // unpack and store...
      if (did.det()==DetId::Calo && did.subdetId()==HcalZDCDetId::SubdetectorId) {
        colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
        HcalUnpacker_impl::unpack_compact<ZDCDataFrame>(i,iend, colls.zdcCont->back(), nps, eid, startSample_, endSample_); 
      } else if (did.det()==DetId::Hcal) {
        switch (((HcalSubdetector)did.subdetId())) {
        case (HcalBarrel):
        case (HcalEndcap): {
          colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
          HcalUnpacker_impl::unpack_compact<HBHEDataFrame>(i, iend, colls.hbheCont->back(), nps, eid, startSample_, endSample_);
        } break;
        case (HcalOuter): {
          colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
          HcalUnpacker_impl::unpack_compact<HODataFrame>(i, iend, colls.hoCont->back(), nps, eid, startSample_, endSample_);
        } break;
        case (HcalForward): {
          colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
          HcalUnpacker_impl::unpack_compact<HFDataFrame>(i, iend, colls.hfCont->back(), nps, eid, startSample_, endSample_);
        } break;
        case (HcalOther) : {
          HcalOtherDetId odid(did);
          if (odid.subdet()==HcalCalibration) {
        colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
        HcalUnpacker_impl::unpack_compact<HcalCalibDataFrame>(i, iend, colls.calibCont->back(), nps, eid, startSample_, endSample_); 
          }
        } break;
        case (HcalEmpty): 
        default: {
          for (++i;
           i!=iend && !i.isHeader();
           ++i);
        }
        break;
        }
      }
    } else {
      report.countUnmappedDigi(eid);
      if (unknownIds_.find(eid)==unknownIds_.end()) {
        if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
        unknownIds_.insert(eid);
      }
      for (++i;
           i!=iend && !i.isHeader();
           ++i);
    }
      } else if (i.flavor()==0x4) { // TP digis
    int ilink=((i.channelid()>>4)&0xF);
    int itower=(i.channelid()&0xF);
    HcalElectronicsId eid(crate,slot,ilink,itower,true);
    DetId did=emap.lookupTrigger(eid);
#ifdef DebugLog
    std::cout << "Unpacking " << eid << " " << i.channelid() << std::endl;
#endif
    if (did.null()) {
      report.countUnmappedTPDigi(eid);
      if (unknownIdsTrig_.find(eid)==unknownIdsTrig_.end()) {
        if (!silent) edm::LogWarning("HCAL") << "HcalUnpacker: No trigger primitive match found for electronics id :" << eid;
        unknownIdsTrig_.insert(eid);
      }
      // Skip it
      for (++i; i!=iend && !i.isHeader(); ++i); 
    } else if (did==HcalTrigTowerDetId::Undefined || 
           (did.det()==DetId::Hcal && did.subdetId()==0)) {
      for (++i; i!=iend && !i.isHeader(); ++i); 
    } else {
      HcalTrigTowerDetId id(did);
#ifdef DebugLog
      std::cout << "Unpacking " << id << std::endl;
#endif
      colls.tpCont->push_back(HcalTriggerPrimitiveDigi(id));
      int j=0;
      for (++i; i!=iend && !i.isHeader(); ++i) {
        colls.tpCont->back().setSample(j,i.value());
        if (i.soi()) colls.tpCont->back().setPresamples(j);
        j++;
      }
      colls.tpCont->back().setSize(j);
    }      
      } else {
    // consume any not-understood channel data
      for (++i;
           i!=iend && !i.isHeader();
           ++i);    
      }
    }
  }
}

HcalUnpacker::Collections::Collections() {
  hbheCont=nullptr;
  hoCont=nullptr;
  hfCont=nullptr;
  tpCont=nullptr;
  zdcCont=nullptr;
  calibCont=nullptr;
  ttp=nullptr;
  qie10=nullptr;
  qie10ZDC=nullptr;
  qie10Lasermon=nullptr;
  qie11=nullptr;
  umnio=nullptr;
}

void HcalUnpacker::unpack(const FEDRawData& raw, const HcalElectronicsMap& emap, std::vector<HcalHistogramDigi>& histoDigis) {

  // get the DCC header
  const HcalDCCHeader* dccHeader=(const HcalDCCHeader*)(raw.data());
  int dccid=dccHeader->getSourceId()-sourceIdOffset_;
  
  // check the summary status
  
  // walk through the HTR data...
  HcalHTRData htr;
  for (int spigot=0; spigot<HcalDCCHeader::SPIGOT_COUNT; spigot++) {
    if (!dccHeader->getSpigotPresent(spigot)) continue;
    
    int retval=dccHeader->getSpigotData(spigot,htr,raw.size());
    // check
    if (retval || !htr.check()) {
      edm::LogWarning("Invalid Data") << "Invalid HTR data observed on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
      continue;
    }
    if (!htr.isHistogramEvent()) {
      edm::LogWarning("Invalid Data") << "Non-histogram data passed to histogram unpacker on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId();
      continue;
    }

    unsigned int smid=htr.getSubmodule();
    int htr_tb=smid&0x1;
    int htr_slot=(smid>>1)&0x1F;
    int htr_cr=(smid>>6)&0x1F;
    
    // find out the fibers
    int f[2],fc;
    htr.getHistogramFibers(f[0],f[1]);

    for (int nf=0; nf<2; nf++) {
      if (f[nf]<0 || (nf==1 && f[0]==f[1])) continue; // skip if invalid or the same
      for (fc=0; fc<=2; fc++) {
    HcalElectronicsId eid(fc,f[nf],spigot,dccid);     
    eid.setHTR(htr_cr,htr_slot,htr_tb);
    DetId did=emap.lookup(eid);

    if (did.null() || did.det()!=DetId::Hcal || did.subdetId()==0) {
      if (unknownIds_.find(eid)==unknownIds_.end()) {
        edm::LogWarning("HCAL") << "HcalHistogramUnpacker: No match found for electronics id :" << eid;
        unknownIds_.insert(eid);
      }   
      continue;
    }
    histoDigis.push_back(HcalHistogramDigi(HcalDetId(did))); // add it!
    HcalHistogramDigi& digi=histoDigis.back();
    
    // unpack the four capids
    for (int capid=0; capid<4; capid++) 
      htr.unpackHistogram(f[nf],fc,capid,digi.getArray(capid));
    
      }
    }
  }
}
// Method to unpack uMNio data
void HcalUnpacker::unpackUMNio(const FEDRawData& raw, int slot, Collections& colls) {
  const hcal::AMC13Header* amc13=(const hcal::AMC13Header*)(raw.data());
  int namc=amc13->NAMC();
  //Find AMC corresponding to uMNio slot
  for (int iamc=0; iamc<namc; iamc++) {
    if (amc13->AMCSlot(iamc) == slot) namc = iamc;
  }
  if (namc==amc13->NAMC()) {
    return;
  }
  const uint16_t* data = (const uint16_t*)(amc13->AMCPayload(namc));
  size_t nwords = amc13->AMCSize(namc) * ( sizeof(uint64_t) / sizeof(uint16_t) );
  *(colls.umnio) = HcalUMNioDigi(data, nwords);
  
}

void HcalUnpacker::printInvalidDataMessage( const std::string &coll_type, int default_ns, int conflict_ns, bool extended ) {

  nPrinted_++;

  int limit = 20;
  if( nPrinted_ >= limit ) {

      if( nPrinted_ == limit ) edm::LogWarning("Invalid Data") << "Suppressing further error messages" << std::endl;
      
      return;
  }

  std::stringstream message;

  message << "The default " << coll_type << " Collection has " 
        << default_ns << " samples per digi, while the current data has " 
        << conflict_ns << "!  This data cannot be included with the default collection.";

  if( extended ) {
      message << "\nIn order to store this data in the event, it must have a unique tag.  "
              << "To accomplish this, provide two lists to HcalRawToDigi \n"
              << "1) that specifies the number of samples and "
              << "2) that gives tags with which these data are saved.\n"
              << "For example in this case you might add \n"
              << "process.hcalDigis.save" << coll_type << "DataNSamples = cms.untracked.vint32( " 
              << conflict_ns << ") \nprocess.hcalDigis.save" << coll_type << "DataTags = cms.untracked.vstring( \"MYDATA\" )" ;
  }

  edm::LogWarning("Invalid Data") << message.str() << std::endl;
}