DTSpyReader.cc

Go to the documentation of this file.

 
#include <IORawData/DTCommissioning/plugins/DTSpyReader.h>
#include <IORawData/DTCommissioning/plugins/DTFileReaderHelpers.h>
 
#include <DataFormats/FEDRawData/interface/FEDHeader.h>
#include <DataFormats/FEDRawData/interface/FEDTrailer.h>
#include <DataFormats/FEDRawData/interface/FEDNumbering.h>
 
#include "DataFormats/Provenance/interface/EventID.h"
#include <DataFormats/Provenance/interface/Timestamp.h>
 
#include <DataFormats/FEDRawData/interface/FEDRawDataCollection.h>
 
#include <FWCore/ParameterSet/interface/ParameterSet.h>
 
#include <string>
#include <iosfwd>
#include <iostream>
#include <algorithm>
#include <cstdio>
 
using namespace std;
using namespace edm;
 
DTSpyReader::DTSpyReader(const edm::ParameterSet& pset) : runNumber(1), eventNumber(0) {
  // instatiating Sandro's spy (My name is Bond, Sandro Bond)
  mySpy = new DTSpy();
 
  string connectionParameters = pset.getUntrackedParameter<string>("connectionParameters");
  mySpy->Connect(connectionParameters.c_str(), 10000);
 
  cout << endl;
  cout << "DT Local DAQ online spy. Connected to IP " << connectionParameters.c_str()
       << ". Waiting for the data to be flushed" << endl;
  cout << endl;
 
  debug = pset.getUntrackedParameter<bool>("debug", false);
  dduID = pset.getUntrackedParameter<int32_t>("dduID", 770);  // NOT needed
 
  produces<FEDRawDataCollection>();
}
 
DTSpyReader::~DTSpyReader() { delete mySpy; }
 
int DTSpyReader::fillRawData(Event& e,
                             //Timestamp& tstamp,
                             FEDRawDataCollection*& data) {
  EventID eID = e.id();
 
  // ask for a new buffer
  mySpy->getNextBuffer();
 
  // get the pointer to the beginning of the buffer
  const char* rawDTData = mySpy->getEventPointer();
 
  const uint32_t* rawDTData32 = reinterpret_cast<const uint32_t*>(rawDTData);
 
  // instantiate the FEDRawDataCollection
  data = new FEDRawDataCollection();
 
  vector<uint64_t> eventData;
  uint64_t word = 0;
  int wordCount = 0;
  int wordCountCheck = 0;
 
  bool headerTag = false;
  bool dataTag = true;
 
  // Advance at long-word steps until the trailer is reached.
  // Skipped whatever else is in the buffer (e.g. another event..)
  while (!isTrailer(word, dataTag, wordCount)) {
    // dma gets 4 32-bits words and create a 64 bit one
    word = dmaUnpack(rawDTData32, dataTag);
 
    // look for the DDU header
    if (isHeader(word, dataTag))
      headerTag = true;
 
    // check whether the first word is a DDU header
    if (wordCountCheck > 0 && !headerTag && debug)
      cout << "[DTSpyReader]: WARNING: header still not found!!" << endl;
 
    // from now on fill the eventData with the ROS data
    if (headerTag) {
      // swapping only the 32 bits words
      if (dataTag)
        swap(word);
      // WARNING also the ddu status words have been swapped!
      // Control the correct interpretation in DDUUnpacker
 
      eventData.push_back(word);
      wordCount++;
    }
 
    // advancing by 4 32-bits words
    rawDTData32 += 4;
 
    // counting the total number of group of 128 bits (=4*32) in the buffer
    wordCountCheck++;
  }
 
  // Setting the Event ID
  runNumber = mySpy->getRunNo();
  eID = EventID(runNumber, 1U, eventNumber);
 
  // eventDataSize = (Number Of Words)* (Word Size)
  int eventDataSize = eventData.size() * dduWordLength;
 
  if (debug)
    cout << " DDU ID = " << dduID << endl;
 
  FEDRawData& fedRawData = data->FEDData(dduID);
  fedRawData.resize(eventDataSize);
 
  copy(reinterpret_cast<unsigned char*>(&eventData[0]),
       reinterpret_cast<unsigned char*>(&eventData[0]) + eventDataSize,
       fedRawData.data());
 
  mySpy->setlastPointer((char*)rawDTData32);
 
  return true;
}
 
void DTSpyReader::produce(Event& e, EventSetup const& es) {
  edm::Handle<FEDRawDataCollection> rawdata;
  FEDRawDataCollection* fedcoll = nullptr;
  fillRawData(e, fedcoll);
  std::unique_ptr<FEDRawDataCollection> bare_product(fedcoll);
  e.put(std::move(bare_product));
}
 
void DTSpyReader::swap(uint64_t& word) {
  twoNibble64* newWorld = reinterpret_cast<twoNibble64*>(&word);
 
  uint32_t msBits_tmp = newWorld->msBits;
  newWorld->msBits = newWorld->lsBits;
  newWorld->lsBits = msBits_tmp;
}
 
uint64_t DTSpyReader::dmaUnpack(const uint32_t* dmaData, bool& isData) {
  uint32_t unpackedData[2] = {0, 0};
  // adjust 4 32-bits words  into 2 32-bits words
  unpackedData[0] |= dmaData[3] & 0x3ffff;
  unpackedData[0] |= (dmaData[2] << 18) & 0xfffc0000;
  unpackedData[1] |= (dmaData[2] >> 14) & 0x0f;
  unpackedData[1] |= (dmaData[1] << 4) & 0x3ffff0;
  unpackedData[1] |= (dmaData[0] << 22) & 0xffc00000;
 
  isData = (dmaData[0] >> 10) & 0x01;
 
  //printf ("Lower part: %x \n", unpackedData[0]);
  //printf ("Upper part: %x \n", unpackedData[1]);
 
  // push_back to a 64 word
  uint64_t dduWord = (uint64_t(unpackedData[1]) << 32) | unpackedData[0];
 
  return dduWord;
}
 
bool DTSpyReader::isHeader(uint64_t word, bool dataTag) {
  bool it_is = false;
  FEDHeader candidate(reinterpret_cast<const unsigned char*>(&word));
  if (candidate.check()) {
    // if ( candidate.check() && !dataTag) {
    it_is = true;
    dduID = candidate.sourceID();
    eventNumber++;
  }
  return it_is;
}
 
bool DTSpyReader::isTrailer(uint64_t word, bool dataTag, unsigned int wordCount) {
  bool it_is = false;
  FEDTrailer candidate(reinterpret_cast<const unsigned char*>(&word));
  if (candidate.check()) {
    //  if ( candidate.check() && !dataTag) {
    if (wordCount == candidate.fragmentLength())
      it_is = true;
  }
  return it_is;
}