int main(int argc, char *argv[])
{
assert(argc == 11);
char *shmObjectPath = argv[1];
unsigned long dataFrameSharedMemorySize = boost::lexical_cast<unsigned long>(argv[2]);
char outputType = argv[3][0];
char *outputFilePrefix = argv[4];
float cWindow = boost::lexical_cast<float>(argv[5]);
float minToT = boost::lexical_cast<float>(argv[6]);
float preWindow = boost::lexical_cast<float>(argv[7]);
float postWindow = boost::lexical_cast<float>(argv[8]);
char *channelMapFileName = argv[9];
char *triggerMapFileName = argv[10];
DAQ::Common::SystemInformation *systemInformation = new DAQ::Core::SystemInformation();
if(cWindow != 0) {
systemInformation->loadMapFile(channelMapFileName);
systemInformation->loadTriggerMapFile(triggerMapFileName);
}
FILE *rawFrameFile = NULL;
DAQd::SHM *shm = new DAQd::SHM(shmObjectPath);
AbstractRawHitWriter *writer = NULL;
bool pipeWriterIsNull = true;
if(outputType == 'T') {
writer = new TOFPET::RawWriterV3(outputFilePrefix);
pipeWriterIsNull = false;
}
else if(outputType == 'E') {
writer = new ENDOTOFPET::RawWriterE(outputFilePrefix, 0);
pipeWriterIsNull = false;
}
else if(outputType == 'R') {
writer = new NullRawHitWriter();
char fName[1024];
sprintf(fName, "%s.rawf", outputFilePrefix);
rawFrameFile = fopen(fName, "wb");
assert(rawFrameFile != NULL);
pipeWriterIsNull = true;
}
else {
writer = new NullRawHitWriter();
pipeWriterIsNull = true;
}
bool firstBlock = true;
float step1;
float step2;
BlockHeader blockHeader;
long long stepGoodFrames = 0;
long long stepEvents = 0;
long long stepMaxFrame = 0;
long long stepLostFrames = 0;
long long stepLostFrames0 = 0;
EventSink<RawHit> *sink = NULL;
EventBuffer<RawHit> *outBuffer = NULL;
long long minFrameID = 0x7FFFFFFFFFFFFFFFLL, maxFrameID = 0, lastMaxFrameID = 0;
long long lastFrameID = -1;
long long stepFirstFrameID = -1;
while(fread(&blockHeader, sizeof(blockHeader), 1, stdin) == 1) {
step1 = blockHeader.step1;
step2 = blockHeader.step2;
if(sink == NULL) {
writer->openStep(step1, step2);
if (pipeWriterIsNull) {
sink = new NullSink<RawHit>();
}
else if (cWindow == 0) {
sink = new CoarseSorter(
new RawHitWriterHandler(writer,
new NullSink<RawHit>()
));
}
else {
// Round up cWindow and minToT for use in CoincidenceFilter
float cWindowCoarse = (ceil(cWindow/SYSTEM_PERIOD)) * SYSTEM_PERIOD;
float minToTCoarse = (floor(minToT/SYSTEM_PERIOD) - 2) * SYSTEM_PERIOD;
sink = new CoarseSorter(
new CoincidenceFilter(systemInformation, cWindowCoarse, minToTCoarse,
new RawHitWriterHandler(writer,
new NullSink<RawHit>()
)));
}
}
unsigned bs = shm->getSizeInFrames();
unsigned rdPointer = blockHeader.rdPointer % (2*bs);
unsigned wrPointer = blockHeader.wrPointer % (2*bs);
while(rdPointer != wrPointer) {
unsigned index = rdPointer % bs;
long long frameID = shm->getFrameID(index);
if(stepFirstFrameID == -1) stepFirstFrameID = frameID;
if(frameID <= lastFrameID) {
fprintf(stderr, "WARNING!! Frame ID reversal: %12lld -> %12lld | %04u %04u %04u\n",
lastFrameID, frameID,
blockHeader.wrPointer, blockHeader.rdPointer, rdPointer
);
}
else if ((lastFrameID >= 0) && (frameID != (lastFrameID + 1))) {
// We have skipped one or more frame ID, so
// we account them as lost
long long skippedFrames = (frameID - lastFrameID) - 1;
stepGoodFrames += skippedFrames;
stepLostFrames += skippedFrames;
stepLostFrames0 += skippedFrames;
}
lastFrameID = frameID;
minFrameID = minFrameID < frameID ? minFrameID : frameID;
maxFrameID = maxFrameID > frameID ? maxFrameID : frameID;
// Simply dump the raw data frame
int frameSize = shm->getFrameSize(index);
if (rawFrameFile != NULL) {
DAQd::DataFrame *dataFrame = shm->getDataFrame(index);
fwrite((void *)dataFrame->data, sizeof(uint64_t), frameSize, rawFrameFile);
}
int nEvents = shm->getNEvents(index);
bool frameLost = shm->getFrameLost(index);
if(outBuffer == NULL) {
outBuffer = new EventBuffer<RawHit>(EVENT_BLOCK_SIZE, NULL);
}
for (int n = 0; !pipeWriterIsNull && n < nEvents; n++) {
RawHit &p = outBuffer->getWriteSlot();
#ifdef __ENDOTOFPET__
int feType = shm->getEventType(index, n);
#else
const int feType = 0;
#endif
if (feType == 0) {
p.feType = RawHit::TOFPET;
unsigned tCoarse = shm->getTCoarse(index, n);
unsigned eCoarse = shm->getECoarse(index, n);
p.time = (1024LL * frameID + tCoarse) * T;
p.timeEnd = (1024LL * frameID + eCoarse) * T;
if((p.timeEnd - p.time) < -256*T) p.timeEnd += (1024LL * T);
p.channelID = 64 * shm->getAsicID(index, n) + shm->getChannelID(index, n);
p.d.tofpet.tac = shm->getTACID(index, n);
p.d.tofpet.tcoarse = tCoarse;
p.d.tofpet.ecoarse = eCoarse;
p.d.tofpet.tfine = shm->getTFine(index, n);
p.d.tofpet.efine = shm->getEFine(index, n);
p.channelIdleTime = shm->getChannelIdleTime(index, n);
p.d.tofpet.tacIdleTime = shm->getTACIdleTime(index, n);
}
else if (feType == 1) {
p.feType = RawHit::STIC;
unsigned tCoarse = shm->getTCoarse(index, n);
unsigned eCoarse = shm->getECoarse(index, n);
// Compensate for LFSR's 2^16-1 period
// and wrap at frame's 6.4 us period
int ctCoarse = STICv3::Sticv3Handler::compensateCoarse(tCoarse, frameID) % 4096;
int ceCoarse = STICv3::Sticv3Handler::compensateCoarse(eCoarse, frameID) % 4096;
p.time = 1024LL * frameID * T + ctCoarse * T/4;
p.timeEnd = 1024LL * frameID * T + ceCoarse * T/4;
if((p.timeEnd - p.time) < -256*T) p.timeEnd += (1024LL * T);
p.channelID = 64 * shm->getAsicID(index, n) + shm->getChannelID(index, n);
p.d.stic.tcoarse = tCoarse;
p.d.stic.ecoarse = eCoarse;
p.d.stic.tfine = shm->getTFine(index, n);
p.d.stic.efine = shm->getEFine(index, n);
p.channelIdleTime = shm->getChannelIdleTime(index, n);
p.d.stic.tBadHit = shm->getTBadHit(index, n);
p.d.stic.eBadHit = shm->getEBadHit(index, n);
} else {
continue;
}
outBuffer->pushWriteSlot();
}
if(outBuffer->getSize() >= (EVENT_BLOCK_SIZE - DAQd::MaxDataFrameSize)) {
long long tMin = lastMaxFrameID * 1024 * T;
long long tMax = (maxFrameID+1) * 1024 * T - 1;
outBuffer->setTMin(tMin);
outBuffer->setTMax(tMax);
lastMaxFrameID = maxFrameID;
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
stepEvents += nEvents;
stepMaxFrame = stepMaxFrame > nEvents ? stepMaxFrame : nEvents;
if(frameLost) {
stepLostFrames += 1;
if(nEvents == 0)
stepLostFrames0 += 1;
}
stepGoodFrames += 1;
rdPointer = (rdPointer+1) % (2*bs);
}
if(blockHeader.endOfStep != 0) {
if(sink != NULL) {
if(outBuffer != NULL) {
long long tMin = lastMaxFrameID * 1024 * T;
long long tMax = (maxFrameID+1) * 1024 * T - 1;
outBuffer->setTMin(tMin);
outBuffer->setTMax(tMax);
lastMaxFrameID = maxFrameID;
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
sink->finish();
sink->report();
delete sink;
sink = NULL;
writer->closeStep();
}
fprintf(stderr, "writeRaw:: Step had %lld frames with %lld events; %f events/frame avg, %d event/frame max\n",
stepGoodFrames, stepEvents,
float(stepEvents)/stepGoodFrames,
stepMaxFrame); fflush(stderr);
fprintf(stderr, "writeRaw:: %d (%5.1f%%) frames received had missing data; %d (%5.1f%%) of had no data at all\n",
stepLostFrames, 100.0 * stepLostFrames / stepGoodFrames,
stepLostFrames0, 100.0 * stepLostFrames0 / stepGoodFrames
);
fflush(stderr);
stepGoodFrames = 0;
stepEvents = 0;
stepMaxFrame = 0;
stepLostFrames = 0;
stepLostFrames0 = 0;
lastFrameID = -1;
stepFirstFrameID = -1;
}
fwrite(&rdPointer, sizeof(uint32_t), 1, stdout);
fflush(stdout);
}
delete writer;
delete systemInformation;
if(rawFrameFile != NULL)
fclose(rawFrameFile);
return 0;
}
void RawReader::run()
{
unsigned nWraps = 0;
EventBuffer<RawPulse> *outBuffer = NULL;
int nEventsInFrame = 0;
long long tMax = 0, lastTMax = 0;
long long FrameID;
sink->pushT0(0);
long long minFrameID = LLONG_MAX;
long long maxFrameID = LLONG_MIN;
uint8_t code;
long long events=0;
int bytes;
while (fread(&code, 1, 1, dataFile) == 1) {
events++;
if(code>0x03){
fprintf(stderr, "Impossible code: %u, at event %ld\n\n", code, events);
break;
}
fseek(dataFile, -1, SEEK_CUR);
switch(code){
case 0:{
StartTime rawStartTime;
bytes= fread(&rawStartTime, sizeof(StartTime), 1, dataFile);
AcqStartTime=rawStartTime.time;
//fprintf(stderr, "rawStartTime=%d %d\n",rawStartTime.code,rawStartTime.time);
continue;
}
case 1:{
FrameHeader rawFrameHeader;
bytes=fread(&rawFrameHeader, sizeof(FrameHeader), 1, dataFile);
CurrentFrameID=rawFrameHeader.frameID;
//fprintf(stderr, "Current frameID= %d %lld %lld\n", rawFrameHeader.code,rawFrameHeader.frameID,rawFrameHeader.drift );
continue;
}
case 2:{
RawTOFPET rawEvent;
bytes=fread(&rawEvent, sizeof(RawTOFPET), 1, dataFile);
//fprintf(stderr, "tof.struct=%d\n %d\n %d\n %ld\n %ld\n %ld\n %lld\n %lld\n \n\n", rawEvent.code, rawEvent.tac, rawEvent.channelID,rawEvent.tCoarse, rawEvent.eCoarse, rawEvent.tFine , rawEvent.eFine , rawEvent.tacIdleTime , rawEvent.channelIdleTime );
if(outBuffer == NULL) {
outBuffer = new EventBuffer<RawPulse>(outBlockSize);
}
RawPulse &p = outBuffer->getWriteSlot();
// Carefull with the float/double/integer conversions here..
p.T = T * 1E12;
p.time = (1024LL * CurrentFrameID + rawEvent.tCoarse) * p.T;
p.timeEnd = (1024LL * CurrentFrameID + rawEvent.eCoarse) * p.T;
if((p.timeEnd - p.time) < -256*p.T) p.timeEnd += (1024LL * p.T);
p.channelID = rawEvent.channelID;
p.channelIdleTime = rawEvent.channelIdleTime;
p.region = rawEvent.channelID / 16;
p.feType = RawPulse::TOFPET;
p.d.tofpet.tac = rawEvent.tac;
p.d.tofpet.tcoarse = rawEvent.tCoarse;
p.d.tofpet.ecoarse = rawEvent.eCoarse;
p.d.tofpet.tfine = rawEvent.tFine;
p.d.tofpet.efine = rawEvent.eFine;
p.d.tofpet.tacIdleTime = rawEvent.tacIdleTime;
//printf("DBG T frameID = %20lld tCoarse = %6u time = %20lld\n", CurrentFrameID, rawEvent.tCoarse, p.time);
if(CurrentFrameID < minFrameID) minFrameID = CurrentFrameID;
if(CurrentFrameID > maxFrameID) maxFrameID = CurrentFrameID;
if(p.channelID >= SYSTEM_NCHANNELS)
continue;
if(p.time > tMax)
tMax = p.time;
outBuffer->pushWriteSlot();
if(outBuffer->getSize() >= (outBlockSize - 512)) {
outBuffer->setTMin(lastTMax);
outBuffer->setTMax(tMax);
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
continue;
}
case 3:{
RawSTICv3 rawEvent2;
fread(&rawEvent2, sizeof(RawSTICv3), 1, dataFile);
if(outBuffer == NULL) {
outBuffer = new EventBuffer<RawPulse>(outBlockSize);
}
RawPulse &p = outBuffer->getWriteSlot();
//long long clocksElapsed = CurrentFrameID *1024*4ULL;
long long clocksElapsed = (CurrentFrameID%256) *1024*4ULL; // Periodic reset every 256 frames
long long wrapNumber = clocksElapsed / 32767;
long long wrapRemainder = clocksElapsed % 32767;
unsigned tCoarse = rawEvent2.tCoarse;
unsigned eCoarse = rawEvent2.eCoarse;
if(tCoarse < wrapRemainder)
tCoarse += 32767;
tCoarse -= wrapRemainder;
if(eCoarse < wrapRemainder)
eCoarse += 32767;
eCoarse -= wrapRemainder;
//printf("wrapRemainder: %6lld\n", wrapRemainder);
//printf("tCoarse: %6lu %6lu\n", rawEvent2.tCoarse, tCoarse);
p.T = T * 1E12;
p.time = 1024LL * CurrentFrameID * p.T + tCoarse * p.T/4;
p.timeEnd = 1024LL * CurrentFrameID * p.T + eCoarse * p.T/4;
if((p.timeEnd - p.time) < -256*p.T) p.timeEnd += (1024LL * p.T);
p.channelID = rawEvent2.channelID;
p.channelIdleTime = rawEvent2.channelIdleTime;
p.feType = RawPulse::STIC;
p.d.stic.tcoarse = rawEvent2.tCoarse;
p.d.stic.ecoarse = rawEvent2.eCoarse;
p.d.stic.tfine = rawEvent2.tFine;
p.d.stic.efine = rawEvent2.eFine;
p.d.stic.tBadHit = rawEvent2.tBadHit;
p.d.stic.eBadHit = rawEvent2.eBadHit;
//printf("DBG S frameID = %20lld tCoarse = %6u time = %20lld\n", CurrentFrameID, tCoarse >> 2, p.time);
if(CurrentFrameID < minFrameID) minFrameID = CurrentFrameID;
if(CurrentFrameID > maxFrameID) maxFrameID = CurrentFrameID;
if(p.channelID >= SYSTEM_NCHANNELS)
continue;
if(p.time > tMax)
tMax = p.time;
outBuffer->pushWriteSlot();
if(outBuffer->getSize() >= (outBlockSize - 512)) {
outBuffer->setTMin(lastTMax);
outBuffer->setTMax(tMax);
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
continue;
}
}
}
if(outBuffer != NULL) {
outBuffer->setTMin(lastTMax);
outBuffer->setTMax(tMax);
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
sink->finish();
fprintf(stderr, "RawReaderV2 report\n");
fprintf(stderr, "\t%16lld minFrameID\n", minFrameID);
fprintf(stderr, "\t%16lld maxFrameID\n", maxFrameID);
sink->report();
}
void RawReaderV2::run()
{
unsigned nWraps = 0;
EventBuffer<RawPulse> *outBuffer = NULL;
int nEventsInFrame = 0;
long long tMax = 0, lastTMax = 0;
sink->pushT0(0);
long long minFrameID = LLONG_MAX;
long long maxFrameID = LLONG_MIN;
fprintf(stderr, "Reading %llu to %llu\n", eventsBegin, eventsEnd);
fseek(dataFile, eventsBegin * sizeof(RawEventV2), SEEK_SET);
int maxReadBlock = 1024*1024;
RawEventV2 *rawEvents = new RawEventV2[maxReadBlock];
unsigned long long readPointer = eventsBegin;
while (readPointer < eventsEnd) {
unsigned long long count = eventsEnd - readPointer;
if(count > maxReadBlock) count = maxReadBlock;
int r = fread(rawEvents, sizeof(RawEventV2), count, dataFile);
if(r <= 0) break;
readPointer += r;
//printf("events extracted= %lld\n",readPointer);
for(int j = 0; j < r; j++) {
RawEventV2 &rawEvent = rawEvents[j];
if(outBuffer == NULL) {
outBuffer = new EventBuffer<RawPulse>(outBlockSize);
}
RawPulse &p = outBuffer->getWriteSlot();
// Carefull with the float/double/integer conversions here..
p.T = T * 1E12;
p.time = (1024LL * rawEvent.frameID + rawEvent.tCoarse) * p.T;
p.timeEnd = (1024LL * rawEvent.frameID + rawEvent.eCoarse) * p.T;
if((p.timeEnd - p.time) < -256*p.T) p.timeEnd += (1024LL * p.T);
p.channelID = (64 * rawEvent.asicID) + rawEvent.channelID;
p.channelIdleTime = rawEvent.channelIdleTime;
p.region = (64 * rawEvent.asicID + rawEvent.channelID) / 16;
p.feType = RawPulse::TOFPET;
p.d.tofpet.tac = rawEvent.tacID;
p.d.tofpet.tcoarse = rawEvent.tCoarse;
p.d.tofpet.ecoarse = rawEvent.eCoarse;
p.d.tofpet.tfine = rawEvent.tFine;
p.d.tofpet.efine = rawEvent.eFine;
p.channelIdleTime = rawEvent.channelIdleTime;
p.d.tofpet.tacIdleTime = rawEvent.tacIdleTime;
if(rawEvent.frameID < minFrameID) minFrameID = rawEvent.frameID;
if(rawEvent.frameID > maxFrameID) maxFrameID = rawEvent.frameID;
if(p.channelID >= SYSTEM_NCHANNELS)
continue;
if(p.time > tMax)
tMax = p.time;
outBuffer->pushWriteSlot();
if(outBuffer->getSize() >= outBlockSize) {
outBuffer->setTMin(lastTMax);
outBuffer->setTMax(tMax);
sink->pushEvents(outBuffer);
lastTMax = tMax;
outBuffer = NULL;
}
}
}
delete [] rawEvents;
if(outBuffer != NULL) {
outBuffer->setTMin(lastTMax);
outBuffer->setTMax(tMax);
sink->pushEvents(outBuffer);
outBuffer = NULL;
}
sink->finish();
fprintf(stderr, "RawReaderV2 report\n");
fprintf(stderr, "\t%16lld minFrameID\n", minFrameID);
fprintf(stderr, "\t%16lld maxFrameID\n", maxFrameID);
sink->report();
}
