/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/CalibHR2Parser.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) $ */

#include "parser/CalibHR2Parser.hh"
#include "parser/AcquisitionParser.hh"

#include "event/Event.hh"

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

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

#include <cstdio>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include "math.h"

using namespace std;



#define bigTolittle Toolbox::bigTolittle

using namespace std;



//-----------------------------------------
//-------------------------------------------------------------------
/* Convert given binary into gray code */
/* 1101011001 (binary) -> 1011110101 (gray) */
/* all codes gives the same result */
static unsigned int grayToBinary2(unsigned int gray) {
  // loop for always 32 bits
  unsigned int bin = ((gray >> 31) & 1) << 31;
  for (int bit = 30; bit >= 0; --bit)
    bin += ( ((gray >> bit) & 1) ^ ((bin >> (bit + 1)) & 1) ) << bit;

  return(bin);
} // grayToBinar



CalibHR2Parser::CalibHR2Parser(Run& aRun, FILE *aFile, ui32 _firstEventId)
: AcquisitionParser(aRun, aFile,  _firstEventId)
{
  FILE_LOG(logDEBUG1) << "--CalibHR2Parser constructor()"<< endl;

  run.setCalibrationRun(true);

  reset();
}

//--------------- Destructeur -------------//
CalibHR2Parser::~CalibHR2Parser()
{
  FILE_LOG(logDEBUG1)<< "----CalibHR2Parser destructeur"<< endl;
}

//-------------------------------------------------------------------
void CalibHR2Parser::reset()
{
init = false;
newCalibration = true;
newDif = true;
newHR = true;
difId = -1;
dac[0] = -1;
dac[1] = -1;
dac[2] = -1;
difId = -1;



}
//-------------------------------------------------------------------
void  CalibHR2Parser::setMotifValue(string line)
{
    ui64 result = 0;
    string mot;
    int equalpos = 0;

    equalpos = line.find('=') ;
    if ( equalpos != string::npos )
    {
        mot = line.substr(equalpos + 2, line.size());  // + 2 because of the space caractere behind equal

        // Now  convert string reprensenting 32 bit binary to int

        for(int i=MOTIFNB-1; i>=0 ;  --i)
        {

            motif[i] = false;
            if ( mot[i] == '1')
            {
                motif[i] = true;
            }
        }
    }

}



//-------------------------------------------------------------------
int  CalibHR2Parser::getDacValue(string line)
{
    int result = -1;
    string value;
    int equalpos = 0;

    equalpos = line.find('=') ;
    if ( equalpos != string::npos )
    {
        value = line.substr(equalpos + 2, line.size());  // + 2 because of the space caractere behind equal
        result = atoi(value.c_str());
    }

    return result;

}

//-------------------------------------------------------------------
void  CalibHR2Parser::initParsing(FILE* inputFile)
{

    string line;
    size_t found;


    do
    {
       if ( getLine ( inputFile, line) == EOF ) { return ;}
       found = line.find("Chips en calibration" );

       line.clear();
    }
    while  (found==string::npos);

    // get motifCTest
    if ( getLine ( inputFile, line) == EOF ) { return ;}
    found = line.find("motif Ctest" );
    if  (found!=string::npos)
    {
      setMotifValue(line);
    }
}

//-------------------------------------------------------------------
bool  CalibHR2Parser::checkNextLine(FILE* inputFile, string target )
{
    size_t found;
    string line;

    int curPos = ftell(inputFile);

    if ( getLine ( inputFile, line) == EOF ) { return false ;}
//    FILE_LOG(logINFO) <<  "read line[" << line << endl;
    fseek(inputFile,curPos,SEEK_SET);
    found = line.find(target );
    if  (found!=string::npos)
    {
        return true;
    }
    return false;

}
//-------------------------------------------------------------------

