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

Go to the documentation of this file.

/* @version $Revision: 1328 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2011-10-03 17:04:17 +0200 (Mon, 03 Oct 2011) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR DIF Synchro
//
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

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

#include "parser/DifSynchroReader.hh"

#include "event/Event.hh"

#include "geometry/Chamber.hh"
#include "geometry/Dif.hh"
#include "geometry/Hardroc2Chip.hh"
#include "geometry/Detector.hh"

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

#include <iostream>
#include <iomanip>

using namespace std;



/*
Pour les données des SLAB du M2: pas de changement:
- même numéro de format (10)
- numero de version du soft d'acquistion mise a jour (4.0)

Pour les données de la DIF synchro:
- entete raccourci par rapport a l'entete des donnée d'un SLAB
    - data format (10)   = idem fichier SLAB
    - daq version (4)     = idem fichier SLAB
    - daq sous-version (0) = idem fichier SLAB
    - CC firmware version = idem fichier SLAB
    - Slow-control Header (B1) = idem fichier SLAB
    - DIF ID = idem fichier SLAB
    - DIF firmware version = idem fichier SLAB
    - c'est tout pour le slow-control = changement par rapport au fichier SLAB
    - Slow-control Trealer (A1) = idem fichier SLAB
- donnée de la DIF_Synchro mots de 32 bits (compteur)
*/


////////////////////////////////////////////////////////////////////////
DifSynchroReader::DifSynchroReader(Run& aRun, FILE *aFile, ui32 lastEventId) : Hardroc2Reader(aRun, aFile, lastEventId)
{
  FILE_LOG(logDEBUG1) << "--DifSynchroReader constructor()"<< endl;
  scFound = false;
  reset();
}

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

//-------------------------------------------------------------------
// read slow control data
// Les 872 bits du slow control sont inverses dans le fihier de donnee.
//1er  octet lu -> bit 872 871 870 869 868 867 866 865
//2eme octet lu -> bit 864 863 862 861 860 859 858 857

int DifSynchroReader::getScData() {
     unsigned int data;
     display(+1);
     FILE_LOG(logDEBUG) << " Slow Control data header B1 found" << endl;

     ui16 dataFormat = run.getDataFormat();
     bool findA1 = false;
     difId = getData(1);
     display(+1);
     FILE_LOG(logDEBUG) << "--- difId[" << difId << "] config ---" << endl;
 
          Dif& dif = run.getDetector().getDifById(difId);
          dif.setDifFirmware(getData(2));
          display(+1);
          FILE_LOG(logINFO) << "-------- difFirmware[0x" << hex << dif.getDifFirmware() << "]" << endl;

   // Verify A1 Header
        unsigned char *buf = initGetBits(1, false);
    if ( !buf)
    {
        FILE_LOG(logERROR) << "  malloc error while getting SC buffer" << endl;
        exit ( -1);
    }

      int foo = getBits(8);
      finishGetBits();

      FILE_LOG(logDEBUG) << "Hreader[" << hex << foo <<"]" << endl;
      if ( foo != 0xa1)
      {
          FILE_LOG(logERROR) << "  Header A1 not found" << endl;
          exit (-1);
      }
      FILE_LOG(logDEBUG1) << "Header A1 found" << endl;

    return(1);
} // DifSynchroReader.getScData

