DTROS25Unpacker Class Reference

#include <DTROS25Unpacker.h>

Inheritance diagram for DTROS25Unpacker:

Public Member Functions
	DTROS25Unpacker (const edm::ParameterSet &ps)
	Constructor. More...
const std::vector< DTROS25Data > &	getROSsControlData () const
void	interpretRawData (const unsigned int *index, int datasize, int dduID, edm::ESHandle< DTReadOutMapping > &mapping, std::unique_ptr< DTDigiCollection > &product, std::unique_ptr< DTLocalTriggerCollection > &product2, uint16_t rosList=0) override
	~DTROS25Unpacker () override
	Destructor. More...
Public Member Functions inherited from DTUnpacker
	DTUnpacker ()
	Constructor. More...
virtual	~DTUnpacker ()
	Destructor. More...

Private Member Functions
int	swap (int x)

Private Attributes
std::vector< DTROS25Data >	controlDataFromAllROS
bool	debug
int	hardcodedDDUID
	to analyze older data.. More...
bool	localDAQ
	if reading data locally, words, being assembled as 32-bits, do not need to be swapped More...
bool	performDataIntegrityMonitor
	perform DQM on ROS data More...
bool	readDDUIDfromDDU
	since June 2007, local DAQ, provides FED number More...
bool	readingDDU
	if data are read from ROS directly, no information on the ROS Id is present More...
bool	writeSC
	make the local SC spy data persistent More...

Detailed Description

The unpacker for DTs' ROS25: final version of Read Out Sector board with 25 channels.

Author

M. Zanetti INFN Padova FRC 060906

Definition at line 18 of file DTROS25Unpacker.h.

Constructor & Destructor Documentation

DTROS25Unpacker()

DTROS25Unpacker::DTROS25Unpacker

(

const edm::ParameterSet &

ps

)

Constructor.

Definition at line 27 of file DTROS25Unpacker.cc.

References debug, edm::ParameterSet::getUntrackedParameter(), DTskim_cfg::localDAQ, DTskim_cfg::performDataIntegrityMonitor, DTskim_cfg::readDDUIDfromDDU, DTskim_cfg::readingDDU, and DTskim_cfg::writeSC.

                                                          {
  localDAQ = ps.getUntrackedParameter<bool>("localDAQ", false);
  readingDDU = ps.getUntrackedParameter<bool>("readingDDU", true);

  readDDUIDfromDDU = ps.getUntrackedParameter<bool>("readDDUIDfromDDU", true);
  hardcodedDDUID = ps.getUntrackedParameter<int>("dduID", 770);

  writeSC = ps.getUntrackedParameter<bool>("writeSC", false);
  performDataIntegrityMonitor = ps.getUntrackedParameter<bool>("performDataIntegrityMonitor", false);
  debug = ps.getUntrackedParameter<bool>("debug", false);
}

~DTROS25Unpacker()

DTROS25Unpacker::~DTROS25Unpacker ( )

override

Destructor.

Definition at line 39 of file DTROS25Unpacker.cc.

{}

Member Function Documentation

getROSsControlData()

const std::vector<DTROS25Data>& DTROS25Unpacker::getROSsControlData ( ) const

inline

Definition at line 35 of file DTROS25Unpacker.h.

References controlDataFromAllROS.

Referenced by DTDDUUnpacker::getROSsControlData().

{ return controlDataFromAllROS; }

interpretRawData()

void DTROS25Unpacker::interpretRawData ( const unsigned int *  index, int  datasize, int  dduID, edm::ESHandle< DTReadOutMapping > &  mapping, std::unique_ptr< DTDigiCollection > &  product, std::unique_ptr< DTLocalTriggerCollection > &  product2, uint16_t  rosList = 0  )

overridevirtual

Unpacking method. index is the pointer to the beginning of the buffer. datasize is the size of the buffer in bytes

Implements DTUnpacker.

Definition at line 41 of file DTROS25Unpacker.cc.