int  CalibHR2Parser::getNextEvent(Event& event)
{
    unsigned int nbHits = 0;
    // The first line does not contains needed informations
    // init fill the motifCtest and place streaming just before the first event
    if ( ! init)
    {
        initParsing(inputFile);
        init = true;
    }

    string line;

    if ( newCalibration)
    { // get calibration parameters ( DAC_2, DAC_1, D AC_0 values )
        FILE_LOG(logDEBUG1) <<  "New calibration !" << endl;
        size_t found;

        do
        {
            int result = getLine ( inputFile, line);
             if (result == EOF)
             {
                 FILE_LOG(logDEBUG1) <<  "End of file !" << endl;
                 reset();
                 FILE_LOG(logDEBUG1) <<  "return LAST_FILE_EVENT:["  << LAST_FILE_EVENT <<  endl;
                 return LAST_FILE_EVENT;
             }

             // Get DAC_2
             found=line.find("DAC_2");
        }
        while (found==string::npos);

        dac[0] = -1;
        dac[1] = -1;
        dac[2] = getDacValue(line);

        // Get DAC_1
        if ( getLine ( inputFile, line) != EOF )
        {
            if ( line.find("DAC_1")!=string::npos) { dac[1] = getDacValue(line); }
            else { return EVENT_ERROR;  }  // DAC_1 value not found
        }

        // Get DAC_0
        if ( getLine ( inputFile, line) != EOF )
        {
            if ( line.find("DAC_0")!=string::npos) { dac[0] = getDacValue(line); }
            else { return EVENT_ERROR;  }  // DAC_0 value not found
        }
        FILE_LOG(logINFO) <<  "dac_2[" << dac[2] << "]" << endl;
        FILE_LOG(logINFO) <<  "dac_1[" << dac[1] << "]" << endl;
        FILE_LOG(logINFO) <<  "dac_0[" << dac[0] << "]" << endl;

        // Set chip configuration
        run.setName("turlututu");
        const Detector &detector = run.getDetector();
        try {
          ChamberMap_t chambers = detector.getChambers();
          for (ChamberMap_t::iterator chamberIt = chambers.begin(); chamberIt != chambers.end(); chamberIt++) {
            Chamber& chamber = *chamberIt->second;
            DifMap_t difs = chamber.getDifs();
            for (DifMap_t::iterator difIt = difs.begin(); difIt != difs.end(); difIt++) {
              Dif& dif = *difIt->second;
              BoardMap_t boards = dif.getBoards();
              for (BoardMap_t::iterator boardIt = boards.begin(); boardIt != boards.end(); boardIt++) {
                Board& b = *boardIt->second;
                ChipMap_t chips = b.getChips();
                for (ChipMap_t::iterator chipIt = chips.begin(); chipIt != chips.end(); chipIt++) {
                  Hardroc2Chip &chip = dynamic_cast<Hardroc2Chip &> (*chipIt->second);
                  chip.setThresholdDac_0(dac[0]);
                  chip.setThresholdDac_1(dac[1]);
                  chip.setThresholdDac_2(dac[2]);
                  for (int chNum = 0; chNum < 64; chNum++) {
                    Channel& ch = chip.getChannelById(chNum);
                    ch.setEnable(1);
                  }
                }
              }
            }
          }
        }
        catch (MicroException &e) { cout << e.getMessage() << endl; }

        newCalibration = false; // nany event could be attach to these calibration parametre ( DAC_2 ... )
        return NEW_CONFIG;
     } // end if new calibratio
   if ( newDif)
   {
          FILE_LOG(logDEBUG1) <<  "New Dif !" << endl;
        // Place file streamer after B4
        int space = 0;  // nb bytes beetween B4 and B0 tags
        int b0Pos = 6;  // B0 tag position
        bool find = false;
        do
        {
           b0Pos = ftell(inputFile);
           if (getLine ( inputFile, line) == EOF) {
             return(LAST_FILE_EVENT);
           }
//           FILE_LOG(logINFO) << "line[" << line << "]" << endl;
           // On verifie que l'on ne retombe pas sur le mot DAC_2, ce qui ce produit si aucune Dif n'a repondu ( du a un BUG )
           if (checkNextLine(inputFile,"DAC_") )
           {
               newCalibration = true;
               FILE_LOG(logWARNING) <<  "No data for DAC values:[" << dac[0] << "," << dac[1] << "," << dac[2] << "]" << endl;
               return getNextEvent( event);
           }

           int b0find = line.find("B0",18);
           int b4pos = 0;
           do
           {
               b4pos = line.find("B4",b4pos+1);

               if ( b4pos - b0find == 46 )
               {
                   find = true;
               }
           }
           while  (b4pos != string::npos && find == false );

        }
        while ( !find );

        b0Pos = b0Pos + 18 + 2 ;  // position du B0
        fseek(inputFile, b0Pos, SEEK_SET);

        // File after position "B0"
        // Here we are sure to be at the correct position in the file to start

       // New DIF
       difId = getData(inputFile, 1);
       FILE_LOG(logDEBUG1) << "  difId[" << difId << "]" <<  endl;

       fseek(inputFile, 42, SEEK_CUR);
       // Fichier avant la position "B4"
       // New B4 Tag

       int dataHeader = getData(inputFile, 1);
       FILE_LOG(logDEBUG1) << (hex) << "  dataHeader[" << dataHeader << "]" <<  endl;
       if (dataHeader == 0xB4)
       {
           FILE_LOG(logDEBUG1) << "  data header B4 found" << endl;
       }
       else
       {
           FILE_LOG(logERROR) << "  parsing file error. data header error : " << hex << dataHeader << dec << endl;
           return EVENT_ERROR;
       }

       newDif = false;


    }
    if ( newHR)
    {
          FILE_LOG(logDEBUG1) <<  "New HR !" << endl;
       // VERIF TAG A3 pas de skip. Dans le cas ou aucun des chips ne repond
          if ( checkData(inputFile, 1) == 0xA3)
          {
             FILE_LOG(logERROR) <<  "ERROR TAG A3 just after newHR for DAC values:[" << dac[0] << "," << dac[1] << "," << dac[2] << "]" << endl;
             return EVENT_ERROR;
          }
       // On skip les insultes du hardroc
       //fseek ( inputFile, 40, SEEK_CUR);
       newHR = false;
    }


    // On Verifie en hexadecimal que l'on a pas de tag A0
    // Pour une Dif, lit ChipId + BCId + donnee
    // get Chip Id. Warning ! Decimal

    int chipId = -1;
    // On doit lire 2 fois car le tag A3 est en Hexedecimal alors que le chipId est en decimal
    int foo = getData(inputFile , 1);
    if ( foo == 0xA3)
    { // Fin de donnees chip(HR)
        FILE_LOG(logDEBUG1) << " -------- TAG A3 " <<  endl;
        newHR = true;
        foo = getData(inputFile , 1);
        if ( foo == 0xA0 )
        {
            newDif = true;
            FILE_LOG(logDEBUG1) << " -------- Tag A0 derriere A3 " <<  endl;
            foo = getData(inputFile , 2 ); // READ CRC
                        try {
               foo = getData(inputFile, 1 );
                        }
            catch ( MicroException &e) 
                        {
                foo = 0;
            }
            if ( foo != 0xB0)
            {
// On verifie si apres la ligne separatrice  "-----------------"c'est une nouvelle acquisition on des nouvelles valeur de DAC
                if (  getLine ( inputFile, line) == EOF ) { return LAST_FILE_EVENT ;}  // ligne separatrice ---------------
                if (checkNextLine(inputFile,"acquisition") )
                {
                   newDif = true;
                }
                else 
                {


                    newCalibration = true;
                    FILE_LOG(logDEBUG1) << " -------- Pas de B0 derrire le CRC donc newCalibration = true " <<  endl;
                                }
            }
            else {
                FILE_LOG(logDEBUG1) << " -------- B0 derrire le CRC donc Dif  " <<  endl;
            }

        }
        return getNextEvent( event);
    }
    else
    { // Pas Fin de donnees chip(HR)
      fseek ( inputFile, -2, SEEK_CUR);
      chipId = getData(inputFile, 1);


    // get bcid
    int bcId = getData(inputFile, 3);
    FILE_LOG(logDEBUG1) << (hex) << "  bcid[" << bcId << "]" <<  endl;


    // the following data is repeated one time for each Dif which has sent data

    bool difFound = false;
    Detector& detector = run.getDetector();
    { 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 << endl;
        return EVENT_ERROR;
      }
    }

   // trigger data for 64 channels : 1 bit trigger1, 1 bit trigger0 for each channel from 63 downto 0.
        // this makes 2-bit values which should not give bit 1 without bit 0

        int canal[16]={0};
        for (int chNum = 48; chNum >= 0; chNum -= 16) {
                unsigned int data4;
          try {
              data4 = getData(inputFile, 4); // on lit 4 Bytes => 8 cara => 16 cannaux
          }
          catch ( MicroException &e) 
          {
              continue;
          }


          int index = 0;
          for ( index = 0; index <= 15 ; index++)
          {
             // sur les 16 canaux, on recupere les donnees canal par canal
             canal[index] = (data4 >> ((15 - index )* 2 )) & 0x03; // 2 Most Significant Bits of the digi

             if ( motif[index+chNum])
             {
                if ( newHit(event, detector, canal[index], index + chNum    , chipId, difId) != 1 )
                                {
// Format de donées non valid, on cherche une balise A3 pour tenter de recuperer les prochain evemements
                  try 
                  {
                        foo =  getData(inputFile, 1) ;
                        while (  foo != 0xA3 )
                                            {
    
                          foo =  getData(inputFile, 1) ;
                                            }
                    }
                                        catch ( MicroException &e) 
                    {
                        FILE_LOG(logINFO) << "End of line 0xA3 not Found !!!" << endl; 
                                                newDif = true;
//                    event.setId(++lastEventId);
                    //FILE_LOG(logDEBUG1) << "  STORE EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
                    //return EVENT_CORRECT;


                    }
                                        
                                }
                                else 
                                {//, dac);
                        nbHits++;
                                }
             }
          }
      }

      event.setId(++lastEventId);
      FILE_LOG(logDEBUG1) << "  STORE EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
      return EVENT_CORRECT;
    }

}


