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

Go to the documentation of this file.

/* @version $Revision: 1922 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-10-24 15:21:19 +0200 (Wed, 24 Oct 2012) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR HARDROC BOARDS
//
////////////////////////////////////////////////////////////////////////
// v7 8.6.2009
//    29.6.2009 : added timestamps with Microroc data
////////////////////////////////////////////////////////////////////////
// timestamp (v7) :
//   t(hit) = t(lecture) - t2 + t3
//   l(lecture) = t0 + (t1 - t10)
//   avec
//     t0 = timestamp unix (32 bits, avec ou sans millisecondes)
//     t1 = BcId absolu (bcId_Abs, 48 bits)
//     t10 = premiere lecture de t1
//     t2 = BcId pour la DIF (bcId_HRHit, 24 bits)
//     t3 = BCId pour la HR (bcId_Hit, 24 bits en CODE GRAY)
////////////////////////////////////////////////////////////////////////

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

#include "mTypes.h"

#include "parser/MicrorocMergeReader.hh"
#include "parser/AcquisitionParser.hh"
#include "parser/MicrorocSCReader.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 <iostream>
#include <iomanip>

using namespace std;

////////////////////////////////////////////////////////////////////////
MicrorocMergeReader::MicrorocMergeReader(Run& aRun, FILE *aFile, ui32 lastEventId, bool _forceAnalog, set<unsigned int>*_difList) : MicrorocReader(aRun, aFile, lastEventId), slowControlSet(false), difList(_difList) , hexTemperatureAsu1(0), hexTemperatureAsu2(0), hexTemperatureDif(0), nbChipPerLine(0), analogDataActivate(false), forceAnalog(_forceAnalog), debugEventId(0)

{
  FILE_LOG(logDEBUG1) << "--MicrorocMergeReader constructor()"<< endl;
  FILE_LOG(logDEBUG) << "MicrorocMergeReader Constructeur  crc adr[" <<  crc << "]" << endl;

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


  localReset();
}

//--------------- Destructeur -------------//
MicrorocMergeReader::~MicrorocMergeReader()
{
  FILE_LOG(logDEBUG1)<< "----MicrorocMergeReader destructor"<< endl;
}


//--------------- reset -------------//
void MicrorocMergeReader::localReset()
{
  reset(); // appel MicrorocReader::reset();
  slowControlSet = false;
  hexTemperatureAsu1 = 0;
  hexTemperatureAsu2 = 0;
  hexTemperatureDif = 0;

}

//------------------------------------------//
int MicrorocMergeReader::decodeData(Event& event)
{
              unsigned int globalHeader = getSpecificData(1);
              if (fileError == EOF) 
              {
                FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
                reset();
                return(LAST_FILE_EVENT);
              }

              FILE_LOG(logDEBUG) << "Header: [0x"<< hex << globalHeader << "]"  << endl;
              

              if (globalHeader == 0xB1) {
                // slow control data
                getScData();
              }
              else if (globalHeader == 0xB0) {
                // acquisition data
                this->analogData.clear();
                FILE_LOG(logDEBUG) << "  0xB0 found " << hex << globalHeader << dec << endl;
                getAcqData(event);
                return  true;
              }
              else if (globalHeader == 0xBB) {
                // acquisition data
                FILE_LOG(logDEBUG) << "TEMPERATURE FILL  0xBB found " << hex << globalHeader << dec << endl;
                getAcqData(event,true);
                return true;
              }
              else {
                FILE_LOG(logERROR) << "  parsing file error. global header error : " << hex << globalHeader << dec << endl;
               event.setValidFlag(GLOBAL_HEADER_ERROR,false);
              }
}

//------------------------------------------//
 int MicrorocMergeReader::getAcqData(Event& event, bool temperatureFill)
{

  ui32 nbanalogHit = 0;
  unsigned int nbHits = 0;

  display(+1);


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

  if ( temperatureFill )
  {
    FILE_LOG(logDEBUG) << " global header BB found" << endl;
    FILE_LOG(logDEBUG) << "crc->compute(0xBB)[ "<< crc <<"]"   << endl;
    crc->compute(0xBB);
  }
  else
  {
    FILE_LOG(logDEBUG) << " global header B0 found" << 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 = getSpecificData(1);

  difTriggerCounter = getSpecificData(4);
  informationCounter = getSpecificData(4);  // trigger counter version >= 4
  globalTriggerCounter = getSpecificData(4);

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

  bcId_Dif = getSpecificData(3);

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

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


  if ( temperatureFill )
  {
    hexTemperatureAsu1 = getSpecificData(4);
    display();
    FILE_LOG(logDEBUG)   << " hexTemperatureAsu1[0x" <<hex << hexTemperatureAsu1 << "]"  << endl;
    hexTemperatureAsu2 = getSpecificData(4);
    display();
    FILE_LOG(logDEBUG)   << " hexTemperatureAsu2[0x" <<hex << hexTemperatureAsu2 << "]"  << endl;
    hexTemperatureDif = getSpecificData(1) & 0xFF;
    display();
    FILE_LOG(logDEBUG)   << " hexTemperatureDif[0x" <<hex << hexTemperatureDif << "]"  << endl;
/*
  Pour les temperature des ASU
1) j'enleve les 16 bits de poids fort (bit31 a bit16). Le bit 15 signifie alors le bit de signe
    C'est a dire qu'il faut que tu mette(bit15 à bit0) dans un integer signé à 16 bits.

2) il faut supprimer les 3  bits de poids faible (bit2 à bit0). moi, je l'ai fait par une division entiere par 8 (pour garder le signe). Autrement, si tu préfères, tu pourrais faire une décalage de 3 bits des (bits14 à bits0)

3) il faut diviser le chiffre restant par 16 pour avoir le résultat en degré Celsius.
Cyril.

4/ Pour les nouvelles sonde ( bit 31 == 1 ) il faut encore diviser le resultat par 2
*/
    i16 hex16tempAsu1 = hexTemperatureAsu1 & 0x7FFF;
    float tempAsu1 = (float) ((hex16tempAsu1 / 16 ) / 8 );
    if (( hexTemperatureAsu1 & 0x8000) == 0x8000) { tempAsu1 = tempAsu1 / 2 ; }
    FILE_LOG(logDEBUG)   << " TemperatureAsu1[" <<dec << tempAsu1 << "]"  << endl;

    i16 hex16tempAsu2 = hexTemperatureAsu2 & 0x7FFF;
    float tempAsu2 = (float) ((hex16tempAsu2 / 16 ) / 8 );
    if ( ( hexTemperatureAsu2 & 0x8000 ) == 0x8000) { tempAsu2 = tempAsu2 / 2 ; }
    FILE_LOG(logDEBUG)   << " TemperatureAsu2[" <<dec << tempAsu2 << "]"  << endl;

