BeamlineUnpack.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineUnpack.cxx
/// \brief   Methods to interface with the DAQ-formatted output file
///          for the beamline components of the test beam experiment.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    November 2018
////////////////////////////////////////////////////////////////////////////

#include "DAQ2RawDigit/testbeam/BeamlineUnpack.h"

using beamlineutil::BeamlineChannelMap;

// -----------------------------------------------------------------------
artdaq::Fragments* daq2raw::getFragments(TBranch* br, unsigned entry) {
  br->GetEntry(entry);
  return reinterpret_cast<artdaq::Fragments*>(br->GetAddress());
}

// -----------------------------------------------------------------------
void daq2raw::SpillWrapper::add(const artdaq::Fragment& frag) {

  if (nfragments_processed_ == 0) {
    // Basically, it's the LAST of the fragments which is the
    // largest if the spill couldn't be evenly split into four
    // fragments, so that's why we add the "+1" padding to the
    // buffer
    size_t bufsize = (frag.dataSize() + 1) * sizeof(artdaq::RawDataType) * nfragments_ ;
    buffer_.resize( bufsize );
  }

  memcpy( &*buffer_.begin() + size_, frag.dataBeginBytes(), frag.dataSizeBytes() );

  // Bookkeeping
  size_ += frag.dataSizeBytes();
  nfragments_processed_++;

}

