00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271 #include "Stypes.h"
00272
00273
00274 #include <string.h>
00275 #include <stdio.h>
00276 #include <errno.h>
00277 #include <unistd.h>
00278 #include <assert.h>
00279 #include <sys/types.h>
00280 #include <sys/stat.h>
00281 #include <fcntl.h>
00282 #include "Stypes.h"
00283 #include "StMessMgr.h"
00284 #include "StDAQReader.h"
00285
00286 #include "StDaqLib/GENERIC/EventReader.hh"
00287 #if !defined(OLD_EVP_READER) && !defined(NEW_DAQ_READER)
00288 # include "RTS/src/EVP_READER/evpReaderClass.h"
00289 #elif NEW_DAQ_READER
00290 # include "RTS/src/DAQ_READER/daqReader.h"
00291 #endif
00292
00293 #include "StDaqLib/RICH/RICH_Reader.hh"
00294 #include "StDaqLib/L3/L3_Reader.hh"
00295 #include "StDaqLib/TOF/TOF_Reader.hh"
00296 #include "StDaqLib/FPD/FPD_Reader.hh"
00297
00298 #include "StTPCReader.h"
00299 #include "StEMCReader.h"
00300 #include "StSSDReader.h"
00301 #include "StEEMCReader.h"
00302 #include "StPMDReader.h"
00303 #include "StFTPCReader.h"
00304 #include "StTRGReader.h"
00305 #include "StSVTReader.h"
00306 #include "StMessMgr.h"
00307 #include "TString.h"
00308 #include "StRtsReaderMaker.h"
00309 #include "StStreamFileFactory.h"
00310 #include "StStreamFile.h"
00311
00312
00313
00314
00315 typedef EventInfo DAQEventInfo;
00316
00317 StDAQReader::StDAQReader(const char *file, StRtsReaderMaker* rtsMaker) :
00318 fRtsMaker(rtsMaker)
00319 {
00320 fFd = -1;
00321 fVerbose = 0;
00322 fEventReader = 0;
00323 fTPCReader = 0;
00324 fEMCReader = 0;
00325 fSSDReader = 0;
00326 fEEMCReader = 0;
00327 fPMDReader = 0;
00328 fFTPCReader = 0;
00329 fRICHReader = 0;
00330 fTRGReader = 0;
00331 fSVTReader = 0;
00332 fL3Reader = 0;
00333 fTOFReader = 0;
00334 fFPDReader = 0;
00335 m_ZeroTokens = 0;
00336 fOffset = 0;
00337 fFile = 0;
00338 fEventInfo = new DAQEventInfo;
00339 memset(fEventInfo,0,sizeof(DAQEventInfo));
00340 assert(sizeof(DAQEventInfo)==sizeof(EventInfo));
00341 setTPCVersion();
00342 setFTPCVersion();
00343 fTrigSummary = new StTrigSummary();
00344 fDaqFileReader = 0;
00345 fDatFileReader = 0;
00346 fDATAP = 0;
00347 if(file && file[0]) open(file);
00348 }
00349
00350
00351 int StDAQReader::open(const char *file)
00352 {
00353 assert(file);
00354 if (!fRtsMaker) fRtsMaker = new StRtsReaderMaker;
00355 if (StStreamFileFactory::Factory()) {
00356
00357 const char *dat_ext= ".dat";
00358 LOG_INFO << " StDAQReader::open(const char *file): " << file << " - "
00359 << (const char*)&file[strlen(file)-sizeof(dat_ext)]
00360 << " len=" << strlen(file)
00361 << " size=" << sizeof(dat_ext)
00362 << fDatFileReader << endm;
00363 if (TString(dat_ext) == (const char*)&file[strlen(file)-sizeof(dat_ext)] && !fDatFileReader) {
00364 fDatFileReader = StStreamFileFactory::Factory()->Create();
00365 fRtsMaker->SetDatReader(fDatFileReader);
00366 }
00367 }
00368 if (fDatFileReader) {
00369 fDatFileReader->open(file);
00370 } else {
00371 if (fDaqFileReader) close();
00372 fDaqFileReader = new daqReader((char *)file);
00373 fRtsMaker->SetDaqReader(fDaqFileReader);
00374 }
00375 LOG_INFO << "StDAQReader::open the DAQ " << file << " via "
00376 << (fDatFileReader ? "DAT reader ->" : "" ) << fDatFileReader
00377 << (fDaqFileReader ? "daqReader ->" : "") << fDaqFileReader
00378 << endm;
00379 fOffset =0;
00380 return 0;
00381 }
00382
00383 void StDAQReader::clear()
00384 {
00385 delete fEventReader; fEventReader = 0;
00386 }
00387
00388 int StDAQReader::close()
00389 {
00390 if (fDaqFileReader ) {
00391 delete fDaqFileReader;
00392 fDaqFileReader = 0;
00393 } else if (fDatFileReader) {
00394 fDatFileReader->close();
00395 }
00396 if (fRtsMaker) {
00397 fRtsMaker->SetDaqReader(0);
00398 }
00399 delete fEventReader; fEventReader = 0;
00400
00401 if(fTPCReader) fTPCReader ->close();
00402 if(fSSDReader) fSSDReader ->close();
00403 if(fEMCReader) fEMCReader ->close();
00404 if(fEEMCReader) fEEMCReader->close();
00405 if(fPMDReader) fPMDReader ->close();
00406 if(fSVTReader) fSVTReader ->close();
00407
00408 if(fFTPCReader) fFTPCReader->close();
00409 if(fTRGReader) fTRGReader ->close();
00410 delete fL3Reader; fL3Reader = 0;
00411 fOffset = -1;
00412 return 0;
00413 }
00414
00415 StDAQReader::~StDAQReader()
00416 {
00417 if (m_ZeroTokens > 1){
00418 LOG_WARN << m_ZeroTokens << " events with token==0" << endm;
00419 }
00420 free(fDATAP);
00421 fDATAP = 0;
00422 close();
00423 delete fDatFileReader; fDatFileReader=0;
00424 }
00425
00427 void StDAQReader::nextEvent()
00428 {
00429 #ifndef OLD_EVP_READER
00430
00431
00432 char *currentData = fDaqFileReader->get(0,EVP_TYPE_ANY);
00433 LOG_DEBUG << " StEvpReader::NextEvent - data = "
00434 << (void *)currentData <<" :: " << fDaqFileReader
00435 << " status " << fDaqFileReader->status << " EVP_STAT_OK=" << EVP_STAT_OK
00436 << " token " << fDaqFileReader->token
00437 << endm
00438 ;
00439
00440 fOffset = -1;
00441 if(currentData && (fDaqFileReader->status == EVP_STAT_OK) ) {
00442 fOffset = 1;
00443 } else {
00444 switch(fDaqFileReader->status) {
00445 case EVP_STAT_EOR :
00446 if(fDaqFileReader->IsEvp()) {
00447 LOG_FATAL << "StEvpReader::NextEvent - waiting event" << endm;
00448 nextEvent();
00449 } else {
00450 LOG_DEBUG << "StEvpReader::NextEvent - End Of File" << endm;
00451 }
00452 break;
00453 case EVP_STAT_EVT :
00454 LOG_ERROR << "Problem getting event - skipping" << endm;
00455 nextEvent();
00456 break;
00457 case EVP_STAT_CRIT :
00458 LOG_ERROR << "Critical error - halting..." << endm;
00459 nextEvent();
00460 break;
00461 default:
00462 LOG_FATAL << "Unknow DAQ file I/O problem " << endm;
00463 };
00464 }
00465 fEventStatus = fDaqFileReader->status;
00466 #endif
00467 }
00468
00469 int StDAQReader::Make()
00470 {
00471 int ret = readEvent();
00472 if (fRtsMaker) fRtsMaker->Make();
00473 return ret;
00474 }
00475
00476 int StDAQReader::readEvent()
00477 {
00478 int retStatus = kStOk;
00479
00480 if (fDatFileReader) {
00481 fDatFileReader->Read();
00482 if (!fDatFileReader->good()) {
00483 fOffset = -1;
00484 retStatus = kStErr;
00485 if (fDatFileReader->eof() ) retStatus = kStEOF;
00486 }
00487 } else if (fDaqFileReader) {
00488 nextEvent();
00489 if (fOffset == -1) retStatus = kStEOF;
00490 }
00491
00492 delete fEventReader; fEventReader=0;
00493 delete fRICHReader; fRICHReader = 0;
00494 delete fL3Reader; fL3Reader = 0;
00495 delete fTOFReader; fTOFReader = 0;
00496 delete fFPDReader; fFPDReader = 0;
00497 if (retStatus == kStOk) {
00498 fEventReader = new EventReader();
00499 fEventReader->setVerbose(fVerbose);
00500
00501 fEventReader->setDaqReader(fDaqFileReader);
00502 if (fDaqFileReader) {
00503 if (fDaqFileReader->mem) {
00504
00505
00506
00507
00508
00509
00510 # if 1
00511 fDATAP = (char *)realloc(fDATAP, fDaqFileReader->bytes);
00512 memcpy(fDATAP,fDaqFileReader->mem, fDaqFileReader->bytes);
00513
00514 fDaqFileReader->fixDatapSummary((DATAP*)fDATAP);
00515 # else
00516 fDATAP = (char *)realloc(fDATAP, fDaqFileReader->bytes_mapped);
00517 memcpy(fDATAP,fDaqFileReader->mem, fDaqFileReader->bytes_mapped);
00518 # endif
00519 fEventReader->InitEventReader(fDATAP);
00520 *fEventInfo = fEventReader->getEventInfo();
00521 if(fEventInfo->Token==0){
00522 LOG_INFO <<
00523 Form("StDAQReader::readEvent: found event with token==0") << endm;
00524 m_ZeroTokens++;
00525
00526 }
00527 }
00528 else if(fDaqFileReader && fDaqFileReader->token==0){
00529 LOG_INFO <<
00530 Form("StDAQReader::readEvent: found event with token==0") << endm;
00531 m_ZeroTokens++;
00532 }
00533 if (fTPCReader && TPCPresent() ) fTPCReader ->Update();
00534 if (fFTPCReader && FTPCPresent()) fFTPCReader->Update();
00535 if (fTRGReader && TRGPresent() ) {
00536 fTRGReader ->Update();
00537 if ( ! fTRGReader->thereIsTriggerData() ){
00538 LOG_INFO <<
00539 Form("StDAQReader::readEvent: No or bad TRG data - Skipping event: ")
00540 << getRunNumber() << " : " <<getEventNumber()<< endm;
00541 return kStErr;
00542 }
00543 }
00544 if (fSVTReader && SVTPresent() ) fSVTReader ->Update();
00545 if (fSSDReader && SSDPresent() ) fSSDReader ->Update();
00546 if (fEMCReader && EMCPresent() ) fEMCReader ->Update();
00547 if (fEEMCReader && EMCPresent() ) fEEMCReader->Update();
00548 if (fPMDReader && PMDPresent() ) fPMDReader ->Update();
00549
00550
00551 int i;
00552 for(i=0;i<2;i++) fTrigSummary->L1summary[i]=fDaqFileReader->L1summary[i];
00553 for(i=0;i<2;i++) fTrigSummary->L2summary[i]=fDaqFileReader->L2summary[i];
00554 for(i=0;i<4;i++) fTrigSummary->L3summary[i]=fDaqFileReader->L3summary[i];
00555 } }
00556 return retStatus;
00557 }
00558
00559 int StDAQReader::skipEvent(int nskip)
00560 {
00561 for (int isk=0; nskip; nskip--,isk++)
00562 {
00563 delete fEventReader;
00564 if (fOffset == -1) {
00565 LOG_WARN << Form("EOF after record %d\n",isk)<< endm;
00566 break;}
00567 #ifdef OLD_EVP_READER
00568 fEventReader = new EventReader();
00569
00570 fEventReader->InitEventReader(fFd, fOffset);
00571 if(fEventReader->errorNo()) {
00572 LOG_WARN << Form("<Warning: StDAQReader::skipEvent> ReadError on record %d",isk)<<endm;
00573 fOffset = -1; break;}
00574 fOffset = fEventReader->NextEventOffset();
00575 #else
00576 nextEvent();
00577 #endif
00578 }
00579 return nskip;
00580 }
00581
00582
00583
00584 void StDAQReader::setTPCVersion(const char* vers)
00585 {strcpy(fTPCVersion,vers);}
00586
00587 void StDAQReader::setFTPCVersion(const char* vers)
00588 {strcpy(fFTPCVersion,vers);}
00589
00590
00591 int StDAQReader::getRunNumber() const
00592 {
00593
00594
00595 int runNum = -1;
00596 if (fDatFileReader)
00597 runNum = fDatFileReader->RunNumber();
00598 else if (fDaqFileReader )
00599 runNum = fDaqFileReader->run;
00600 else
00601 runNum = fEventReader->runno();
00602 return runNum;
00603 }
00604
00605 int StDAQReader::getEventNumber() const {
00606 return fDaqFileReader ?
00607 fDaqFileReader->seq
00608 :
00609 fEventInfo->EventSeqNo;
00610 }
00611
00612 unsigned int StDAQReader::getUnixTime() const
00613 {
00614 int unixTime = 0;
00615 if (fDatFileReader)
00616 unixTime = fDatFileReader->RecordUnixTime();
00617 else if (fDaqFileReader )
00618 unixTime = fDaqFileReader->evt_time;
00619 else
00620 unixTime = fEventInfo->UnixTime;
00621 return unixTime;
00622 }
00623
00624
00625 unsigned int StDAQReader::getTrigWord() const {
00626 return fDaqFileReader ?
00627 fDaqFileReader->trgword
00628 :
00629 fEventInfo->TrigWord;
00630 }
00631
00632 unsigned int StDAQReader::getTrigInputWord() const {return fEventInfo->TrigInputWord;}
00633
00634 int StDAQReader::TPCPresent() const {return fEventInfo->TPCPresent;}
00635
00636 int StDAQReader::SVTPresent() const {return fEventInfo->SVTPresent;}
00637
00638 int StDAQReader::TOFPresent() const {return fEventInfo->TOFPresent;}
00639
00640 int StDAQReader::FPDPresent() const {return fEventInfo->FPDPresent;}
00641
00642 int StDAQReader::SSDPresent() const {return fEventInfo->SSDPresent;}
00643
00644 int StDAQReader::EMCPresent() const {return fEventInfo->EMCPresent;}
00645
00646 int StDAQReader::PMDPresent() const {return fEventInfo->PMDPresent;}
00647
00648 int StDAQReader::SMDPresent() const {return fEventInfo->BSMDPresent|fEventInfo->ESMDPresent;}
00649
00650 int StDAQReader::FTPCPresent() const {return fEventInfo->FTPCPresent;}
00651
00652 int StDAQReader::RICHPresent() const {return fEventInfo->RICHPresent;}
00653
00654 int StDAQReader::TRGPresent() const {return ( fEventInfo && fEventInfo->TRGPresent) || (fDatFileReader && StTRGReader::OldFormat(fDatFileReader->Version()));}
00655
00656 int StDAQReader::L3Present() const {return fEventInfo->L3Present;}
00657
00658 int StDAQReader::getEventSize()const
00659 {
00660 int eventSize = 0;
00661 if (fDatFileReader)
00662 eventSize = fDatFileReader->Length();
00663 else
00664 eventSize = fEventInfo->EventLength;
00665 return eventSize;
00666 }
00667
00668 StTPCReader *StDAQReader::getTPCReader(char mergeSequences)
00669 {
00670 int updateStatus;
00671 if(!TPCPresent()) return 0;
00672 if (!fTPCReader) {
00673 fTPCReader = new StTPCReader(this,mergeSequences);
00674 updateStatus=fTPCReader->Update();
00675 if(updateStatus) { delete fTPCReader; fTPCReader=0; return 0; }
00676 }
00677 return fTPCReader;
00678 }
00679
00680 StEEMCReader *StDAQReader::getEEMCReader()
00681 {
00682 if (!fEEMCReader) {
00683 fEEMCReader = new StEEMCReader(this);
00684 }
00685 return fEEMCReader;
00686 }
00687
00688 StEMCReader *StDAQReader::getEMCReader()
00689 {
00690 if (!EMCPresent()) return 0;
00691 if (!fEMCReader) {
00692 fEMCReader = new StEMCReader(this);
00693 }
00694 return fEMCReader;
00695 }
00696
00697 StSSDReader *StDAQReader::getSSDReader()
00698 {
00699 if (!SSDPresent()) return 0;
00700 if (!fSSDReader) {
00701 fSSDReader = new StSSDReader(this);
00702 }
00703 return fSSDReader;
00704 }
00705
00706 StPMDReader *StDAQReader::getPMDReader()
00707 {
00708 if (!PMDPresent()) return 0;
00709 if (!fPMDReader) {
00710 fPMDReader = new StPMDReader(this);
00711
00712 }
00713 return fPMDReader;
00714 }
00715
00716 StRICHReader *StDAQReader::getRICHReader()
00717 {
00718 if (!RICHPresent()) return 0;
00719 if (!fRICHReader) {
00720 fRICHReader = ::getRICHReader(fEventReader);
00721 if (!fRICHReader) fEventInfo->RICHPresent=0;
00722 }
00723
00724 return fRICHReader;
00725 }
00726
00727 StL3Reader *StDAQReader::getL3Reader()
00728 {
00729 if (!L3Present()) return 0;
00730 if (!fL3Reader) {
00731 fL3Reader = ::getL3Reader(fEventReader);
00732 if (!fL3Reader) fEventInfo->L3Present=0;
00733 }
00734 return fL3Reader;
00735 }
00736
00737 StFTPCReader *StDAQReader::getFTPCReader()
00738 {
00739 if (!FTPCPresent()) return 0;
00740 if (!fFTPCReader) {
00741 fFTPCReader = new StFTPCReader(this);
00742 fFTPCReader->Update();
00743 }
00744 return fFTPCReader;
00745 }
00746
00747 StTOFReader *StDAQReader::getTOFReader()
00748 {
00749 if (!TOFPresent()) return 0;
00750 if (!fTOFReader) {
00751 fTOFReader = ::getTOFReader(fEventReader);
00752 if(!fTOFReader) fEventInfo->TOFPresent=0;
00753 }
00754 return fTOFReader;
00755 }
00756
00757 StFPDReader *StDAQReader::getFPDReader()
00758 {
00759 if (!FPDPresent()) return 0;
00760 if (!fFPDReader) {
00761 fFPDReader = ::getFPDReader(fEventReader);
00762 if (!fFPDReader) fEventInfo->FPDPresent=0;
00763 }
00764 return fFPDReader;
00765 }
00766
00767 StTRGReader *StDAQReader::getTRGReader()
00768 {
00769 if (!TRGPresent()) return 0;
00770 if (!fTRGReader) {
00771 fTRGReader = new StTRGReader(this);
00772
00773 }
00774 return fTRGReader;
00775 }
00776
00777 StSVTReader *StDAQReader::getSVTReader()
00778 {
00779 if (!SVTPresent()) return 0;
00780 if (!fSVTReader) {
00781 fSVTReader = new StSVTReader(this);
00782 fSVTReader->Update();
00783 }
00784 return fSVTReader;
00785 }
00786
00787
00788 void StDAQReader::printEventInfo()
00789 {fEventReader->printEventInfo();}