References DTROS25Data::addROBHeader(), DTROS25Data::addROBTrailer(), DTROS25Data::addROSDebug(), DTROS25Data::addROSError(), DTROS25Data::addROSHeader(), DTROS25Data::addROSTrailer(), DTROS25Data::addSCData(), DTROS25Data::addSCHeader(), DTROS25Data::addSCPrivHeader(), DTROS25Data::addSCPrivSubHeader(), DTROS25Data::addSCTrailer(), DTROS25Data::addTDCData(), DTROS25Data::addTDCError(), DTROBHeaderWord::bunchID(), DTROS25Data::clean(), gather_cfg::cout, debug, DTROSDebugWord::debugMessage(), DTROSDebugWord::debugType(), DTROSErrorWord::errorType(), DTROBHeaderWord::eventID(), DTROBTrailerWord::eventID(), DTLocalTriggerHeaderWord::eventID(), DTROSTrailerWord::EventWordCount(), DTLocalTriggerDataWord::getBits(), DTROChainCoding::getCode(), DTROSWordType::GroupHeader, DTROSWordType::GroupTrailer, DTLocalTriggerDataWord::hasTrigger(), createfilelist::int, DTWireId::layerId(), DTLocalTriggerSectorCollectorSubHeaderWord::LocalBunchCounter(), taus_updatedMVAIds_cff::mapping, DTLocalTriggerSectorCollectorHeaderWord::NumberOf16bitWords(), DTskim_cfg::performDataIntegrityMonitor, funct::pow(), DTTDCErrorNotifier::print(), DTLocalTrigger::print(), DTskim_cfg::readDDUIDfromDDU, DTskim_cfg::readingDDU, DTROSErrorWord::robID(), DTROBHeaderWord::robID(), DTROBTrailerWord::robID(), DTROSWordType::ROSDebug, DTROSWordType::ROSError, DTROSWordType::ROSHeader, DTROSWordType::ROSTrailer, DTROSWordType::SCData, DTLocalTriggerDataWord::SCData(), DTROSWordType::SCHeader, DTROSWordType::SCTrailer, DTROS25Data::setROSId(), std::swap(), DTTDCMeasurementWord::tdcChannel(), DTROSWordType::TDCDebug, DTROSWordType::TDCError, DTTDCMeasurementWord::tdcID(), DTROSWordType::TDCMeasurement, DTTDCMeasurementWord::tdcTime(), DTLocalTriggerDataWord::trackQuality(), DTLocalTriggerSectorCollectorSubHeaderWord::TriggerDelay(), DTROSHeaderWord::TTCEventCounter(), DTROSWordType::type(), DTWireId::wire(), DTROBTrailerWord::wordCount(), DTLocalTriggerTrailerWord::wordCount(), and DTskim_cfg::writeSC.

