/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/f12MicrorocXDaqReader.cpp

Go to the documentation of this file.

/* @version $Revision: 1624 $ * @modifiedby $Author: lcdet $ * @lastmodified $Date: 2012-03-30 14:49:30 +0200 (Fri, 30 Mar 2012) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR MICROROC BOARDS
//
////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include "parser/MicrorocXDaqReader.hh"
#include "parser/MicrorocSCReader.hh"
#include "parser/AcquisitionParser.hh"

#include "event/Event.hh"

#include "geometry/Chamber.hh"
#include "geometry/Board.hh"
#include "geometry/Dif.hh"
#include "geometry/MicrorocChip.hh"
#include "geometry/Detector.hh"

#include "tools/Toolbox.hh"
#include "tools/SteerDesc.hh"
#include "tools/Log.hh"
#include "tools/MicroException.hh"


#include "lcio.h"
#include "IO/LCReader.h"
#include "IMPL/LCTOOLS.h"
#include "IMPL/LCGenericObjectImpl.h"
#include "EVENT/LCCollection.h"
#include "EVENT/LCRunHeader.h"

#include "geometry/MicrorocChannel.hh"

#include "ilcConfDb/IlcConfDb.hh"


#include <iostream>
#include <iomanip>


#define NBBYTETOSKIP  94

using namespace std;
using namespace lcio ;


////////////////////////////////////////////////////////////////////////
MicrorocXDaqReader::MicrorocXDaqReader(Run& aRun, string aFileFullPath, ui32 lastEventId, set<unsigned int>*_difList) : MicrorocReader(aRun, NULL, lastEventId), nbChipPerLine(0), analogDataActivate(false), firstEvent(true), slowControlSet(false), difList(_difList)

{
  FILE_LOG(logDEBUG1) << "--MicrorocXDaqReader constructor()"<< endl;

  lcReader = LCFactory::getInstance()->createLCReader() ;
  try {
    lcReader->open(aFileFullPath);
/* Seems to be not set by XDAQ
    EVENT::LCRunHeader *runHeader = lcReader->readNextRunHeader();
    if ( runHeader != NULL ) 
    {
      cout << "-------------runNumber: " << runHeader->getRunNumber() << endl;
      cout << "-------------runDetectorName: " << runHeader->getDetectorName() <<endl;
      cout << "-------------runDescription: " << runHeader->getDescription() <<endl;
      exit (10);
    }
    else { cout << "runHeader == NULL: "  << endl; }
*/
  }
  catch( IOException& e) {
    cout << e.what() << endl ;
    exit(-1) ;
  }
  
  if ( lcReader == NULL ) { exit(-1); }

  for ( ui16 line = 0 ; line < NBLINE ; line++)
  {
    analogDataActivatedLine[line] = false;
  }

  localReset();

}

//--------------- Destructeur -------------//
MicrorocXDaqReader::~MicrorocXDaqReader()
{
  lcReader->close();
  delete lcReader;
  FILE_LOG(logDEBUG1)<< "----MicrorocXDaqReader destructor"<< endl;
}
                                                                                                             