/* 
Pour la temperature de la Dif
Vlsb est une constante = 20
(ca veut dire qu'un lsb de l'adc de la DIF vaut 20mV)

Nadc = les 8 bits que tu recois

Temperature = la conversion en degré Celsius
================================================

float V_adc ;
float  V_lm20 ;

conversion ADC 
V_adc = ( Nadc * Vlsb ) ;

ampli gain 33K/10K avec point milieu à 1,5V 
V_lm20 = ( (6450 - V_adc) / 3.3 ) ;

calcul du premier ordre du lm20 pour T entre -30°C et 100°C 
Temperature = (  (V_lm20 - 1860.5) / (-11.77)  ) ;
*/
    float Vlsb = 20.0;
    float V_adc = hexTemperatureDif * Vlsb;
    float V_lm20 = ( (6450. - V_adc) / 3.3 ) ;
    float tempDif = (V_lm20 - 1860.5) / (-11.77);

    FILE_LOG(logDEBUG)   << " TemperatureDif[" <<dec << tempAsu2 << "]"  << endl;

    event.setTemperature(difId, tempAsu1,    tempAsu2 , tempDif);

  }

  // 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)   << "    Information counter   " << informationCounter << 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();

  // 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 (detector.getMonitoringId() == difId)
    {
       difFound = true;
    }
    if (!difFound) {
      FILE_LOG(logERROR) << "    No dif found with Id 0x" << hex << difId << ", " << dec << difId << "                                     " <<endl;
      event.setValidFlag(BAD_DIF_ID,false);

    }
  }

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

    display();
    for (; delimiter != 0xA0 && delimiter != 0xB4 && delimiter != 0xC4; ) {
      // seek for first data frame header (0xB4)
      delimiter = getSpecificData(1);
      FILE_LOG(logDEBUG) << " delimiter[0x" <<hex << delimiter << "] " << endl;
      if (fileError == EOF) {
        delimiter = 0;
        break;
      }
      if (delimiter == 0xA3)
      {
        FILE_LOG(logERROR) << "    frame trailer A3 found -- should not" << endl;
        event.setValidFlag(FRAME_HEADER_ERROR,false);
      }
    }
    if (delimiter == 0x00) {
      FILE_LOG(logERROR) << "  end of file -- should not" << endl;
      event.setValidFlag(END_OF_FILE_ERROR,false);
      break;
    }
    if (delimiter == 0xA0)
    {
      FILE_LOG(logDEBUG) << "    frame trailer A0 found" << endl;
      this->setComputeCrcFlag(false);
      unsigned short CRC_check = getSpecificData(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
                            <<  " Compute CRC[" << crc->getCrc()
                            << "] Received CRC[" << CRC_check << "]" <<  endl ;
        event.setCrcIsCorrect(false);
        event.setValidFlag(CRC_ERROR,false);
      }
      display(-1);
      FILE_LOG(logDEBUG) << " global trailer A0 found" << endl;
      break;
    }
  if (delimiter == 0xC4)
    {
      //computeCrc = false;
      Dif& dif = run.getDetector().getDifById(difId);
      FILE_LOG(logDEBUG) << "analog dif[" << difId << "] " << endl;

      analogDataActivate = true;
      ui16 lineNum = 1;
      ui16 nbChipByBoard = dif.getBoards().begin()->second->getNbColumns();
      ui16 nbBoard =  dif.getBoards().size();
      FILE_LOG(logDEBUG) << "nbBoard[" << nbBoard << "]" <<endl;
      FILE_LOG(logDEBUG) << "nbChipByBoard[" << nbChipByBoard << "]" <<endl;

      for ( ui16 iLine = 0 ; iLine < nbLine ; iLine++)
      {
        FILE_LOG(logDEBUG)  << "usedLine[" << usedLine << "] lineNum[" << lineNum << "]" << "usedLine & lineNum[" <<  (usedLine & lineNum) <<  "]" << endl;
        if ( usedLine & lineNum ) // LINE 1
        {
          ui16 nbChips = getSpecificData(1);
          FILE_LOG(logDEBUG)  << endl << " Line " << lineNum << " nb Chip[" << dec <<  nbChips << "]"  << endl;

          // Le SlowControl permet de savoir si il y a 1 ou 2 ASU de connectes a la Dif. Si il n'y a qu'un ASU
          // alors  ASUID 1 ou ASUID 2 = 0 dans le slowcontrol
          // Dans le cas ou il y a les deux ASU connectes a la Dif, c'est le ASU le plus eloigne ( col ==  ? ) de la Dif qui parle 
          // en 1er

          ui16 uniqBoard = 99;
          ui16 nbChipForLoop = 12;
          FILE_LOG(logDEBUG) << "-------- ASU 1 Id[0x" <<hex << dif.getAsu1Id() << "]" << endl;
          FILE_LOG(logDEBUG) << "-------- ASU 2 Id[0x" <<hex << dif.getAsu2Id() << "]" << endl;
          if ( dif.getAsu1Id() == 0 && dif.getAsu2Id() == 0)
          {
            FILE_LOG(logERROR)<< "SlowControl Error dif.getAsu1Id()==0 AND dif.getAsu1Id() ==0 " << endl;
            exit(0);
          }

          else if ( dif.getAsu1Id() == 0) { uniqBoard = 1; nbChipForLoop = 6; }
          else if ( dif.getAsu2Id() == 0) { uniqBoard = 0; nbChipForLoop = 6; }
          FILE_LOG(logDEBUG)<< "uniqBoard[" << uniqBoard << "] nbChipForLoop[" << nbChipForLoop << "]" << endl;
          
          for ( i32 col = nbChipForLoop -1  ; col >= 0; col--)
          {
              
            FILE_LOG(logDEBUG)<< "col[" << col << "]" << endl;
            ui16 board = col / nbChipByBoard;
            if ( uniqBoard == 0 ) { board = 0; }
            else if ( uniqBoard == 1 ) { board = 1; }
            FILE_LOG(logDEBUG)<< "board[" << board << "]" << endl;


            FILE_LOG(logDEBUG)<< dec << "board [" << board << "] line[" << lineNum-1 << "] col[" <<  col << "]" << endl;
            Chip& chip = dif.getChipByRowCol(board, lineNum-1,col % 6);   // board / row /column
            FILE_LOG(logDEBUG)<< "chip id[" << chip.getId() << "]" << endl;
            if( chip.getBypassed() == false )
            {
              FILE_LOG(logDEBUG)<< dec << "not bypassed chip Id[" << chip.getId() << "]" << endl;
              map<ui16,ui16> channelsValues;
              for ( ui16 iChannel = 0 ; iChannel < 64 ; iChannel++)
              {
                ui16 foo = getSpecificData(2);
                foo = foo & 0x0fff; // Seul les 2 dernier bits correspondent a  adc_slab_value
                channelsValues[iChannel] = foo;
                FILE_LOG(logDEBUG) << "difId["<< dif.getId() << "] ,chipId["<< chip.getId() <<"] analogData line["<< line <<
                                      "], col number["<< col << "] , channel[" << iChannel << "]= [0x" << hex <<foo << "]" << dec << endl;
              } // end for iChannel
              this->analogData[chip.getId()] = channelsValues;
            }
          } // end for iChip
        } // end if usedLine
        else {
          iLine--;
        }
        lineNum++;
     } // end for iLine
     //computeCrc = true;
      if ( forceAnalog )
      {
        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++;
            }
          }
        }
      }
      ui16 header = getSpecificData(1);
      display(1);
      if ( header != 0xd4 ) 
      {
        FILE_LOG(logERROR) << "Frame header 0xd4 not found" << endl;
      }
      else
      {
        FILE_LOG(logDEBUG) << "Frame header 0xd4 found" << endl;
      }

    } // end if delimiter 0xC4

    if (delimiter == 0xB4)
    {
      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 = getSpecificData(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);
          break;
        }
        else if (chipId == 0xC3) {
          display(-1);
          FILE_LOG(logERROR) << "    frame trailer C3 found - error occured during data transfer" << endl;
          event.setValidFlag(TRAILER_C3_FOUND,false);
          break;
        }


        bcId_Hit = grayToBinary(getSpecificData(3));
        FILE_LOG(logDEBUG) << dec << "bcId_Hit[" << bcId_Hit << "]" << endl;

        orderInChipMemory++;

