488 lines
13 KiB
C++
488 lines
13 KiB
C++
#ifndef EVTREADER_H
|
|
#define EVTREADER_H
|
|
|
|
#include <stdio.h> /// for FILE
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "TString.h"
|
|
#include "TBenchmark.h"
|
|
|
|
#include "../armory/DataBlock.h"
|
|
|
|
#define MAX_CRATES 2
|
|
#define MAX_BOARDS_PER_CRATE 13
|
|
#define MAX_CHANNELS_PER_BOARD 16
|
|
#define BOARD_START 2
|
|
|
|
|
|
class timePos{
|
|
public:
|
|
timePos(ULong64_t time, unsigned long int inFilePos){
|
|
this->time = time;
|
|
this->inFilePos = inFilePos;
|
|
}
|
|
|
|
ULong64_t time;
|
|
unsigned long int inFilePos;
|
|
|
|
void Print(){
|
|
printf("time: %16llu, filePos: %lu\n", time, inFilePos);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
class evtReader{
|
|
|
|
public:
|
|
DataBlock * data;
|
|
|
|
private:
|
|
FILE * inFile;
|
|
|
|
long int inFileSize;
|
|
long int inFilePos0;
|
|
long int inFilePos;
|
|
bool endOfFile;
|
|
bool isOpened;
|
|
Long64_t blockID;
|
|
long int nBlock;
|
|
|
|
unsigned int extraHeader[14];
|
|
unsigned int traceBlock[MAX_TRACE_LENGHT/2];
|
|
|
|
TBenchmark gClock;
|
|
|
|
long int inFilePosPrecent[10];
|
|
Long64_t blockIDPrecent[10];
|
|
|
|
///============================================ Methods
|
|
public:
|
|
|
|
evtReader();
|
|
evtReader(TString inFileName);
|
|
~evtReader();
|
|
|
|
void OpenFile(TString inFileName);
|
|
void CloseFile();
|
|
|
|
void UpdateFileSize();
|
|
bool IsEndOfFile();
|
|
|
|
bool IsOpen() {return isOpened;}
|
|
long int GetFilePos() {return inFilePos;}
|
|
long int GetFileSize() {return inFileSize;}
|
|
Long64_t GetBlockID() {return blockID;}
|
|
Long64_t GetNumberOfBlock() {return nBlock;}
|
|
|
|
|
|
int ReadBlock(int opt = 0); /// 0 = default, fill data
|
|
/// 1 = no fill data
|
|
|
|
int ReadBlockAtPos(unsigned long int filePos);
|
|
|
|
void ScanNumberOfBlock();
|
|
void JumptoPrecent(int precent); ///this is offset by 1 block
|
|
void PrintStatus(int mod);
|
|
|
|
|
|
std::vector<timePos> timePosList;
|
|
unsigned long int filePosK;
|
|
std::vector<timePos> ReadBatchPos(long batchSize, bool verbose = false);
|
|
void SortTimePos();
|
|
|
|
};
|
|
|
|
|
|
//========================== implementation
|
|
|
|
evtReader::evtReader(){
|
|
inFile = 0;
|
|
data = new DataBlock();
|
|
|
|
inFileSize = 0;
|
|
inFilePos = 0;
|
|
inFilePos0 = 0;
|
|
filePosK = 0;
|
|
|
|
nBlock = 0;
|
|
blockID = -1;
|
|
endOfFile = false;
|
|
isOpened = false;
|
|
|
|
}
|
|
|
|
|
|
evtReader::~evtReader(){
|
|
fclose(inFile); //already delete inFile
|
|
delete data;
|
|
}
|
|
|
|
|
|
evtReader::evtReader(TString inFileName){
|
|
inFile = 0;
|
|
data = new DataBlock();
|
|
|
|
inFileSize = 0;
|
|
inFilePos = 0;
|
|
inFilePos0 = 0;
|
|
filePosK = 0;
|
|
|
|
nBlock = 0;
|
|
blockID = -1;
|
|
endOfFile = false;
|
|
isOpened = false;
|
|
|
|
OpenFile(inFileName);
|
|
}
|
|
|
|
void evtReader::OpenFile(TString inFileName){
|
|
inFile = fopen(inFileName, "r");
|
|
if( inFile == NULL ){
|
|
printf("Cannot read file : %s \n", inFileName.Data());
|
|
}else{
|
|
fseek(inFile, 0L, SEEK_END);
|
|
inFileSize = ftell(inFile);
|
|
rewind(inFile); ///back to the File begining
|
|
|
|
data->Clear();
|
|
|
|
gClock.Reset();
|
|
gClock.Start("timer");
|
|
|
|
isOpened = true;
|
|
}
|
|
};
|
|
|
|
void evtReader::CloseFile(){
|
|
fclose(inFile);
|
|
isOpened = false;
|
|
data->Clear();
|
|
inFileSize = 0;
|
|
inFilePos = 0;
|
|
nBlock = 0;
|
|
blockID = -1;
|
|
endOfFile = false;
|
|
};
|
|
|
|
void evtReader::UpdateFileSize(){
|
|
if( inFile == NULL ) return;
|
|
fseek(inFile, 0L, SEEK_END);
|
|
inFileSize = ftell(inFile);
|
|
fseek(inFile, inFilePos, SEEK_SET);
|
|
}
|
|
|
|
bool evtReader::IsEndOfFile() {
|
|
int haha = feof(inFile);
|
|
return haha > 0 ? true: false;
|
|
}
|
|
|
|
int evtReader::ReadBlockAtPos(unsigned long int filePos){
|
|
|
|
fseek( inFile, filePos, SEEK_SET);
|
|
|
|
return ReadBlock(0);
|
|
|
|
}
|
|
|
|
int evtReader::ReadBlock(int opt){
|
|
|
|
if( feof(inFile) ) return -1;
|
|
if( endOfFile ) return -1;
|
|
|
|
unsigned int header[4]; ///read 4 header, unsigned int = 4 byte = 32 bits.
|
|
|
|
inFilePos0 = inFilePos;
|
|
|
|
if ( fread(header, sizeof(header), 1, inFile) != 1 ) {
|
|
endOfFile = true;
|
|
return -1;
|
|
}
|
|
blockID ++;
|
|
|
|
|
|
if( opt == 0 ){
|
|
/// see the Pixie-16 user manual, Table4-2
|
|
data->eventID = blockID;
|
|
data->ch = header[0] & 0xF ;
|
|
data->slot = (header[0] >> 4) & 0xF;
|
|
data->crate = (header[0] >> 8) & 0xF;
|
|
data->headerLength = (header[0] >> 12) & 0x1F;
|
|
data->eventLength = (header[0] >> 17) & 0x3FFF;
|
|
data->pileup = header[0] >> 31 ;
|
|
data->time = ((ULong64_t)(header[2] & 0xFFFF) << 32) + header[1];
|
|
data->cfd = header[2] >> 16 ;
|
|
data->energy = (header[3] & 0xFFFF );
|
|
data->trace_length = (header[3] >> 16) & 0x7FFF;
|
|
data->trace_out_of_range = header[3] >> 31;
|
|
|
|
data->ClearQDC();
|
|
data->ClearTrace();
|
|
|
|
///======== read QDCsum
|
|
if( data->headerLength >= 4 ){
|
|
fread(extraHeader, sizeof(unsigned int) * (data->headerLength-4), 1, inFile);
|
|
if( data->headerLength == 8 || data->headerLength == 16){
|
|
data->trailing = extraHeader[0];
|
|
data->leading = extraHeader[1];
|
|
data->gap = extraHeader[2];
|
|
data->baseline = extraHeader[3];
|
|
}
|
|
if( data->headerLength == 12 || data->headerLength == 16){
|
|
for( int i = 0; i < 8; i++){
|
|
int startID = 0;
|
|
if( data->headerLength > 12) startID = 4; ///the 1st 4 words
|
|
data->QDCsum[i] = extraHeader[i+startID];
|
|
}
|
|
}
|
|
}else{
|
|
for( int i = 0 ; i < 8; i++){ data->QDCsum[i] = 0;}
|
|
data->trailing = 0;
|
|
data->leading = 0;
|
|
data->gap = 0;
|
|
data->baseline = 0;
|
|
}
|
|
///====== read trace
|
|
if( data->eventLength > data->headerLength ){
|
|
fread(traceBlock, sizeof(unsigned int) * ( data->trace_length / 2 ), 1, inFile);
|
|
|
|
for( int i = 0; i < data->trace_length/2 ; i++){
|
|
data->trace[2*i+0] = traceBlock[i] & 0xFFFF ;
|
|
data->trace[2*i+1] = (traceBlock[i] >> 16 ) & 0xFFFF ;
|
|
}
|
|
|
|
///make QDC by trace
|
|
/**
|
|
if( data->headerLength == 4 || data->headerLength == 8 ) {
|
|
for( int i = 0; i < 8; i++){ data->QDCsum[i] = 0;}
|
|
for( int i = 0; i < data->trace_length; i++){
|
|
if( 0 <= i && i < 31 ) data->QDCsum[0] += data->trace[i];
|
|
if( 31 <= i && i < 60 ) data->QDCsum[1] += data->trace[i];
|
|
if( 60 <= i && i < 75 ) data->QDCsum[2] += data->trace[i];
|
|
if( 75 <= i && i < 95 ) data->QDCsum[3] += data->trace[i];
|
|
if( 95 <= i && i < 105 ) data->QDCsum[4] += data->trace[i];
|
|
if( 105 <= i && i < 160 ) data->QDCsum[5] += data->trace[i];
|
|
if( 160 <= i && i < 175 ) data->QDCsum[6] += data->trace[i];
|
|
if( 175 <= i && i < 200 ) data->QDCsum[7] += data->trace[i];
|
|
}
|
|
}*/
|
|
}
|
|
}
|
|
|
|
if( opt == 1 ){
|
|
|
|
data->headerLength = (header[0] >> 12) & 0x1F;
|
|
data->eventLength = (header[0] >> 17) & 0x3FFF;
|
|
data->trace_length = (header[3] >> 16) & 0x7FFF;
|
|
|
|
if( data->headerLength >= 4 ){
|
|
fread(extraHeader, sizeof(unsigned int) * (data->headerLength-4), 1, inFile);
|
|
}
|
|
if( data->eventLength > data->headerLength ){
|
|
fread(traceBlock, sizeof(unsigned int) * ( data->trace_length / 2 ), 1, inFile);
|
|
}
|
|
}
|
|
|
|
inFilePos = ftell(inFile);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
void evtReader::ScanNumberOfBlock(){
|
|
|
|
nBlock = 0;
|
|
int count = 0;
|
|
while( ReadBlock(1) != -1 ){
|
|
nBlock ++;
|
|
int haha = (inFilePos*10/inFileSize)%10;
|
|
if( haha == count ) {
|
|
inFilePosPrecent[count] = inFilePos;
|
|
blockIDPrecent[count] = blockID;
|
|
count++;
|
|
}
|
|
|
|
PrintStatus(10000);
|
|
}
|
|
|
|
printf("\n\n\n");
|
|
printf("scan complete: number of data Block : %ld\n", nBlock);
|
|
|
|
inFilePos = 0;
|
|
inFilePos0 = 0;
|
|
filePosK = 0;
|
|
blockID = -1;
|
|
|
|
rewind(inFile); ///back to the File begining
|
|
endOfFile = false;
|
|
|
|
}
|
|
|
|
void evtReader::JumptoPrecent(int precent){
|
|
|
|
if( precent < 0 || precent > 10 ) {
|
|
printf("input precent should be 0 to 10\n");
|
|
return;
|
|
}
|
|
|
|
fseek(inFile, inFilePosPrecent[precent], SEEK_SET);
|
|
blockID = blockIDPrecent[precent];
|
|
|
|
}
|
|
|
|
void evtReader::PrintStatus(int mod){
|
|
|
|
///==== event stats, print status every 10000 events
|
|
if ( blockID % mod == 0 ) {
|
|
UpdateFileSize();
|
|
gClock.Stop("timer");
|
|
double time = gClock.GetRealTime("timer");
|
|
gClock.Start("timer");
|
|
printf("Total measurements: \x1B[32m%llu \x1B[0m\nReading Pos: \x1B[32m %.3f/%.3f GB\x1B[0m\nTime used:%3.0f min %5.2f sec\033[A\033[A\r",
|
|
blockID, inFilePos/(1024.*1024.*1024.), inFileSize/1024./1024./1024, TMath::Floor(time/60.), time - TMath::Floor(time/60.)*60.);
|
|
}
|
|
|
|
}
|
|
|
|
void evtReader::SortTimePos(){
|
|
std::sort(timePosList.begin(), timePosList.end(), [](const timePos & a, const timePos & b) { return a.time < b.time; });
|
|
}
|
|
|
|
std::vector<timePos> evtReader::ReadBatchPos(long batchSize, bool verbose){
|
|
|
|
if( verbose ) printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& %s / %lu / %lu\n", __func__, filePosK, inFileSize );
|
|
|
|
fseek( inFile, filePosK, SEEK_SET);
|
|
|
|
std::vector<timePos> timePosList_A;
|
|
if( filePosK == inFileSize ){
|
|
timePosList_A = timePosList;
|
|
timePosList.clear();
|
|
return timePosList_A;
|
|
}
|
|
|
|
if( timePosList.size() == 0 ){
|
|
int res = 0;
|
|
do{
|
|
res = ReadBlock();
|
|
timePosList.push_back( timePos(data->time, inFilePos0));
|
|
}while( timePosList.size() < batchSize && res == 1);
|
|
SortTimePos();
|
|
unsigned long long t0_B = timePosList.front().time;
|
|
unsigned long long t1_B = timePosList.back().time;
|
|
if( verbose ) {
|
|
printf(" hit in memeory : %7zu | %lu | %lu \n", timePosList.size(), inFilePos, inFileSize);
|
|
printf("t0 : %15llu\n", t0_B);
|
|
printf("t1 : %15llu\n", t1_B);
|
|
}
|
|
timePosList_A = timePosList;
|
|
timePosList.clear();
|
|
|
|
}else{
|
|
timePosList_A = timePosList;
|
|
timePosList.clear();
|
|
}
|
|
|
|
if( feof(inFile) ) return timePosList_A;
|
|
|
|
int res = 0;
|
|
do{
|
|
res = ReadBlock();
|
|
timePosList.push_back(timePos(data->time, inFilePos0));
|
|
}while( timePosList.size() < batchSize && res == 1);
|
|
SortTimePos();
|
|
unsigned long long t0_B = timePosList.front().time;
|
|
unsigned long long t1_B = timePosList.back().time;
|
|
if( verbose ) {
|
|
printf(" hit in memeory : %7zu | %lu | %lu \n", timePosList.size(), inFilePos, inFileSize);
|
|
printf("t0 : %15llu\n", t0_B);
|
|
printf("t1 : %15llu\n", t1_B);
|
|
}
|
|
|
|
unsigned long long t0_A = timePosList_A.front().time;
|
|
unsigned long long t1_A = timePosList_A.back().time;
|
|
ulong ID_A = 0;
|
|
ulong ID_B = 0;
|
|
|
|
if( t0_A >= t0_B) {
|
|
printf("\033[0;31m!!!!!!!!!!!!!!!!! %s | Need to increase the batch size. \033[0m\n", __func__);
|
|
printf("present batch size : %lu \n", batchSize);
|
|
printf("timePosList_A t0_A : %15llu\n", t0_A);
|
|
printf("timePosList t0_B : %15llu\n", t0_B);
|
|
return std::vector<timePos> ();
|
|
}
|
|
|
|
if( t1_A > t0_B) { // need to sort between two hitList
|
|
|
|
if( verbose ) {
|
|
printf("############# need to sort \n");
|
|
printf("=========== sume of A + B : %zu \n", timePosList_A.size() + timePosList.size());
|
|
}
|
|
|
|
std::vector<timePos> timePosListTemp;
|
|
|
|
// find the hit that is >= t0_B, save them to timePosListTemp
|
|
for( size_t j = 0; j < timePosList_A.size() ; j++){
|
|
if( timePosList_A[j].time < t0_B ) continue;;
|
|
if( ID_A == 0 ) ID_A = j;
|
|
timePosListTemp.push_back(timePosList_A[j]);
|
|
}
|
|
|
|
// remove timePosList_A element that is >= t0_B
|
|
timePosList_A.erase(timePosList_A.begin() + ID_A, timePosList_A.end() );
|
|
|
|
// find the hit that is <= t1_A, save them to timePosListTemp
|
|
for( size_t j = 0; j < timePosList.size(); j++){
|
|
if( timePosList[j].time > t1_A ) {
|
|
break;
|
|
}
|
|
timePosListTemp.push_back(timePosList[j]);
|
|
ID_B = j + 1;
|
|
}
|
|
|
|
// remove hit elements that is <= t1_A
|
|
timePosList.erase(timePosList.begin(), timePosList.begin() + ID_B );
|
|
|
|
// sort timePosListTemp
|
|
std::sort(timePosListTemp.begin(), timePosListTemp.end(), [](const timePos& a, const timePos& b) {
|
|
return a.time < b.time;
|
|
});
|
|
|
|
|
|
if( verbose ) {
|
|
printf("----------------- ID_A : %lu, Drop\n", ID_A);
|
|
printf("----------------- ID_B : %lu, Drop\n", ID_B);
|
|
printf("=========== sume of A + B + Temp : %zu \n", timePosList_A.size() + timePosList.size() + timePosListTemp.size());
|
|
printf("----------------- refill timePosList_A \n");
|
|
}
|
|
|
|
for( size_t j = 0; j < timePosListTemp.size(); j++){
|
|
timePosList_A.push_back(timePosListTemp[j]);
|
|
}
|
|
timePosListTemp.clear();
|
|
|
|
if( verbose ) {
|
|
printf("=========== sume of A + B : %zu \n", timePosList_A.size() + timePosList.size());
|
|
printf(" A in memeory : %7zu \n", timePosList_A.size());
|
|
printf("t0 : %15llu\n", timePosList_A.front().time);
|
|
printf("t1 : %15llu\n", timePosList_A.back().time);
|
|
|
|
printf(" B in memeory : %7zu | %lu | %lu \n", timePosList.size(), inFilePos, inFileSize);
|
|
printf("t0 : %15llu\n", timePosList.front().time);
|
|
printf("t1 : %15llu\n", timePosList.back().time);
|
|
}
|
|
|
|
}
|
|
|
|
filePosK = inFilePos;
|
|
|
|
return timePosList_A;
|
|
|
|
}
|
|
|
|
|
|
#endif
|