//-------------------------------------------------------------------
int CalibHR2Parser::getLine ( FILE*file, string &line )
{
    line.clear();
    int result = fgetc(file ) ;
    while ( result != EOF )
    {
        line += result;
        if ( result == '\n' )
        {
            line.resize (line.size()-1);
            return 0;
        }
        result = fgetc(file ) ;
    }
    return EOF;
}


//---------------------------------------------------------------------
unsigned int CalibHR2Parser::checkData(FILE* inputFile, const int nBytes) {

    int curPos = ftell(inputFile);
    unsigned int result = getData(inputFile, nBytes);
    fseek(inputFile,curPos,SEEK_SET);
    return result;
}


//---------------------------------------------------------------------
unsigned int CalibHR2Parser::getData(FILE* inputFile, const int nBytes) {
  unsigned int result = 0;
  for (int byte = 0; byte < nBytes; ++byte) {
    int data = 0;
    if (fscanf(inputFile, "%2x", &data) != 1) {
            throw MicroException("get data: fcanf error");

//      return(0);
    }
    result = (result << 8) + data;
  }
  return(result);
} 



//---------------------------------------------------------------------
unsigned int CalibHR2Parser::getDecimalData(FILE* inputFile, const int nBytes) {
  unsigned int result = 0;
  for (int byte = 0; byte < nBytes; ++byte) {
    int data = 0;
    if (fscanf(inputFile, "%2d", &data) != 1) {
      return(0);
    }
    result = (result << 8) + data;
  }
  return(result);
} 