//-------------------------------------------------------------------
// read acq  data
int DifSynchroReader::getAcqData(Event& event) {

        bool eventFound = false;

        
        while ( ! eventFound  &&  fileError != EOF )
        {
        i32     foo = getData(4);
                FILE_LOG(logDEBUG) << hex << "foo[" << foo << "]"  << endl;

                if ( foo == 0xfffffffa )
                {
                        // Header Run number (  synchromizsed with previous Run ) 
                        i32 runNumber = getData(4); 
                        FILE_LOG(logINFO) << "Run number[" << runNumber << "]"  << endl;
                        foo = getData(4);
                        if ( foo != 0xfffffffb )
                        {
                                FILE_LOG(logERROR) << " Trailer Run numbers  (  synchromizsed with previous Run ) not FOUND !" << endl;
                                exit(-1);
                        }
                        else FILE_LOG(logDEBUG) << " Trailer Run numbers[0x" << hex << foo <<"]" << endl;
                }
                else if ( foo == 0xfffffff0 )
                {
                        // Header Run number (  DEsynchromizsed with previous Run ) 
                        i32 runNumber = getData(4); 
                        FILE_LOG(logINFO) << "Run number[" << runNumber << "]"  << endl;
                        foo = getData(4);
                        if ( foo != 0xfffffff1 )
                        {
                                FILE_LOG(logERROR) << " Trailer Run numbers  (  DEsynchromizsed with previous Run ) not FOUND !" << endl;
                                exit(-1);
                        }
                        else FILE_LOG(logDEBUG) << hex << " Trailer Run numbers[0x" << foo <<"]" << endl;
                }
        
                else if ( foo == 0xffffffff )
                {
                        FILE_LOG(logINFO) << "COMMAND MODE : end of data buffer flags"  << endl;
                        // end of data buffer flags
                }
        
                else  // it 's an event 
                {
                        event.setDifSyncrho(foo);
                        FILE_LOG(logDEBUG) << "Dif Synchro[0x"<<  hex <<  foo << " ]"  << endl;
                        event.setId(++lastEventId);
                        eventFound = true;
                }
        }
        return 0;
/*
unsigned int nbHits = 0;
    i32 foo = getData(4);
  
 
        FILE_LOG(logINFO)  << hex<< "foo [" << foo << "]"  << endl;
        if ( foo == 0xfffffffa )
        {
                // Header Run number (  synchromizsed with previous Run ) 
                i32 runNumber = getData(4); 
                FILE_LOG(logINFO) << "Run number[" << runNumber << "]"  << endl;
                foo = getData(4);
                if ( foo == 0xfffffffb )
                {
                        // Trailer Run numbers  (  synchromizsed with previous Run )
                        foo = getData(4);
                }
                else
                {
                        FILE_LOG(logERROR) << " Trailer Run numbers  (  synchromizsed with previous Run ) not FOUND !" << endl;
                        exit(-1);
                }
        }
        else if ( foo == 0xfffffff0 )
        {
                // Header Run number (  DEsynchromizsed with previous Run ) 
                i32 runNumber = getData(4); 
                FILE_LOG(logINFO) << "Run number[" << runNumber << "]"  << endl;
                foo = getData(4);
                if ( foo == 0xfffffff1 )
                {
                        // Trailer Run numbers  (  DEsynchromizsed with previous Run )
                        exit(-1);
                }
                else
                {
                        FILE_LOG(logERROR) << " Trailer Run numbers  (  DEsynchromizsed with previous Run ) not FOUND !" << endl;
                        exit(-1);
                }
        }

        else if ( foo == 0xffffffff )
        {
                FILE_LOG(logINFO) << "COMMAND MODE : end of data buffer flags"  << endl;
                foo = getData(4);
                // end of data buffer flags
        }

        event.setDifSyncrho(foo);
        FILE_LOG(logINFO) << "Dif Synchro[0x"<<  hex <<  foo << " ]"  << endl;
        event.setId(++lastEventId);
        return 32;

*/
} // DifSynchroReader.getAcqData

//-------------------------------------------------------------------
// LOOP over the data Files, returns after each event
//      called for every dif found in the data file.
int DifSynchroReader::getNextEvent(Event& event) {
  // Start data reconstruction
  Level(0);

        ui16 dataFormat = run.getDataFormat();

  if (dataFormat == 0) {
    // first read of the file
    bcIdDifAbsOrgMap.clear();
    // read file header
    dataFormat = getData(1);
    if ( dataFormat == 0x10  ) { dataFormat = 0xa; }
                run.setDataFormat(dataFormat);


    if (fileError == EOF) {
      FILE_LOG(logERROR) << "parsing file[" << inputFile << "]  - error " << errno << ":" << strerror(errno) << endl;
      reset();
      return(LAST_FILE_EVENT);
    }
    display(+1);
    FILE_LOG(logINFO) << "  DIF SYNCHRO LABVIEW DATA FORMAT  : " << dataFormat << endl;

    if (dataFormat != 7 && dataFormat != 1 && dataFormat != 10) {
      // unknown format
      FILE_LOG(logERROR) << " DIF SYNCHRO LABVIEW data format  " << dataFormat << " is not implemented" << endl;
      reset();
      return(LAST_FILE_EVENT);
    }

        if ( dataFormat == 10)
        {
                run.setDaqSoftware( getData(1));
                display(+1);
                FILE_LOG(logINFO) << "  DAQ software version  : " << run.getDaqSoftware() << endl;

                run.setCccFirmware(getData(1));
                display(+1);
        FILE_LOG(logINFO) << "  ccc firware  : " << run.getCccFirmware() << endl;

                globalTime = getData(4)    ; // labview time is second since 1 janv 1970 and globalTime milli second
        FILE_LOG(logDEBUG1) << "globalTime in second:[" << globalTime << "]" <<  endl;
        globalTime *= 1000;
        FILE_LOG(logDEBUG1) << "globalTime in millisecond:[" << globalTime << "]" <<  endl;
        FILE_LOG(logDEBUG) << "  Global timestamp(hex) [" << hex << globalTime << "]" << endl;

        }


   if (fileError == EOF) 
   {
     FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
     reset();
     return(LAST_FILE_EVENT);
   }
   FILE_LOG(logDEBUG) << run.getDetector() << endl;
   display(-1);
   return NEW_CONFIG;
  }


  if ( !scFound ) // slow control has nott been readed yet
  {

    // look for a global data header and process corresponding data
    unsigned int globalHeader = getData(1);
    if (fileError == EOF) 
    {
        FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
        reset();
        return(LAST_FILE_EVENT);
    }
    FILE_LOG(logDEBUG) << "globalHeader:["<< hex  << globalHeader << "]" << endl;
    if (globalHeader == 0xB1) 
    {
      // slow control data
      getScData();
          scFound = true;
        }
  }

  if (fileError == EOF) 
  {
      FILE_LOG(logINFO) << "  END OF DATA FILE" << endl;
      reset();
      return(LAST_FILE_EVENT);
  }

  getAcqData(event);

  if ( fileError == EOF)
  {
       FILE_LOG(logINFO) << "  END OF DATA FILE" << endl;
       reset();
       return(LAST_FILE_EVENT);
  }

  return EVENT_CORRECT;
}

---