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

Go to the documentation of this file.

/* @version $Revision: 1952 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-11-20 15:34:41 +0100 (Tue, 20 Nov 2012) $ */

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

#include <unistd.h>

#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,bool _forceAnalog, set<unsigned int>*_difList) : MicrorocMergeReader(aRun, NULL, lastEventId,_forceAnalog,_difList), firstEvent(true)

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

  lcReader = LCFactory::getInstance()->createLCReader() ;
  try {
    lcReader->open(aFileFullPath);
  }
  catch( IOException& e) {
    cout << e.what() << endl ;
    exit(-1) ;
  }
  
  if ( lcReader == NULL ) { exit(-1); }


  localReset();

}

//--------------- Destructeur -------------//
MicrorocXDaqReader::~MicrorocXDaqReader()
{
  lcReader->close();
  delete lcReader;
  FILE_LOG(logDEBUG1)<< "----MicrorocXDaqReader destructor"<< endl;
}
                                                                                                             
//--------------- reset -------------//
void MicrorocXDaqReader::localReset()
{
  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 = 12;
    run.setDataFormat(dataFormat);
    
    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 = (i64) ( lcioEvt->getTimeStamp()*1000 );

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

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


      // Set dif Asu1Id and Asu2Id from XML as there is no available information in SlowControl 
        Detector &det = run.getDetector();
        const ChamberMap_t& chambers= det.getChambers();
        for (ChamberMap_t::const_iterator chamberIt = chambers.begin(); chamberIt != chambers.end(); ++chamberIt)
        {
          Chamber& chamber = *(chamberIt->second);
          const DifMap_t& difs = chamber.getDifs();
          for (DifMap_t::const_iterator difIt = difs.begin(); difIt != difs.end(); ++difIt)
          {
            Dif& dif = *(difIt->second);
            ui16 asuIndex = 1; 
            const BoardMap_t& boards = dif.getBoards();
            for (BoardMap_t::const_iterator boardIt = boards.begin(); boardIt != boards.end(); ++boardIt)
            {
              Board& board = *(boardIt->second);
              if ( asuIndex == 1 ) 
              {
                 dif.setAsu1Id(board.getId());
                 asuIndex++; 
                 FILE_LOG(logDEBUG) << "Set difid[" << dif.getId() << "] Asu1Id to[" << dif.getAsu1Id() << "]"  << endl;
              } 
              else if ( asuIndex == 2 ) 
              {
                 dif.setAsu2Id(board.getId()); 
                 FILE_LOG(logDEBUG) << "Set difid[" << dif.getId() << "] Asu2Id to[" << dif.getAsu2Id() << "]"  << endl;
              } 
            }
          }
        }

      }

    }
    if ( firstEvent  )
    {
      FILE_LOG(logINFO) << "firstEvent  skip"  << endl;
      firstEvent = false;
      // skip first event because of its corruption ???
    }
    else if (  skipNbEvent != 0 && debugEventId < skipNbEvent)
    {
      debugEventId++;
      FILE_LOG(logINFO) << "skip event " << debugEventId << "\r"  << flush;
    }
    else if (  skipNbEvent == debugEventId )
    {
      FILE_LOG(logINFO) << skipNbEvent << " event(s) have been skipped" << debugEventId << endl;
      debugEventId++;
    }    

    else
    {
      // vnames to store lcioEvt collections name
      std::vector<std::string >* vnames;
      try
      {
        vnames= (std::vector<std::string >*)lcioEvt->getCollectionNames();
        for ( vector<std::string >::iterator it = vnames->begin();  it!= vnames->end(); it++)
        {
          if ((*it).compare("RU_XDAQ")==0)
          {
            EVENT::LCCollection* col= lcioEvt->getCollection(*it);

            for (int difRawDataIndex=0;difRawDataIndex<col->getNumberOfElements(); difRawDataIndex++)
            {
              IMPL::LCGenericObjectImpl* go= (IMPL::LCGenericObjectImpl*) col->getElementAt(difRawDataIndex);
              int rusize =go->getNInt();
              if ( rusize == 56 ) continue; // skip first RU_XDAQ si tsille est 56 int

              int shift=-1;
              ui16 nbInt = go->getNInt();

              
              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));
               // sleep(1);
              }
              //cout << endl;
              
              itRawdata = rawdataList.begin();

              MicrorocMergeReader::decodeData(event);

            } // end for data for dif
            eventFound = true ;
            //event.setId(++lastEventId);
          } // ed if collection = XU_XDAQ
        } // 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

 if ( event.getChannelHitSize() > 0 )
  {
    event.setId(++lastEventId);
    return EVENT_CORRECT;
  }
  else
  {
    return EVENT_ERROR;
  }





return 0;
}

//------------------------------------------//
unsigned int MicrorocXDaqReader::getSpecificData(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 ) 
    {
     // if  ( data != 0xc4 && data != 0xd4 )
      {
        crc->compute(data) ;
      }
    }
    result = (result << 8) + data;
  }

putData(result, nBytes);

return result;
}

---