//-----------------------------
//-------------------------------------------------------------------
int CalibHR2Parser::newHit(Event& event, const Detector &detector, int data, const int chNum, const int chipId, const int difId)//, int* dac)
{
  // cannot be binary pattern 10
//  if (data == 0x2) {
    //FILE_LOG(logERROR) << "      CHANNEL DATA = 0x02" << endl;
//    return(0);
 // }

  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);
      // look for type of chamber
      //if (chamber.getType() != HARDROC1CHAMBER)
      //  continue;
      // store new event data
      try {
        const Channel& channel = chamber.getChannelById(chNum, chipId, difId);
        i16 analogValue = 0;
        //ChannelHit *hit = new ChannelHit(channel, data, analogValue, dac);
        ChannelHit *hit = new ChannelHit(channel, data, analogValue);
//        hit->setHardrocTime(globalTime, bcId_Abs, bcId_Dif, bcId_Hit);
        event.insertHit(chamber, hit);
        FILE_LOG(logDEBUG1) << "      new Hit : ch " << chNum << ", chip " << chipId << ", dif " << difId
                           << " Data=" << data << " , x:" << channel.getX() << ", y:" << channel.getY() << endl;
        return(1);
      }
      catch (MicroException &e) {
        FILE_LOG(logERROR) << "ch " << chNum << ", chip " << chipId << ", dif " << difId << " : " << e.getMessage() << endl;
        return(0);
      }
    }
    catch (...) {
      continue;
    }

  } // for
  return(0);
} 


//-------------------------------------------


string CalibHR2Parser::binaire(unsigned int nombre)
{
string res = "";
unsigned int val = nombre;

while (val != 0) {
/* Invariant de boucle : code_binaire(val) + res = code_binaire(nombre) */

   if (val & 1 == 1) {
res = string("1") + res;
}
    else {
/* val & 1 == 0 */
res = string("0") + res;
}

val = val >> 1;
}
return res;
}

---