/*
        // Test du bit de suppression de donnée
        bool supress = (chipId & 0x80) >> 7;   // bit de poinds fort
        FILE_LOG(logINFO) << "suppress[" << supress << "]"  << endl;
        if ( supress )
        {
          chipId = chipId & 0x7F ; // supression du bit de poinds fort

          ui16 supressInfo = getSpecificData(1);
          FILE_LOG(logDEBUG) << hex << "supressInfo[0x" << supressInfo << "]" << endl;

          ui16 nbDiffer = supressInfo & 0x3F ; // bits de 0 a 5
          ui16 supressType = supressInfo & 0xC0 ; // bit 6 et 7 
          FILE_LOG(logDEBUG) << dec << "nbDiffer[" << nbDiffer << "]" << endl;
          FILE_LOG(logDEBUG) << dec << "type de suppression(00,01,10 ou 11) [" << supressType << "]" << endl;


          set<ui16> channels;
          for ( int index = 0; index < 64; index ++ )
          {
            channels.insert(index);
          }
  
          for ( int index = 0; index < nbDiffer ; index++ )
          {
            //  information pour les channel hits non suprimmer
            ui16 channelInfo = getSpecificData(2);
            FILE_LOG(logDEBUG) << hex << "channel info not deleted[0x" << channelInfo << "]" << endl;
            ui16 channelId = channelInfo & 0xfc;
            FILE_LOG(logDEBUG) << dec << "channel id not deleted[0x" << channelId << "]" << endl;
            ui16 level = channelInfo & 0x03;
            FILE_LOG(logDEBUG) << dec << "channel level not deleted[0x" << level << "]" << endl;
            channels.erase(channelId);
            nbHits += newHit(event, detector, level, 0, channelId, chipId, difId,orderInChipMemory);
          }
          // On cree un hit sur tous les autres channels dont les donnees ont ete suprime
          set<ui16>::const_iterator myIterator; 
          for(myIterator = channels.begin(); myIterator != channels.end(); myIterator++)
          {
            FILE_LOG(logDEBUG) << *myIterator << endl;    
            ui16 channelId = *myIterator;
            FILE_LOG(logDEBUG) << dec << "new hit for channel Id not deleted[" << channelId << "]" << endl;
            nbHits += newHit(event, detector, supressType, 0, channelId, chipId, difId,orderInChipMemory);
          }


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

          // not on first line and bcId OK : get and check data
          if (difFound)
          {
            for (int chNum = 48; chNum >= 0; chNum -= 16)  // read data ( 128) for different channel Id with same BCID_HIT
            {
              unsigned int data4 = getSpecificData(4); // lit 4 bytes => 8 char => 16 canaux
              if ( data4 == 0xffffffff )
              {
                event.setValidFlag(ONLY_FFFF);
                FILE_LOG(logDEBUG) << "event.setValidFlag(ONLY_FFFF)" << endl;
              }
              else if  ( data4 == 0xaaaaaaaa )
              {
                event.setValidFlag(ONLY_AAAA);
                FILE_LOG(logDEBUG) << "event.setValidFlag(ONLY_AAAA)" << endl;
              }
              else if  ( data4 == 0x55555555 )
              {
                event.setValidFlag(ONLY_5555);
                FILE_LOG(logDEBUG) << "event.setValidFlag(ONLY_5555)" << endl;
              }
              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
                //FILE_LOG(logDEBUG) << "trigger[" << trigger << "]"  << endl;
                // store new event data if any
                if (trigger)  // on elimine tous les hits dans la valeur est 0 
                {
                  FILE_LOG(logDEBUG) << "difId[" << difId << "]"  << endl;
                  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);
                     }
                  }
                }
              } // for (index)
            } // End digital data. for (chNum)
          }
        //} // end else not date supress activate
        display();
      } // for(;;)
    }  // end if delimiter = 0xB4
  } // for (;;)
  display(-1);

 // CREATE EVENT for current Run

  event.setTimeStamp(globalTime + ((bcId_AbsOrg /1000000 * bcPeriod) )  );  // globalTime -> millisecond and bcId_AbsOrg * bcPeriod -> nano second
  FILE_LOG(logDEBUG) << "Dif[" << dec << difId << "]  Number of created hit for event  EVENT " << lastEventId << ", " << nbHits << " total hits, within " << nbanalogHit << " analogic hits" << endl;



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

  return(nbHits);


} // END  int MicrorocMergeReader::getAcqData(Event& event, bool temperatureFill)

//------------------------------------------//
int MicrorocMergeReader::getScData() {

  display(+1);



  ui16 dataFormat = run.getDataFormat();
  FILE_LOG(logDEBUG) << " Slow Control data format[" << dec << dataFormat << "]" << endl;
  if ( dataFormat == 15  || dataFormat == 14 )
  {

  // DIF ID ( 8 bits )
  difId=getData(1); // in case of dataFormat = 7 Difid is not in data file
  FILE_LOG(logINFO) << " Slow Control dif Id[" << dec << difId << "]" << endl;
  try {
    Dif& dif = run.getDetector().getDifById(difId);

  if ( dif.getBoards().size() == 2 )
  {

    // ASU ID 1 ( 16 bits)
    dif.setAsu1Id(getData(2));
    FILE_LOG(logDEBUG) << "-------- ASU 1 Id[0x" <<hex << dif.getAsu1Id() << "]" << endl;
    display(+1);
    if ( dif.getAsu1Id() != 0)
    {
      if ( dif.getBoardByCol(0).getId() !=  dif.getAsu1Id() )
      {
        FILE_LOG(logERROR) << "Error data say ASU id =  "<<  dif.getAsu1Id() << " for ASU close to DIF ( left side ) while XML say ASU id = " 
                          << dif.getBoardByCol(0).getId() << endl;
        FILE_LOG(logERROR) << "Please consider modifying XML file" << endl;
        exit(-1);
      }
    }


    // ASU ID 2 ( 16 bits)
    dif.setAsu2Id(getData(2));
    FILE_LOG(logDEBUG) << "-------- ASU 2 Id[0x" <<hex << dif.getAsu2Id() << "]" << endl;
    display(+1);
    if (  dif.getAsu2Id() != 0)
    {
      if ( dif.getBoardByCol(1).getId() !=  dif.getAsu2Id() )
      {
        FILE_LOG(logERROR) << "Error data say ASU id =  "<<  dif.getAsu2Id() << " for ASU far away to DIF ( right side ) while XML say ASU id = " 
                          << dif.getBoardByCol(1).getId() << endl;
        FILE_LOG(logERROR) << "Please consider modifying XML file" << endl;
        exit(-1);
      }
    }
  }

  else if (dif.getBoards().size() == 1)  // ASU dans la boite test
  {
    ui32 asuId1 = getData(2);
    ui32 asuId2 = getData(2);

    if ( asuId1 != 0 )
    {
      dif.setAsu1Id(asuId1);  // ASU loin de la dif
    }
    else
    {
      dif.setAsu1Id(asuId2);
    }
    FILE_LOG(logDEBUG) << "-------- ASU 1 Id[0x" <<hex << dif.getAsu1Id() << "]" << endl;
  }



    // set all chip to byppassed = True.
    // then each chip prensent in Slow control will by set to bypassed = False 
    dif.setChipByPassed(true);


  // nb ASIC ( 8 bits)
    ui16 nbAsic = getData(1);
    display(+1);
    FILE_LOG(logDEBUG) << "--- nb Asic[" << nbAsic << "] ---" << endl;

    
  // Size SC ASIC ( 8 bits)
    ui16 scsize = getData(1);
    display(+1);
    FILE_LOG(logDEBUG) << "--- sc size 74 or 109[" << dec << scsize << "] ---" << endl;


    for ( ui32 index = 0 ; index < nbAsic; index++)
    {
      const unsigned char *buf = initGetBits(scsize, false);
      vector<int> sc;
      for ( ui16 i = 0 ; i<scsize ; i++ )
      {
        ui16 scAsic = getBits(8) ;
        sc.push_back(scAsic);
      }
      MicrorocSCReader scReader(run,sc,difId);
      scReader.parseSC(difId);
      FILE_LOG(logDEBUG) << "Finish SC for asic [" <<dec <<  index <<"]" << endl;
    }
    finishGetBits();
    int foo = getData(1);
    FILE_LOG(logDEBUG) << "Header[" <<hex <<  foo <<"]" << endl;
    if ( foo != 0xa1)
    {
      FILE_LOG(logERROR) << "  Header A1 not found" << endl;
      exit (-1);
    }
    FILE_LOG(logDEBUG) << "Header A1 found" << endl;
    FILE_LOG(logINFO) << "SlowControl read successfully" << endl;
  }
  catch (MicroException &e) { 
   FILE_LOG(logERROR) << "Slow control error" << endl;
    ui16 foo2 = 0xff;
    while ( foo2 != 0xb0  && foo2 !=0 &&  fileError != EOF)
    {
      ui16 foo = getData(1);
      while ( foo != 0xa1 )
      {
        foo = getData(1);
        FILE_LOG(logDEBUG) << "-- Wait foo 0xa1[" << hex << foo << "]" << endl;
      }
      foo2 = getData(1);
      FILE_LOG(logDEBUG) << "-- Wait foo 0xb0[" << hex << foo << "]" << endl;

    }
  }
  }
  else
  {
    FILE_LOG(logERROR) << " Slow Control format " << dec << dataFormat << " is not implemeted" << endl;
    ui16 foo2 = 0xff;
    while ( foo2 != 0xb0  && foo2 !=0 &&  fileError != EOF) 
    {
      ui16 foo = getData(1);
      while ( foo != 0xa1 )
      {
        foo = getData(1);
        FILE_LOG(logDEBUG) << "-- Wait foo 0xa1[" << hex << foo << "]" << endl;
      }
      foo2 = getData(1);
      FILE_LOG(logDEBUG) << "-- Wait foo 0xb0[" << hex << foo << "]" << endl;

    }
  } 

    return true;
} // MicrorocMergeReader.getScData

---