Referenced by DTDDUUnpacker::interpretRawData().

                                                         {
  int dduID;
  if (readDDUIDfromDDU)
    dduID = dduIDfromDDU;
  else
    dduID = hardcodedDDUID;

  const int wordLength = 4;
  int numberOfWords = datasize / wordLength;

  int rosID = 0;
  DTROS25Data controlData(rosID);
  controlDataFromAllROS.clear();

  int wordCounter = 0;
  uint32_t word = index[swap(wordCounter)];

  map<uint32_t, int> hitOrder;

  /******************************************************
  / The the loop is performed with "do-while" statements
  / because the ORDER of the words in the event data
  / is assumed to be fixed. Eventual changes into the
  / structure should be considered as data corruption
  *******************************************************/

  // Loop on ROSs
  while (wordCounter < numberOfWords) {
    controlData.clean();

    rosID++;  // to be mapped;

    if (readingDDU) {
      // matching the ROS number with the enabled DDU channel
      if (rosID <= 12 && !((rosList & int(pow(2., (rosID - 1)))) >> (rosID - 1)))
        continue;
      if (debug)
        cout << "[DTROS25Unpacker]: ros list: " << rosList << " ROS ID " << rosID << endl;
    }

    // FRC prepare info for DTLocalTrigger: wheel and sector corresponding to this ROS

    int SCwheel = -3;
    int SCsector = 0;
    int dum1, dum2, dum3, dum4;

    if (writeSC && !mapping->readOutToGeometry(dduID, rosID, 1, 1, 1, SCwheel, dum1, SCsector, dum2, dum3, dum4)) {
      if (debug)
        cout << " found SCwheel: " << SCwheel << " and SCsector: " << SCsector << endl;
    } else {
      if (writeSC && debug)
        cout << " WARNING failed to find WHEEL and SECTOR for ROS " << rosID << " !" << endl;
    }

    // ROS Header;
    if (DTROSWordType(word).type() == DTROSWordType::ROSHeader) {
      DTROSHeaderWord rosHeaderWord(word);

      if (debug)
        cout << "[DTROS25Unpacker]: ROSHeader " << rosHeaderWord.TTCEventCounter() << endl;

      // container for words to be sent to DQM
      controlData.setROSId(rosID);
      controlData.addROSHeader(rosHeaderWord);

      // Loop on ROBs
      do {
        wordCounter++;
        word = index[swap(wordCounter)];

        // Eventual ROS Error: occurs when some errors are found in a ROB
        if (DTROSWordType(word).type() == DTROSWordType::ROSError) {
          DTROSErrorWord dtROSErrorWord(word);
          controlData.addROSError(dtROSErrorWord);
          if (debug)
            cout << "[DTROS25Unpacker]: ROSError, Error type " << dtROSErrorWord.errorType() << " robID "
                 << dtROSErrorWord.robID() << endl;
        }

        // Eventual ROS Debugging;
        else if (DTROSWordType(word).type() == DTROSWordType::ROSDebug) {
          DTROSDebugWord rosDebugWord(word);
          controlData.addROSDebug(rosDebugWord);
          if (debug)
            cout << "[DTROS25Unpacker]: ROSDebug, type " << rosDebugWord.debugType() << "  message "
                 << rosDebugWord.debugMessage() << endl;
        }

        // Check ROB header
        else if (DTROSWordType(word).type() == DTROSWordType::GroupHeader) {
          DTROBHeaderWord robHeaderWord(word);
          int eventID = robHeaderWord.eventID();  // from the TDCs
          int bunchID = robHeaderWord.bunchID();  // from the TDCs
          int robID = robHeaderWord.robID();      // to be mapped

          DTROBHeader robHeader(robID, robHeaderWord);  // IJ
          controlData.addROBHeader(robHeader);          // IJ

          if (debug)
            cout << "[DTROS25Unpacker] ROB: ID " << robID << " Event ID " << eventID << " BXID " << bunchID << endl;

          // Loop on TDCs data (headers and trailers are not there)
          do {
            wordCounter++;
            word = index[swap(wordCounter)];

            // Eventual TDC Error
            if (DTROSWordType(word).type() == DTROSWordType::TDCError) {
              DTTDCErrorWord dtTDCErrorWord(word);
              DTTDCError tdcError(robID, dtTDCErrorWord);
              controlData.addTDCError(tdcError);

              DTTDCErrorNotifier dtTDCError(dtTDCErrorWord);
              if (debug)
                dtTDCError.print();
            }

            // Eventual TDC Debug
            else if (DTROSWordType(word).type() == DTROSWordType::TDCDebug) {
              if (debug)
                cout << "TDC Debugging" << endl;
            }

            // The TDC information
            else if (DTROSWordType(word).type() == DTROSWordType::TDCMeasurement) {
              DTTDCMeasurementWord tdcMeasurementWord(word);
              DTTDCData tdcData(robID, tdcMeasurementWord);
              controlData.addTDCData(tdcData);

              int tdcID = tdcMeasurementWord.tdcID();
              int tdcChannel = tdcMeasurementWord.tdcChannel();

              if (debug)
                cout << "[DTROS25Unpacker] TDC: ID " << tdcID << " Channel " << tdcChannel << " Time "
                     << tdcMeasurementWord.tdcTime() << endl;

              DTROChainCoding channelIndex(dduID, rosID, robID, tdcID, tdcChannel);

              hitOrder[channelIndex.getCode()]++;

              if (debug) {
                cout << "[DTROS25Unpacker] ROAddress: DDU " << dduID << ", ROS " << rosID << ", ROB " << robID
                     << ", TDC " << tdcID << ", Channel " << tdcChannel << endl;
              }

              // FRC if not already done for this ROS, find wheel and sector for SC data
              if (writeSC && (SCsector < 1 || SCwheel < -2)) {
                if (debug)
                  cout << " second try to find SCwheel and SCsector " << endl;
                if (!mapping->readOutToGeometry(
                        dduID, rosID, robID, tdcID, tdcChannel, SCwheel, dum1, SCsector, dum2, dum3, dum4)) {
                  if (debug)
                    cout << " ROS " << rosID << " SC wheel " << SCwheel << " SC sector " << SCsector << endl;
                } else {
                  if (debug)
                    cout << " WARNING !! ROS " << rosID << " failed again to map for SC!! " << endl;
                }
              }

              // Map the RO channel to the DetId and wire
              DTWireId detId;
              // if ( ! mapping->readOutToGeometry(dduID, rosID, robID, tdcID, tdcChannel, detId)) {
              int wheelId, stationId, sectorId, slId, layerId, cellId;
              if (!mapping->readOutToGeometry(
                      dduID, rosID, robID, tdcID, tdcChannel, wheelId, stationId, sectorId, slId, layerId, cellId)) {
                // skip the digi if the detId is invalid
                if (sectorId == 0 || stationId == 0)
                  continue;
                else
                  detId = DTWireId(wheelId, stationId, sectorId, slId, layerId, cellId);

                if (debug)
                  cout << "[DTROS25Unpacker] " << detId << endl;
                int wire = detId.wire();

                // Produce the digi
                DTDigi digi(wire, tdcMeasurementWord.tdcTime(), hitOrder[channelIndex.getCode()] - 1);

                // Commit to the event
                detectorProduct->insertDigi(detId.layerId(), digi);
              } else {
                LogWarning("DTRawToDigi|DTROS25Unpacker")
                    << "Unable to map the RO channel: DDU " << dduID << " ROS " << rosID << " ROB " << robID << " TDC "
                    << tdcID << " TDC ch. " << tdcChannel;
                if (debug)
                  cout << "[DTROS25Unpacker] ***ERROR***  Missing wire: DDU " << dduID << " ROS " << rosID << " ROB "
                       << robID << " TDC " << tdcID << " TDC ch. " << tdcChannel << endl;
              }

            }  // TDC information

          } while (DTROSWordType(word).type() != DTROSWordType::GroupTrailer &&
                   DTROSWordType(word).type() != DTROSWordType::ROSError);  // loop on TDC's?

          // Check ROB Trailer (condition already verified)
          if (DTROSWordType(word).type() == DTROSWordType::GroupTrailer) {
            DTROBTrailerWord robTrailerWord(word);
            controlData.addROBTrailer(robTrailerWord);
            if (debug)
              cout << "[DTROS25Unpacker]: ROBTrailer, robID  " << robTrailerWord.robID() << " eventID  "
                   << robTrailerWord.eventID() << " wordCount  " << robTrailerWord.wordCount() << endl;
          }
        }  // ROB header

        // Check the eventual Sector Collector Header
        else if (DTROSWordType(word).type() == DTROSWordType::SCHeader) {
          DTLocalTriggerHeaderWord scHeaderWord(word);
          if (debug)
            cout << "[DTROS25Unpacker]: SC header  eventID " << scHeaderWord.eventID() << endl;

          // RT added : first word following SCHeader is a SC private header
          wordCounter++;
          word = index[swap(wordCounter)];

          if (DTROSWordType(word).type() == DTROSWordType::SCData) {
            DTLocalTriggerSectorCollectorHeaderWord scPrivateHeaderWord(word);

            if (performDataIntegrityMonitor) {
              controlData.addSCPrivHeader(scPrivateHeaderWord);
            }

            int numofscword = scPrivateHeaderWord.NumberOf16bitWords();
            int leftword = numofscword;

            if (debug)
              cout << "                   SC PrivateHeader (number of words + subheader = "
                   << scPrivateHeaderWord.NumberOf16bitWords() << ")" << endl;

            // if no SC data -> no loop ;
            // otherwise subtract 1 word (subheader) and countdown for bx assignment
            if (numofscword > 0) {
              int bx_received = (numofscword - 1) / 2;
              if (debug)
                cout << "                   SC number of bx read-out: " << bx_received << endl;

              wordCounter++;
              word = index[swap(wordCounter)];
              if (DTROSWordType(word).type() == DTROSWordType::SCData) {
                //second word following SCHeader is a SC private SUB-header
                leftword--;

                DTLocalTriggerSectorCollectorSubHeaderWord scPrivateSubHeaderWord(word);
                // read the event BX in the SC header (will be stored in SC digis)
                int scEventBX = scPrivateSubHeaderWord.LocalBunchCounter();
                if (debug)
                  cout << "                   SC trigger delay = " << scPrivateSubHeaderWord.TriggerDelay() << endl
                       << "                   SC bunch counter = " << scEventBX << endl;

                controlData.addSCPrivSubHeader(scPrivateSubHeaderWord);

                // actual loop on SC time slots
                int stationGroup = 0;
                do {
                  wordCounter++;
                  word = index[swap(wordCounter)];
                  int SCstation = 0;

                  if (DTROSWordType(word).type() == DTROSWordType::SCData) {
                    leftword--;
                    //RT: bx are sent from SC in reverse order starting from the one
                    //which stopped the spy buffer
                    int bx_counter = int(round((leftword + 1) / 2.));

                    if (debug) {
                      if (bx_counter < 0 || leftword < 0)
                        cout << "[DTROS25Unpacker]: SC data more than expected; negative bx counter reached! " << endl;
                    }

                    DTLocalTriggerDataWord scDataWord(word);

                    // DTSectorCollectorData scData(scDataWord, int(round(bx_counter/2.))); M.Z.
                    DTSectorCollectorData scData(scDataWord, bx_counter);
                    controlData.addSCData(scData);

                    if (debug) {
                      //cout<<"[DTROS25Unpacker]: SCData bits "<<scDataWord.SCData()<<endl;
                      //cout << " word in esadecimale: " << hex << word << dec << endl;
                      if (scDataWord.hasTrigger(0))
                        cout << " at BX " << bx_counter  //round(bx_counter/2.)
                             << " lower part has trigger! with track quality " << scDataWord.trackQuality(0) << endl;
                      if (scDataWord.hasTrigger(1))
                        cout << " at BX " << bx_counter  //round(bx_counter/2.)
                             << " upper part has trigger! with track quality " << scDataWord.trackQuality(1) << endl;
                    }

                    if (writeSC && SCwheel >= -2 && SCsector >= 1) {
                      // FRC: start constructing persistent SC objects:
                      // first identify the station (data come in 2 triggers per word: MB1+MB2, MB3+MB4)
                      if (scDataWord.hasTrigger(0) || (scDataWord.getBits(0) & 0x30)) {
                        if (stationGroup % 2 == 0)
                          SCstation = 1;
                        else
                          SCstation = 3;

                        // construct localtrigger for first station of this "group" ...
                        DTLocalTrigger localtrigger(scEventBX, bx_counter, (scDataWord.SCData()) & 0xFF);
                        // ... and commit it to the event
                        DTChamberId chamberId(SCwheel, SCstation, SCsector);
                        triggerProduct->insertDigi(chamberId, localtrigger);
                        if (debug) {
                          cout << "Add SC digi to the collection, for chamber: " << chamberId << endl;
                          localtrigger.print();
                        }
                      }
                      if (scDataWord.hasTrigger(1) || (scDataWord.getBits(1) & 0x30)) {
                        if (stationGroup % 2 == 0)
                          SCstation = 2;
                        else
                          SCstation = 4;

                        // construct localtrigger for second station of this "group" ...
                        DTLocalTrigger localtrigger(scEventBX, bx_counter, (scDataWord.SCData()) >> 8);
                        // ... and commit it to the event
                        DTChamberId chamberId(SCwheel, SCstation, SCsector);
                        triggerProduct->insertDigi(chamberId, localtrigger);
                        if (debug) {
                          cout << "Add SC digi to the collection, for chamber: " << chamberId << endl;
                          localtrigger.print();
                        }
                      }

                      stationGroup++;
                    }  // if writeSC
                  }    // if SC data
                } while (DTROSWordType(word).type() != DTROSWordType::SCTrailer);

              }  // end SC subheader
            }    // end if SC send more than only its own header!
          }      //  end if first data following SCheader is not SCData

          if (DTROSWordType(word).type() == DTROSWordType::SCTrailer) {
            DTLocalTriggerTrailerWord scTrailerWord(word);
            // add infos for data integrity monitoring
            controlData.addSCHeader(scHeaderWord);
            controlData.addSCTrailer(scTrailerWord);

            if (debug)
              cout << "                   SC Trailer, # of words: " << scTrailerWord.wordCount() << endl;
          }
        }

      } while (DTROSWordType(word).type() != DTROSWordType::ROSTrailer);  // loop on ROBS

      // check ROS Trailer (condition already verified)
      if (DTROSWordType(word).type() == DTROSWordType::ROSTrailer) {
        DTROSTrailerWord rosTrailerWord(word);
        controlData.addROSTrailer(rosTrailerWord);
        if (debug)
          cout << "[DTROS25Unpacker]: ROSTrailer " << rosTrailerWord.EventWordCount() << endl;
      }

      // Perform dqm if requested:
      // DQM IS PERFORMED FOR EACH ROS SEPARATELY
      if (performDataIntegrityMonitor) {
        //  dataMonitor->processROS25(controlData, dduID, rosID);
        // fill the vector with ROS's control data
        controlDataFromAllROS.push_back(controlData);
      }

    }

    else if (index[swap(wordCounter)] == 0) {
      // in the case of odd number of words of a given ROS the header of
      // the next one is postponed by 4 bytes word set to 0.
      // rosID needs to be step back by 1 unit
      if (debug)
        cout << "[DTROS25Unpacker]: odd number of ROS words" << endl;
      rosID--;
    }  // if ROS header

    else {
      cout << "[DTROS25Unpacker]: ERROR! First word is not a ROS Header" << endl;
    }

    // (needed if there are more than 1 ROS)
    wordCounter++;
    word = index[swap(wordCounter)];

  }  // loop on ROS!
}

