ana_raw.cxx File Reference

#include "IRawFile/RawFileExceptions.h"
#include "RawDataCnv/EventManagement/RawEventDef.h"
#include "RawFile/RawFileReader.h"
#include <iomanip>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>

Go to the source code of this file.

Functions
unsigned long	calEts (const uint32_t *dptr)
void	dump (const uint32_t *data, uint32_t n)
void	processETS (const uint32_t *dataPtr, uint32_t dataLen)
int	main (int argc, char *argv[])

Function Documentation

calEts()

unsigned long calEts

(

const uint32_t *

dptr

)

Definition at line 9 of file ana_raw.cxx.

                                             {
  unsigned int  tmp = dptr[0] & 0xffffff;
  unsigned long val = ( tmp >> 16 ) * 61 * 61;
  val += ( ( tmp >> 8 ) & 0xff ) * 61;
  val += tmp & 0xff;
  val *= 2000000; // s -> 500ns
  val += ( dptr[1] & 0x3fffff );
 
  return val;
}

Referenced by processETS().

dump()

void dump	(	const uint32_t *	data,
		uint32_t	n )

Definition at line 20 of file ana_raw.cxx.

                                              {
  std::cout << std::hex;
  for ( uint32_t i = 0; i < n; ++i )
  {
    if ( i % 8 != 0 ) { std::cout << " "; }
    else
    {
      if ( i != 0 ) std::cout << std::endl;
    }
    std::cout << "0x" << std::setw( 8 ) << std::setfill( '0' ) << data[i];
  }
  std::cout << std::dec << std::endl;
}

Referenced by processETS().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 56 of file ana_raw.cxx.

                                   {
  if ( argc != 3 )
  {
    std::cout << "Usage: " << argv[0] << " file.data nevts" << std::endl;
    exit( 1 );
  }
 
  const uint32_t** m_sds  = new const uint32_t*[64];
  const uint32_t** m_robs = new const uint32_t*[256];
 
  int nevts = atoi( argv[2] );
 
  RawFileReader freader( argv[1] );
 
  for ( int i = 0; i < nevts; ++i )
  {
    try
    {
      uint32_t* dataptr = NULL;
 
      RawEvent f;
      f.assign( freader.nextEvent() );
 
      // if ( i < 43649 ) continue;
      // if ( i > 43809 ) break;
      std::cout << i << "  >> run: " << f.run_no() << "  event: " << f.global_id()
                << std::endl;
 
      int nrobs = 0;
      int nsds  = f.children( m_sds, 64 );
      for ( int sdi = 0; sdi < nsds; ++sdi )
      {
        eformat::SubDetectorFragment<const uint32_t*> sd( m_sds[sdi] );
        nrobs += eformat::get_robs( m_sds[sdi], m_robs + nrobs, 256 - nrobs );
      }
      for ( int robi = 0; robi < nrobs; robi++ )
      {
        eformat::ROBFragment<uint32_t*> rob( (uint32_t*)m_robs[robi] );
        uint32_t                        source_id_number = rob.rod_source_id();
        source_id_number <<= 8;
        source_id_number >>= 24;
 
        /// >>>>>>>>>>>>>>>>>>>
        if ( ( rob.rod_detev_type() & 0x2 ) != 0 )
        {
          if ( source_id_number == 165 )
          {
            rob.rod_data( dataptr );
            processETS( dataptr, rob.rod_ndata() );
            break;
          }
        }
      }
 
      if ( !dataptr )
      {
        std::cout << "no ETS data found" << std::endl;
        break;
      }
    } catch ( RawFileException& e )
    {
      e.print();
      break;
    } catch ( std::exception& ex )
    {
      std::cerr << std::endl << "Uncaught std exception: " << ex.what() << std::endl;
      break;
    } catch ( ... )
    {
      std::cerr << std::endl << "Uncaught unknown exception" << std::endl;
      break;
    }
  }
 
  delete[] m_sds;
  delete[] m_robs;
 
  return 0;
}

processETS()

void processETS	(	const uint32_t *	dataPtr,
		uint32_t	dataLen )

Definition at line 34 of file ana_raw.cxx.

                                                             {
  unsigned long t1 = 0, t2 = 0;
 
  if ( dataLen > 11 && dataPtr[1] == 0xffffffff )
  {
    uint32_t start = 10;
    if ( ( dataPtr[start] >> 24 ) == 0xcf )
    {
      t1 = calEts( dataPtr + start );
 
      static unsigned long _t2 = 0;
      if ( ( start + 3 ) < dataLen && ( dataPtr[start + 2] >> 24 ) == 0xd1 )
      { _t2 = calEts( dataPtr + start + 2 ); }
      t2 = _t2;
    }
  }
 
  std::cout << "t1 " << t1 << " t2 " << t2 << std::endl;
 
  dump( dataPtr, dataLen );
}

Referenced by main().