ana_raw.cxx File Reference

#include "RawDataCnv/EventManagement/RawEvent.h"
#include "RawFile/RawFileReader.h"
#include "IRawFile/RawFileExceptions.h"
#include <iostream>
#include <iomanip>
#include <unistd.h>
#include <stdlib.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 21 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 59 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 37 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().