// -----------------------------------------------------------------------
void daq2raw::SpillWrapper::add(const art::Event& evt, const art::InputTag& tag) {

  art::ValidHandle<artdaq::Fragments> raw = evt.getValidHandle<artdaq::Fragments>(tag);
  if (raw->size() != 1)
    throw cet::exception("SpillWrapper") << "Error in SpillWrapper::add(): expected 1 artdaq fragment in event, found " 
                                         << raw->size() << std::endl;

  this->add((*raw)[0]);
  return;

}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvent::BeamlineEvent(unsigned int eventNum) {
  fEventNumber = eventNum;
  this->SetGoodEvent();
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvent::~BeamlineEvent() {
}

// -----------------------------------------------------------------------
unsigned int daq2raw::BeamlineEvent::EventNumber() const {
  return fEventNumber;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddConfig(rawdata::RawBeamlineConfig config) {
  fConfig = config;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddTimestamp(uint64_t timestamp) {
  fTimestamp = timestamp;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddTDUTime(uint64_t tduTime) {
  fTDUTime = tduTime;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddTrigger(std::vector<rawdata::RawBeamlineTrigger> trigger) {
  fTrigger = trigger;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddToF(std::vector<rawdata::RawBeamlineDigit> tof) {
  fToF = tof;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddWC(std::vector<rawdata::RawBeamlineWC> wc) {
  fWC = wc;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddCherenkov(std::vector<rawdata::RawBeamlineDigit> cherenkov) {
  fCherenkov = cherenkov;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddMuonStack(std::vector<rawdata::RawBeamlineDigit> muonstack) {
  fMuonStack = muonstack;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddPaddleDigit(std::vector<rawdata::RawBeamlineDigit> paddle) {
  fPaddleDigit = paddle;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddWCDigit(std::vector<rawdata::RawBeamlineDigit> wc) {
  fWCDigit = wc;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::AddOtherDigit(std::vector<rawdata::RawBeamlineDigit> other) {
  fOtherDigit = other;
  return;
}

// -----------------------------------------------------------------------
bool daq2raw::BeamlineEvent::GoodEvent() const {
  return fGoodEvent;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::SetGoodEvent() {
  fGoodEvent = true;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvent::SetBadEvent() {
  fGoodEvent = false;
  return;
}

// -----------------------------------------------------------------------
rawdata::RawBeamlineConfig daq2raw::BeamlineEvent::GetConfig() const {
  return fConfig;
}

// -----------------------------------------------------------------------
uint64_t daq2raw::BeamlineEvent::GetTimestamp() const {
  return fTimestamp;
}

// -----------------------------------------------------------------------
uint64_t daq2raw::BeamlineEvent::GetTDUTime() const {
  return fTDUTime;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineTrigger> daq2raw::BeamlineEvent::GetTrigger() const {
  return fTrigger;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetToF() const {
  return fToF;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineWC> daq2raw::BeamlineEvent::GetWC() const {
  return fWC;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetCherenkov() const {
  return fCherenkov;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetMuonStack() const {
  return fMuonStack;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetPaddleDigit() const {
  return fPaddleDigit;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetWCDigit() const {
  return fWCDigit;
}

// -----------------------------------------------------------------------
std::vector<rawdata::RawBeamlineDigit> daq2raw::BeamlineEvent::GetOtherDigit() const {
  return fOtherDigit;
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvents::BeamlineEvents() {
  fEventIt = -1;
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvents::BeamlineEvents(unsigned int numEvents) {
  fEventIt = -1;
  for (size_t eventIt = 0; eventIt < numEvents; ++eventIt)
    fEvents.emplace_back(new BeamlineEvent(eventIt));
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvents::~BeamlineEvents() {
  for (std::vector<BeamlineEvent*>::iterator eventIt = fEvents.begin();
       eventIt != fEvents.end(); ++eventIt) {
    if (*eventIt)
      delete *eventIt;
    *eventIt = nullptr;
  }
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvents::AddEvent(BeamlineEvent* event) {
  fEvents.push_back(event);
  fEvents_TDUIndex[event->GetTDUTime()] = event;
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvents::AddEvents(std::vector<BeamlineEvent*> events) {
  fEvents.insert(fEvents.end(), events.begin(), events.end());
  return;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineEvents::FilterGoodEvents() {
  fEvents.erase(std::remove_if(fEvents.begin(), 
                               fEvents.end(),
                               [](const BeamlineEvent* e) { return !e->GoodEvent(); }),
                fEvents.end());
  return;
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvent* daq2raw::BeamlineEvents::FindEvent(unsigned int eventNum) {
  if (eventNum >= fEvents.size())
    throw cet::exception("BeamlineUnpack")
      << "Requested event " << eventNum << " does not exist" << std::endl;
  return fEvents[eventNum];
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvent* daq2raw::BeamlineEvents::FindEvent(unsigned long long nova_timestamp) {
  if (fEvents_TDUIndex.count(nova_timestamp))
    return fEvents_TDUIndex[nova_timestamp];
  else
    mf::LogWarning("BeamlineEvents::FindEvent")
      << "Requested event with timestamp " << nova_timestamp << " does not exist" << std::endl;
  return nullptr;
}

// -----------------------------------------------------------------------
unsigned int daq2raw::BeamlineEvents::NumEvents() const {
  return fEvents.size();
}

// -----------------------------------------------------------------------
std::vector<daq2raw::BeamlineEvent*> daq2raw::BeamlineEvents::GetEvents() const {
  return fEvents;
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvent* daq2raw::BeamlineEvents::GetNextEvent() {
  ++fEventIt;
  if (fEventIt >= fEvents.size())
    throw cet::exception("BeamlineUnpack")
      << "Next requested event (" << fEventIt << ") does not exist." << std::endl;
  return fEvents.at(fEventIt);
}

// -----------------------------------------------------------------------
bool daq2raw::BeamlineEvents::IsNextEvent() const {
  return fEventIt+1 < fEvents.size();
}

// -----------------------------------------------------------------------
daq2raw::BeamlineUnpack::BeamlineUnpack(const fhicl::ParameterSet& pset) :
  fBeamlineEvents(nullptr) {
  this->reconfigure(pset);
}

// -----------------------------------------------------------------------
daq2raw::BeamlineUnpack::~BeamlineUnpack() {
  this->EndSpill();
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::reconfigure(const fhicl::ParameterSet& pset) {
  fTriggerSource     = pset.get<std::string>("TriggerSource", "Trigger");
  fUnpackTrigger     = pset.get<bool>("UnpackTrigger",     true);
  fUnpackDigitizer   = pset.get<bool>("UnpackDigitizer",   true);
  fUnpackWireChamber = pset.get<bool>("UnpackWireChamber", true);
  fUnpackTDU         = pset.get<bool>("UnpackTDU",         true);

  fChannelsPerTDC = pset.get<unsigned int>("ChannelsPerTDC", 64);
  fTDCsPerWC      = pset.get<unsigned int>("TDCsPerWC",      2);

  fTriggerLatency = pset.get<unsigned int>("TriggerLatency", 0);
  fTDUOffset      = pset.get<int>         ("TDUOffset",      0);
}

// -----------------------------------------------------------------------
std::vector<TriggerPattern::TriggerPattern_t>
daq2raw::BeamlineUnpack::CleanTriggers(const TriggerFragment& triggerFrag) {

  // filter triggers saved by the trigger
  // board to remove any which occured directly
  // after the previous one
  std::vector<TriggerPattern::TriggerPattern_t> beamlineTriggers;

  uint32_t prevT = 0;
  for (size_t trigIt = 0; trigIt < triggerFrag.triggerFragment.nEntries; ++trigIt) {

    TriggerPattern::TriggerPattern_t pattern =
      triggerFrag.triggerFragment.patterns[trigIt];

    if (pattern.timeStamp - prevT > fTriggerLatency)
      beamlineTriggers.push_back(pattern);

    prevT = pattern.timeStamp;

  }

  return beamlineTriggers;

}

// -----------------------------------------------------------------------
std::vector<TDUFragment*>
daq2raw::BeamlineUnpack::CleanTDU(const std::vector<TDUFragment*>& tduFrags) {

  // filter just beamline triggers from
  // the TDU timestamps
  std::vector<TDUFragment*> beamlineTDUs;

  // also remove duplicated timestamps
  std::vector<uint64_t> prevTs;

  for (std::vector<TDUFragment*>::const_iterator tduFragIt = tduFrags.begin();
       tduFragIt != tduFrags.end(); ++tduFragIt) {

    const TDUFragment::TDUFragment_t& tduFrag = (*tduFragIt)->tduFragment[0];

    if (tduFrag.type == 1 and
        std::find(prevTs.begin(), prevTs.end(), tduFrag.timestamp) == prevTs.end()) {
      beamlineTDUs.push_back(*tduFragIt);
      prevTs.push_back(tduFrag.timestamp);
    }

  }

  return beamlineTDUs;

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::EndSpill() {
  if (fBeamlineEvents)
    delete fBeamlineEvents;
  fBeamlineEvents = nullptr;
}

// -----------------------------------------------------------------------
daq2raw::BeamlineEvents* daq2raw::BeamlineUnpack::GetBeamlineEvents() const {
  return fBeamlineEvents;
}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::Unpack(const LariatFragment* spillFrag,
                                     const std::vector<TDUFragment*> tduFrags,
                                     unsigned int run,
                                     std::string filename) {

  // get trigger information
  const TriggerFragment triggerFrag = spillFrag->triggerFragment;

  // get digits
  const std::vector<V1742Fragment> v1742Frags = spillFrag->v1742Frags;

  // get wire chambers
  TDCFragment tdcFrag;
  if (fUnpackWireChamber and spillFrag->tdcFrags.size())
    tdcFrag = spillFrag->tdcFrags[0];

  mf::LogVerbatim("BeamlineUnpack::Unpack")
    << "There are " << triggerFrag.triggerFragment.nEntries << " triggers, "
    << v1742Frags.size() << " digitizer triggers, "
    << tdcFrag.tdcEvents.size() << " wire chamber triggers and "
    << tduFrags.size() << " TDU timestamps." << std::endl;

  // clean up various fragments of data
  std::vector<TriggerPattern::TriggerPattern_t> triggers_clean
    = CleanTriggers(triggerFrag);
  std::vector<TDUFragment*> tdu_clean = CleanTDU(tduFrags);

  mf::LogVerbatim("BeamlineUnpack::Unpack")
    << "After cleaning, there are " << triggers_clean.size() << " triggers, "
    << v1742Frags.size() << " digitizer triggers, "
    << tdcFrag.tdcEvents.size() << " wire chamber triggers and "
    << tdu_clean.size() << " TDU timestamps." << std::endl;

  // for testing and commissioning, we may have variable numbers of triggers
  // in each component.
  // deal with all possibilities
  unsigned int numTriggers = 0;
  if (fTriggerSource == "Trigger")
    numTriggers = triggers_clean.size();
  else if (fTriggerSource == "Digitizer")
    numTriggers = v1742Frags.size();
  else if (fTriggerSource == "WireChamber")
    numTriggers = tdcFrag.tdcEvents.size();
  else if (fTriggerSource == "TDU")
    numTriggers = tdu_clean.size();

  // strictly enforce the correct number of fragments for each of the
  // front-end data components we are trying to unpack
  if ((fUnpackTrigger and triggers_clean.size() != numTriggers) or
      (fUnpackDigitizer and v1742Frags.size() != numTriggers) or
      (fUnpackWireChamber and tdcFrag.tdcEvents.size() != numTriggers) or
      (fUnpackTDU and tdu_clean.size() != numTriggers))
    throw cet::exception("BeamlineUnpack")
      << "Inconsistent number of data fragments: "
      << "Triggers: " << triggers_clean.size() << "; "
      << "Digitizer: " << v1742Frags.size() << "; "
      << "Wire Chambers: " << tdcFrag.tdcEvents.size() << "; "
      << "TDU: " << tdu_clean.size() << "."
      << std::endl;

  // make a new BeamlineEvents object to contain the information
  fBeamlineEvents = new BeamlineEvents(numTriggers);

  // get the spill information
  //LariatFragment::SpillTrailer spillFrag = frag->spillTrailer;

  // unpack everything
  this->UnpackConfig(run);
  if (fUnpackTrigger or fUnpackTDU)
    this->UnpackTrigger(triggers_clean, tdu_clean, filename);
  if (fUnpackDigitizer)
    this->UnpackDigits(v1742Frags);
  if (fUnpackWireChamber)
    this->UnpackWC(tdcFrag);

  return;

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::UnpackConfig(unsigned int run) {

  rawdata::RawBeamlineConfig config;

  // beamline run
  config.SetBeamlineRun(run);

  // magnetic field
  float b_field = 0.;
  try {
    b_field = fMagneticField->MagneticField(run);
  }
  catch (cet::exception& e) {
    e.what();
  }
  config.SetBField(b_field);

  for (unsigned int event = 0; event < fBeamlineEvents->NumEvents(); ++event)
    fBeamlineEvents->FindEvent(event)->AddConfig(config);

  return;

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::UnpackTrigger(const std::vector<TriggerPattern::TriggerPattern_t>& beamlineTriggers,
                                            const std::vector<TDUFragment*>& beamlineTDUs,
                                            std::string filename) {

  // get number of triggers
  unsigned int numTrigs = fUnpackTDU ?
    beamlineTDUs.size() : beamlineTriggers.size();

  // get metadata, containing other information about the trigger
  std::string metadata;
  if (!filename.empty()) {
    char* fullpathname = (char*)filename.c_str();
    std::string relfilename = std::string(basename(fullpathname));
    art::ServiceHandle<IFDH> ifdhp;
    try {
      metadata = ifdhp->getMetadata(relfilename);
    }
    catch (WebAPIException) {
      metadata = "";
    }
  }

  // get trigger condition for this file
  std::string trigger_condition = "";
  std::istringstream metadataStream;
  metadataStream.str(metadata);
  while (metadataStream.good()) {
    std::string line, key, value;
    std::getline(metadataStream, line);
    size_t pos = line.find(":");
    if (pos != std::string::npos) {
      key = line.substr(0, pos);
      value = line.substr(pos+1);
      if (key.find("Beamline.BeamlineTrigger") != std::string::npos) {
        value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
        trigger_condition = value;
      }
    }
  }

  // make new RawBeamlineTriggers
  for (unsigned int triggerIt = 0; triggerIt < numTrigs; ++triggerIt) {

    // get timestamps
    uint64_t timestamp =
      fUnpackTrigger? static_cast<uint64_t>(beamlineTriggers[triggerIt].timeStamp) : 0;
    long double timestamp_ns = timestamp * 10; //ns

    // get tdu timestamp
    uint64_t tduTime = fUnpackTDU? (beamlineTDUs[triggerIt]->tduFragment.at(0).timestamp + fTDUOffset) : 0;

    // make trigger object
    rawdata::RawBeamlineTrigger trigger(fChannelMap->TrigDetector(),
                                        triggerIt);
    trigger.SetTimestamp(timestamp_ns);
    trigger.SetPattern(fUnpackTrigger? beamlineTriggers[triggerIt].inputPattern : 0);
    trigger.SetTDUTime(tduTime);
    trigger.SetTriggerCondition(trigger_condition);
    std::vector<rawdata::RawBeamlineTrigger> triggers = {trigger};

    // add to event
    fBeamlineEvents->FindEvent(triggerIt)->AddTrigger(triggers);
    fBeamlineEvents->FindEvent(triggerIt)->AddTimestamp(timestamp_ns);
    fBeamlineEvents->FindEvent(triggerIt)->AddTDUTime(tduTime);

  }

  return;

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::UnpackDigits(const std::vector<V1742Fragment>& frags) {

  // Look through all triggers
  for (unsigned int v1742FragIt = 0; v1742FragIt < frags.size(); ++v1742FragIt) {

    const V1742Fragment& v1742Frag = frags[v1742FragIt];

    std::vector<rawdata::RawBeamlineDigit> cherenkovDigits, tofDigits,
      muonStackDigits, paddleDigits, wcDigits, otherDigits;

    // Get all channels for this V1742 fragment
    for (unsigned int waveform = 0; waveform < v1742Frag.waveForms.size(); ++waveform) {

      if (!fChannelMap->ActiveDigitChannel(waveform))
        continue;

      uint64_t timestamp
        = static_cast<uint64_t>(v1742Frag.triggerTimeStamps[static_cast<int>(waveform/8)]); // timestamps are saved per group
      long double timestamp_ns = static_cast<long double>(timestamp) * 8.5; //ns

      rawdata::RawBeamlineDigit digit(fChannelMap->DigitChannel(waveform));
      digit.SetWaveform(v1742Frag.waveForms[waveform].data);
      digit.SetTimestamp(timestamp_ns);

      switch (digit.ChannelID().System) {
      case beamlinegeo::BeamlineSystem::Cherenkov:
        cherenkovDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::ToF:
        tofDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::MuonStack:
        muonStackDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::Paddle:
        paddleDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::WCDigit:
        wcDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::Other:
        otherDigits.push_back(digit); break;
      default:
        break;
      }

    }

    fBeamlineEvents->FindEvent(v1742FragIt)->AddToF(tofDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddCherenkov(cherenkovDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddMuonStack(muonStackDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddPaddleDigit(paddleDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddWCDigit(wcDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddOtherDigit(otherDigits);

  }

  return;

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineUnpack::UnpackWC(const TDCFragment& frag) {

  // loop over events
  unsigned int event = 0;
  std::vector<std::vector<TDCFragment::TdcEventData> > tdcEvents = frag.tdcEvents;
  for (std::vector<std::vector<TDCFragment::TdcEventData> >::const_iterator tdcEventIt = tdcEvents.begin();
       tdcEventIt != tdcEvents.end(); ++tdcEventIt, ++event) {

    std::vector<rawdata::RawBeamlineWC> wcs(fGeometry->NumWCs());
    for (unsigned int wc_num = 0; wc_num < wcs.size(); ++wc_num)
      wcs[wc_num] = rawdata::RawBeamlineWC(fChannelMap->WCDetector(wc_num));

    // get the timestamp for this event
    // Non-trivial!
    // See https://cdcvs.fnal.gov/redmine/attachments/51083/TDC_Format_Description_B.pdf for a full description
    // Each TDC header has a 'controller timestamp' (16 bit, 1.18 ns ticks) and 'tdc timestamp' (32 bit, 9.4 ns ticks)
    //  --> I _believe_ they should be the same for each TDC in the event (so enforce this)
    // The bits 11..3 for the controller timestamp should be identical to bits 8..0 in the TDC timestamp
    // In order to construct the full timestamp, need to concatenate the 3 lsbs from the controller timestamp
    //   to the TDC timestamp to make a 35 bit word.  This is a timestamp in 1.18 ns ticks since the start of the spill
    std::map<unsigned int, uint16_t> controllerTimestamps;
    std::map<unsigned int, uint32_t> tdcTimestamps;

    // loop over TDCs in this event
    for (std::vector<TDCFragment::TdcEventData>::const_iterator tdcIt = tdcEventIt->begin(); tdcIt != tdcEventIt->end(); ++tdcIt) {

      unsigned int tdcNumber = (int)tdcIt->tdcEventHeader.tdcNumber - 1;
      unsigned int wcNumber = tdcNumber / fGeometry->NumWCs();
      unsigned int tdc_on_wc = tdcNumber % fGeometry->NumWCs();
      unsigned int tdc_on_plane = tdc_on_wc % fTDCsPerWC;
      unsigned int plane_on_wc = tdc_on_wc / fTDCsPerWC;

      // timestamps
      controllerTimestamps[tdcNumber] = tdcIt->tdcEventHeader.controllerTimeStamp;
      tdcTimestamps[tdcNumber] = tdcIt->tdcEventHeader.tdcTimeStamp;

      // overflow register, one for each TDC so if any are set then the whole WC gets true
      if (tdcIt->tdcEventHeader.eventStatus != 0)
        fBeamlineEvents->FindEvent(event)->SetBadEvent();

      // loop over hits in this TDC
      for (std::vector<TDCFragment::TdcHit>::const_iterator hitIt = tdcIt->tdcHits.begin(); hitIt != tdcIt->tdcHits.end(); ++hitIt) {
        unsigned int channel_on_plane = (tdc_on_plane * fChannelsPerTDC) + (int)hitIt->channel;
        rawdata::RawBeamlineWC::WCPulse pulse(channel_on_plane, hitIt->timeBin);
        plane_on_wc ? wcs[wcNumber].AddYPulse(pulse) : wcs[wcNumber].AddXPulse(pulse);
      }

    }

    // form total timestamp for event relative to start of spill
    for (std::map<unsigned int, uint16_t>::const_iterator controllerTsIt = controllerTimestamps.begin();
         controllerTsIt != controllerTimestamps.end(); ++controllerTsIt)
      if (controllerTsIt->second != controllerTimestamps.begin()->second)
        throw cet::exception("BeamlineUnpack::UnpackWC")
          << "WC controller timestamps differ between TDC fragments." << std::endl;

    for (std::map<unsigned int, uint32_t>::const_iterator tdcTsIt = tdcTimestamps.begin();
         tdcTsIt != tdcTimestamps.end(); ++tdcTsIt)
      if (tdcTsIt->second != tdcTimestamps.begin()->second)
        throw cet::exception("BeamlineUnpack::UnpackWC")
          << "TDC timestamps differ between TDC fragments." << std::endl;

    uint32_t tdcTs = tdcTimestamps.begin()->second;
    uint32_t controllerTs = controllerTimestamps.begin()->second;

    uint16_t tdcCommon = tdcTs & 0x1FFu;
    uint16_t controllerCommon = (controllerTs & 0xFF8u) >> 3;
    if (tdcCommon != controllerCommon)
      throw cet::exception("BeamlineUnpack::UnpackWC")
        << "Synchronization problem between MWPC controller and TDC timestamps." << std::endl
        << "Bits 8..0 of TDC timestamp " << std::bitset<9>(tdcCommon) << "; "
        << "bits 11..3 of controller timetamp " << std::bitset<9>(controllerCommon) << std::endl;

    uint64_t timestamp = static_cast<uint64_t>(((std::bitset<35>(tdcTimestamps.begin()->second) << 3) |
                                                (std::bitset<35>(controllerTimestamps.begin()->second & 0x7))).to_ullong());
    long double timestamp_ns = timestamp * 1.18; //ns
    for (std::vector<rawdata::RawBeamlineWC>::iterator wcIt = wcs.begin(); wcIt != wcs.end(); ++wcIt)
      wcIt->SetTimestamp(timestamp_ns);

    fBeamlineEvents->FindEvent(event)->AddWC(wcs);

  }

  return;

}