swap()

int DTROS25Unpacker::swap ( int  x )

private

Definition at line 428 of file DTROS25Unpacker.cc.

References DTskim_cfg::localDAQ, dqmiodumpmetadata::n, and mps_fire::result.

                               {
  int result = n;

  if (!localDAQ) {
    if (n % 2 == 0)
      result = (n + 1);
    if (n % 2 == 1)
      result = (n - 1);
  }

  return result;
}

Member Data Documentation

controlDataFromAllROS

std::vector<DTROS25Data> DTROS25Unpacker::controlDataFromAllROS

private

Definition at line 59 of file DTROS25Unpacker.h.

Referenced by getROSsControlData().

debug

bool DTROS25Unpacker::debug

private

Definition at line 57 of file DTROS25Unpacker.h.

Referenced by util.rrapi.RRApi::dprint(), rrapi.RRApi::dprint(), pkg.AbstractPkg::generate(), util.rrapi.RRApi::get(), rrapi.RRApi::get(), pkg.AbstractPkg::get_kwds(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), and pkg.AbstractPkg::write().

hardcodedDDUID

int DTROS25Unpacker::hardcodedDDUID

private

to analyze older data..

Definition at line 49 of file DTROS25Unpacker.h.

localDAQ

bool DTROS25Unpacker::localDAQ

private

if reading data locally, words, being assembled as 32-bits, do not need to be swapped

Definition at line 41 of file DTROS25Unpacker.h.

performDataIntegrityMonitor

bool DTROS25Unpacker::performDataIntegrityMonitor

private

perform DQM on ROS data

Definition at line 55 of file DTROS25Unpacker.h.

readDDUIDfromDDU

bool DTROS25Unpacker::readDDUIDfromDDU

private

since June 2007, local DAQ, provides FED number

Definition at line 47 of file DTROS25Unpacker.h.

readingDDU

bool DTROS25Unpacker::readingDDU

private

if data are read from ROS directly, no information on the ROS Id is present

Definition at line 44 of file DTROS25Unpacker.h.

writeSC

bool DTROS25Unpacker::writeSC

private

make the local SC spy data persistent

Definition at line 52 of file DTROS25Unpacker.h.