//--------------- reset -------------//
void MicrorocXDaqReader::localReset()
{
  reset(); // appel MicrorocReader::reset();
  slowControlSet = false;
  rawdataList.clear();
}
//------------------------------------------//
int MicrorocXDaqReader::getScData()
{
return 0;
}
//------------------------------------------//
int MicrorocXDaqReader::getNextEvent(Event& event) 
{
  Level(0);
  ui16 dataFormat = run.getDataFormat();

  if (dataFormat == 0) {
    // first read of the file
    bcIdDifAbsOrgMap.clear();
    // read file header
    dataFormat = 1;
    run.setDataFormat(dataFormat);
    //FILE_LOG(logINFO) << " labview data format[" << hex << dataFormat << "] "<< endl;
    //run.setDaqSoftware(333);
    //run.setCccFirmware(333);
    //globalTime = 333;
    
    return NEW_CONFIG;
  } // end dataFormat == 0

  // loops until a non-empty event has been found
  bool eventFound = false;
  while (! eventFound)
  {
    LCEvent* lcioEvt(0) ;
    lcioEvt = lcReader->readNextEvent() ;
    if ( lcioEvt == NULL ) // EOF reach
    {
      return LAST_FILE_EVENT;
    }


    // There is one more LCEvent
    //LCTOOLS::dumpEvent( lcioEvt ) ;
    if ( ! slowControlSet )
    {
      // Read Slow control from database
      if ( event.getRun().getId() == 0 )
      {  // try to find run Id in lcioEvt
        run.setId(lcioEvt->getRunNumber());
        FILE_LOG(logINFO) << "Set run Id from lcioEvent information[" << run.getId() << "]" << endl;
      }
      globalTime = lcioEvt->getTimeStamp();

      run.setDaqSoftware(0);
      run.setCccFirmware(0);

      IlcConfDb *ilcconf = IlcConfDb::getInstance();
      if ( ilcconf != NULL )
      {
        MicrorocSCReader scReader(run);
        scReader.parseSCFromDb(*ilcconf);
        slowControlSet = true;
      }

    }
    
    if ( firstEvent )
    {
      FILE_LOG(logINFO) << "firstEvent  skip"  << endl;
      firstEvent = false;
      // skip first event because of its corruption ???
    }
    else
    {
      // vnames to store lcioEvt collections name
      std::vector<std::string >* vnames;
      try
      {
        vnames= (std::vector<std::string >*)lcioEvt->getCollectionNames();
        /*
        cout << "run number: " << lcioEvt->getRunNumber()<< endl;
        cout << "event number: " << lcioEvt->getEventNumber()<< endl;
        cout << "timestamp: " << lcioEvt->getTimeStamp()<< endl;
        cout << "detectorName: " << lcioEvt->getDetectorName()<< endl;
        cout << "weight: " << lcioEvt->getWeight()<< endl;
        */
        for ( vector<std::string >::iterator it = vnames->begin();  it!= vnames->end(); it++)
        {
          if ((*it).compare("RU_XDAQ")==0)
          {
            EVENT::LCCollection* col= lcioEvt->getCollection(*it);
    //        cout << "collection name:["<< *it << "]"  << endl;

            for (int difRawDataIndex=0;difRawDataIndex<col->getNumberOfElements(); difRawDataIndex++)
            {
              IMPL::LCGenericObjectImpl* go= (IMPL::LCGenericObjectImpl*) col->getElementAt(difRawDataIndex);
              int rusize =go->getNInt();
     //         std::cout<<" New RU found with "<<rusize<<" int stored" <<std::endl;
              if ( rusize == 56 ) continue; // skip first RU_XDAQ si tsille est 56 int

              int shift=-1;
              ui16 nbInt = go->getNInt();
      //        cout << "DEBUG ---nbInt [" << dec << nbInt << "]-----------------" <<endl;

              
              unsigned int buf[go->getNInt()];

              for (int k=0; k < (go->getNInt() );k++) { buf[k] = go->getIntVal(k); }
              // skip first NBBYTETOSKIP ( 94 ) bytes 
              // then fill rawdataList with unsigned char
              unsigned char* bufChar = ( unsigned char* ) &(buf); 
              ui16 rapport = (ui16) (sizeof(unsigned int ) / sizeof ( unsigned char) );

              rawdataList.clear();
              for ( ui32 j = NBBYTETOSKIP ; j < go->getNInt()*rapport ; j++ )
              {
                rawdataList.push_back(*(bufChar+j));
              }
              
              itRawdata = rawdataList.begin();
              unsigned int globalHeader = getData(1);
       //       cout << "globalHeader[" << hex << globalHeader <<  "]" << endl;

              if (globalHeader == 0xB1) {
                // slow control data
                getScData();
                exit(-1); // Conf in Oracle DB not in raw data
              }
              else if (globalHeader == 0xC0) {
                // acquisition data
                getAnalogData(event);
              }
              else if (globalHeader == 0xB0) {
                // acquisition data
                getAcqData(event,bufChar);
                //eventFound = true;
              }
              else {
                FILE_LOG(logERROR) << "  parsing file error. global header error : " << hex << globalHeader << dec << endl;
              }
            } // end for data for dif
            eventFound = true ;
            event.setId(++lastEventId);
          } // ed if collection = XU_XDAQ
          /*
          else  if ((*it).compare("DHCALRawHits")==0)  
          {
            std::cout << "--- Found Collection DHCALRawHits" << endl;
            EVENT::LCCollection* col= lcioEvt->getCollection("DHCALRawHits");
            std::cout << "--- col lcioEvt->getCollection(\"DHCALRawHits\") " << col << endl;
          }
          */
        } // end for collection in event
      }
      catch (IOException& e)
      {
        std::cout << e.what() << std::endl ;
        std::string s=e.what();s+=__PRETTY_FUNCTION__;
        exit(-1);
      }
      catch (...)
      {
        std::cout<<" unknow io exeption "<<std::endl;
        exit(-1);
      }
      /*DEBUG */  unsigned int globalHeader = 0XB0;
    } // end else not first event

    
  }// end while event not found

  return EVENT_CORRECT;





return 0;
}
//------------------------------------------//
int MicrorocXDaqReader::getAcqData(Event& event,unsigned char *bufChar) 
{
 ui32 nbanalogHit = 0;
  unsigned int nbHits = 0;

  display(+1);
  FILE_LOG(logDEBUG) << " global header B0 found" << endl;


  this->setComputeCrcFlag(true);
  //FILE_LOG(logDEBUG) << "MicrorocLabviewReader crc adr[" <<  crc << "]" << endl;
   FILE_LOG(logDEBUG) << "crc->compute(0xB0)[ "<< crc <<"]"   << endl;

  crc->compute(0xB0);



  // reset the data for the block
  //  bcId_AbsOrg = -1;
  bcId_Abs = 0; // max. 48 bits
  bcId_Dif = 0;
  // the following data is repeated one time for each Dif which has sent data
  difId = getData(1);

  difTriggerCounter = getData(4);
  usbBusyTrigger = getData(4);  // trigger counter version >= 4
  globalTriggerCounter = getData(4);

  ui64 bcIdHigh = getData(2);
  ui64 bcIdLow = getData(4);
  bcId_Abs = (bcIdHigh << 32) + bcIdLow;
  //FILE_LOG(logDEBUG) << "bcId_Abs[" << hex << bcId_Abs <<  endl;

  bcId_Dif = getData(3);

  bcId_AbsOrg =  getbcIdAbsOrg(difId, bcId_Abs);
  display();

/* NOT IMPLEMENTAED ??? 
  ui16 lineInfo =  getData(1);
  FILE_LOG(logDEBUG)   << " lineInfo[" <<hex << lineInfo << "]"  << endl;
  ui16 nbLine   = (lineInfo & 0xF0 ) >> 4;
  ui16 usedLine = lineInfo & 0x0F; //bit 3 (4eme ligne,)  bit 2 (3eme ligne)  bit 1 (2eme ligne)  bit 0 (1ere ligne)
  display();
*/



 // the bcTime in milliseconds
  i64 bcTime = ((bcId_Abs - bcId_AbsOrg) * bcPeriod) / 1000;
  // the reading time in milliseconds
  i64 readTime = globalTime + bcTime;

  FILE_LOG(logDEBUG)   << "  START EVENT ------------- time " << readTime << " ms" << endl;
  FILE_LOG(logDEBUG)   << "    bc time               " << bcTime << " ms" << endl;
  FILE_LOG(logDEBUG)   << "    DIF Id                0x" << hex << (int)difId << dec << endl;
  FILE_LOG(logDEBUG)   << "    DIF trigger counter   " << difTriggerCounter << endl;
  FILE_LOG(logDEBUG)   << "    USB Busy trigger counter   " << usbBusyTrigger << endl;
  FILE_LOG(logDEBUG)   << "    total trigger counter " << globalTriggerCounter << endl;
  FILE_LOG(logDEBUG)   << "    absolute bcId         " << bcId_Abs - bcId_AbsOrg << endl;
 // FILE_LOG(logDEBUG)   << "    nb line          " << dec <<nbLine << endl;
 // FILE_LOG(logDEBUG)   << "    used line        " << hex << usedLine << dec <<endl;
  event.setDifTriggerCounter(difTriggerCounter);
  event.setGlobalTriggerCounter(globalTriggerCounter);


  Detector &detector = run.getDetector();

  if ( analogDataActivate )//&& orderInChipMemory == 0 )
  {
    for ( map<ui16,map<ui16,ui16> >::iterator iterAnal = analogData.begin(); iterAnal!= analogData.end(); iterAnal++)
    {
       map<ui16,ui16>& byChip = iterAnal->second;
       ui16 chipId = iterAnal->first;
      // When analog is anable, all channel of all chip enable for analogic respond
      for ( std::map<ui16,ui16>::iterator iterChip = byChip.begin(); iterChip != byChip.end();iterChip++)
      {
        ui16 analogValue =  iterChip->second;
        ui16 channelId = iterChip->first;
        if ( difList == NULL || difList->find(difId) != difList->end()  ) // No difid filter or difId in difList
        {
          nbHits += newHit(event, detector, 0, analogValue,channelId , chipId, difId);
          nbanalogHit++;
        }
      }
    }
  }
  // end of global header

 bool difFound = false;
  { const ChamberMap_t &chambers = detector.getChambers();
    for (ChamberMap_t::const_iterator it = chambers.begin(); it != chambers.end(); ++it) {
      try {
        Chamber& chamber = *(it->second);
        const BoardMap_t& boards = chamber.getBoardsByDifId(difId);
      }
      catch (...) {
        // any error case - try next chamber
        continue;
      }

      // the DIF has been found in a chamber. Process all data and continue
      difFound = true;
      break;
    } // for
    if (!difFound) {
      FILE_LOG(logERROR) << "    No dif found with Id 0x" << hex << difId << ", " << dec << difId << "                                     " <<endl;
    }
  }

  for (bool finish = false; !finish; ) {
    int delimiter = 0;

    display();
    for (; delimiter != 0xA0 && delimiter != 0xB4; ) {
      // seek for first data frame header (0xB4)
      delimiter = getData(1);
      if (fileError == EOF) {
        delimiter = 0;
        break;
      }
      if (delimiter == 0xA3)
        FILE_LOG(logERROR) << "    frame trailer A3 found -- should not" << endl;
    }
    if (delimiter == 0x00) {
      FILE_LOG(logERROR) << "  end of file -- should not" << endl;
      break;
    }
    if (delimiter == 0xA0) {
   FILE_LOG(logDEBUG) << "    frame trailer A0 found" << endl;
      this->setComputeCrcFlag(false);
      unsigned short CRC_check = getData(2);
      FILE_LOG(logDEBUG) << hex << " Compute CRC[" << crc->getCrc() << "]" <<  endl;
      FILE_LOG(logDEBUG) << hex << " Received CRC[" << CRC_check << "]" <<  endl;
      if ( CRC_check != crc->getCrc() )
      {
        FILE_LOG(logERROR)  << " CRC Error for event id " <<  lastEventId << endl;
        FILE_LOG(logERROR) << hex << " Compute CRC[" << crc->getCrc() << "]" <<  endl;
        FILE_LOG(logERROR) << hex << " Received CRC[" << CRC_check << "]" <<  endl;
        event.setCrcIsCorrect(false);
       // exit(-1);
      }
      else
      {
        event.setCrcIsCorrect(true);
      }

      display(-1);
      FILE_LOG(logDEBUG) << " global trailer A0 found" << endl;
      break;
    }
    display(+1);
    FILE_LOG(logDEBUG) << "   frame header B4 found" << endl;


    int chipId = -1;
    ui16 orderInChipMemory = 0;
    for (; ; )  // Read in chip memory for different BCId_HIT. 
    {
      chipId = getData(1);
      FILE_LOG(logDEBUG) << "8 bits read[" << chipId << "] [0x"  << hex << chipId << "]" << dec << endl;

      if (fileError == EOF) {
        finish = true;
        FILE_LOG(logINFO) << "    end of file found -- should not" << endl;
        break;
      }
      if (chipId == 0x00) {
        // dummy null bytes
        continue;
      }
  else if (chipId == 0xA3) {
        display(-1);
        FILE_LOG(logDEBUG) << "   frame trailer A3 found" << endl;
        break;
      }
      else if (chipId == 0xA0) {
        finish = true;
        display(-1);
//        FILE_LOG(logERROR) << "    global trailer A0 found -- should not" << endl;
        //int CRC_check = getData(1);
        break;
      }
      else if (chipId == 0xC3) {
        display(-1);
        FILE_LOG(logERROR) << "    frame trailer C3 found - error occured during data transfer" << endl;
        break;
      }

      // bcId from hardroc chip is counted as Gray code
      bcId_Hit = grayToBinary(getData(3));
      // event time in milliseconds
      eventTime = readTime + (((bcId_Dif - bcId_Hit) * bcPeriod) / 1000);

      orderInChipMemory++;
      // not on first line and bcId OK : get and check data
      if (difFound)
      {
        FILE_LOG(logDEBUG) << "      chip Id               0x" << hex << (int)chipId << dec << endl;
        FILE_LOG(logDEBUG) << "      bcId Microroc          " << hex << (int)bcId_Hit << endl;
        FILE_LOG(logDEBUG) << "      event time            " << eventTime << endl;

        for (int chNum = 48; chNum >= 0; chNum -= 16)  // read data ( 128) for different channel Id with same BCID_HIT
        {
          unsigned int data4 = getData(4); // lit 4 bytes => 8 char => 16 canaux
          for (int index = 0; index < 16; index++)
          {
              // sur les 16 canaux, recupere les donnees canal par canal
            int trigger = (data4 >> ((15 - index) * 2)) & 0x03; // 2 bits
            // store new event data if any
    if (trigger)  // on elimine tous les hits dans la valeur est 0 
            {
              if ( difList == NULL || difList->find(difId) != difList->end()  ) // No difid filter or difId in difList
              { 
                 if ( analogDataActivate && orderInChipMemory == 1 )
                 {
                  i16 analogValue = analogData[chipId][index + chNum];
                  nbHits += newHit(event, detector, trigger, analogValue, index + chNum, chipId, difId,orderInChipMemory);
                 }
                 else
                 {
                  nbHits += newHit(event, detector, trigger, 0, index + chNum, chipId, difId,orderInChipMemory);
                 }
              }

                //digital[index+chNum]=trigger;
                FILE_LOG(logDEBUG) << "digital chipId[" << chipId << "] channelNum["<< index+chNum <<"]= " << trigger << endl;
            }
          } // for (index)
        } // End digital data. for (chNum)
      }
    display();
    } // for(;;)

  } // for (;;)
  display(-1);

 // CREATE EVENT for current Run

// if ( nbHits > 0 )
// {
  event.setTimeStamp(globalTime + ((bcId_AbsOrg /1000000 * bcPeriod) )  );  // globalTime -> millisecond and bcId_AbsOrg * bcPeriod -> nano second
  //FILE_LOG(logINFO) << "  event.setTimeStamp  " <<  event.getTimeStamp()  << endl;
  //event.setId(++lastEventId);
  FILE_LOG(logINFO) << "  Add Hit for event  EVENT " << lastEventId << ", " << nbHits << " hits \r" << flush;
//  FILE_LOG(logINFO) << "  Add Hit for event  EVENT " << lastEventId << ", " << nbHits << " hits " << endl;
// }
// else
// {
//  FILE_LOG(logDEBUG) << "  EMPTY EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
// }


  if (SkippedBcId) {
    FILE_LOG(logWARNING) << "    skipped " << SkippedBcId << " data because of bad bcId" << endl;
    SkippedBcId = 0;
  }

  return(nbHits);


}

//------------------------------------------//
int MicrorocXDaqReader::getAnalogData(Event& event) 
{
return 0;
}

//------------------------------------------//
unsigned int MicrorocXDaqReader::getData(const unsigned int nBytes)
{
unsigned int result = 0;

  fileError = 0;
  for (unsigned int byte = 0; byte < nBytes; ++byte) 
  {
    unsigned int data = *itRawdata;
    itRawdata++;
    if ( computeCrc ) 
    {
      crc->compute(data) ;
    }
    result = (result << 8) + data;
  }

putData(result, nBytes);

return result;
}

//------------------------------------------//
/*
void MicrorocXDaqReader::display(const int inc) {
  line++;
  if (inc < 0) {
    level += inc;
    if (level < 0) level = 0;
  }
    FILE_LOG(logDEBUG) << setfill(' ') << setw(level * 2) << "display[" << hex << (unsigned int)( *itRawdata )<< "]" << endl;

  if (inc > 0)
    level += inc;
} // DifReader.display
*/

---