StRoot: StDaqLib/RICH/RichEventReader.cxx Source File

00001 /***************************************************************************
00002  * $Id: RichEventReader.cxx,v 1.5 2007/12/24 06:04:23 fine Exp $
00003  * Author: Zhangbu Xu 
00004  ***************************************************************************
00005  * Description: Rich Event reader code for standalone data file
00006  *
00007  *  change log
00008  * 06-Jun-99 MJL implement EventReader::getEventInfo()
00009  * 06-Jun-99 MJL implement EventReader::printEventInfo()
00010  * 23-Jun-99 MJL add verbose flag and setVerbose() method
00011  * 23-Jun-99 MJL turn off all printf, cout when verbose=0
00012  * 24-Jun-99 MJL navigation now reads DATAP without prior 
00013  *               knowledge of DATAP length
00014  * 20-Jul-99 MJL added EventReader::fprintError()
00015  * 20-Jul-99 MJL add alternate constructor for EventReader with name of logfile
00016  * 20-Jul-99 MJL add alternate getEventReader with name of logfile
00017  * 20-Jul-99 MJL add overloaded printEventInfo(FILE *)
00018  * 29-Aug-99 MJL if((MMAPP = (char *) mmap(0, ...  for HP platform
00019  * 28-Dec-99 MJL add alternate InitEventReaders, mapped and unmapped
00020  * 31-Jan-00 MJL set runnum  (mapped version)
00021  * 21-Apr-00 Adopted by Z. Xu to read Rich standalone events 
00022  *
00023  ***************************************************************************
00024  * $Log: RichEventReader.cxx,v $
00025  * Revision 1.5  2007/12/24 06:04:23  fine
00026  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00027  *
00028  * Revision 1.4  2004/02/18 20:17:52  ward
00029  * Access SSD data in makers.
00030  *
00031  * Revision 1.3  2003/12/24 21:55:57  perev
00032  * Cleanup
00033  *
00034  * Revision 1.2  2000/04/25 15:18:08  xzb
00035  * Fix the compiler warnings.
00036  *
00037  * Revision 1.1  2000/04/25 14:55:28  xzb
00038  * Clean up RICH_Reader array, add RichEventReader for standalone data file
00039  *
00040  * Revision 1.19  2000/01/31 19:26:11  levine
00041  * restore run number to memory-mapped version
00042  *
00043  * Revision 1.18  2000/01/11 22:04:40  levine
00044  * EventReader.hh  // change the header file to include std::string
00045  * EventReader.cxx // convert string to char* via c_str() member
00046  * (changes from Brian Lasiuk)
00047  *
00048  * Revision 1.17  2000/01/04 20:54:46  levine
00049  * Implemented memory-mapped file access in EventReader.cxx. Old method
00050  * (via seeks) is still possible by setting mmapp=0 in
00051  *
00052  *      getEventReader(fd,offset,(const char *)logfile,mmapp);
00053  *
00054  *
00055  * but memory-mapped access is much more effective.
00056  *
00057  * Revision 1.16  1999/12/07 23:10:30  levine
00058  * changes to silence the gcc compiler warnings
00059  *
00060  * Revision 1.15  1999/12/07 20:24:45  levine
00061  * add #include <time.h> to make compile warning go away
00062  *
00063  * Revision 1.14  1999/12/06 22:53:20  levine
00064  * Cleaned up information generated on failure to initialize EventReader
00065  *
00066  * Revision 1.13  1999/12/03 21:39:22  levine
00067  * ON encountering end of file, issue INFO message instead of ERROR
00068  *
00069  * Revision 1.12  1999/12/02 16:40:23  levine
00070  * change test on ret value for read (line 230) to prevent looping behavior
00071  * at end of file
00072  *
00073  * Revision 1.11  1999/11/20 00:13:09  fisyak
00074  * Micheal LeVine update
00075  *
00076  * Revision 1.9  1999/07/28 16:08:23  levine
00077  * modify EventReader so that ENDR does not cause error exit
00078  *
00079  * Revision 1.8  1999/07/21 21:33:09  levine
00080  *
00081  *
00082  * changes to include error logging to file.
00083  *
00084  * There are now 2 constructors for EventReader:
00085  *
00086  *  EventReader();
00087  *  EventReader(const char *logfilename);
00088  *
00089  * Constructed with no argument, there is no error logging. Supplying a file name
00090  * sends all diagnostic output to the named file (N.B. opens in append mode)
00091  *
00092  * See example in client.cxx for constructing a log file name based on the
00093  * datafile name.
00094  *
00095  * It is strongly advised to use the log file capability. You can grep it for
00096  * instances of "ERROR:" to trap anything noteworthy (i.e., corrupted data files).
00097  *
00098  * Revision 1.7  1999/07/10 21:31:17  levine
00099  * Detectors RICH, EMC, TRG now have their own (defined by each detector) interfaces.
00100  * Existing user code will not have to change any calls to TPC-like detector
00101  * readers.
00102  *
00103  * Revision 1.6  1999/07/04 01:47:58  levine
00104  * minor changes to make solaris CC compiler happy
00105  *
00106  * Revision 1.5  1999/07/02 04:37:41  levine
00107  * Many changes - see change logs in individual programs
00108  *
00109  **************************************************************************/
00110 
00111 #include <sys/types.h>
00112 #include <sys/stat.h>
00113 #include <sys/mman.h>
00114 #include <time.h>
00115 #include <fcntl.h>
00116 #include <stdlib.h>
00117 #include <sys/uio.h>
00118 #include <unistd.h>
00119 #include "RichEventReader.hh"
00120 #include "RICH_Reader.hh"
00121 
00122 using namespace OLDEVP;
00123 
00124 RichEventReader *getRichEventReader(int fd, long offset, int MMap)
00125 {
00126   RichEventReader *er = new RichEventReader();
00127   if (MMap) {
00128     er->InitEventReader(fd, offset, MMap); // invoke the mapped version
00129     if(er->errorNo()) 
00130       {
00131         cout << er->errstr().c_str() << endl;
00132         cout << (er->err_string[er->errorNo()-1]) << endl;
00133         delete er;
00134         return NULL;
00135       }
00136   }
00137   else {
00138     er->InitEventReader(fd, offset); // invoke the mapped version
00139     if(er->errorNo()) 
00140       {
00141         cout << er->errstr().c_str() << endl;
00142         cout << (er->err_string[er->errorNo()-1]) << endl;
00143         delete er;
00144         return NULL;
00145       }
00146   }
00147   
00148   return er;
00149 }
00150 
00151 
00152 //Memory mapped version
00153 void RichEventReader::InitEventReader(int fdes, long offset, int MMap)
00154 {//InitER
00155   //#define MX_MAP_SIZE 0x20000000
00156 #define MX_MAP_SIZE 32768*4 /*max event size in RICH*/
00157 
00158   off_t FileLength;
00159 
00160   //  cout << "Initializing EventReader with a MAPPED file" << endl;
00161   
00162   //initialize the error strings
00163   strcpy(err_string[0],"ERROR: FILE");
00164   strcpy(err_string[1],"ERROR: CRC");
00165   strcpy(err_string[2],"ERROR: SWAP");
00166   strcpy(err_string[3],"ERROR: BANK");
00167   strcpy(err_string[4],"ERROR: MEM");
00168   strcpy(err_string[5],"ERROR: NOT DATA BANK");
00169   strcpy(err_string[6],"ERROR: BAD ARG");
00170   strcpy(err_string[7],"ERROR: ENDR ENCOUNTERED");
00171   strcpy(err_string[8],"ERROR: BAD HEADER");
00172   strcpy(err_string[9],"INFO: MISSING BANK");
00173   strcpy(err_string[10],"INFO: END OF FILE");
00174 
00175 
00176   fd = fdes;
00177   struct stat buf;
00178   next_event_offset = 0;
00179   if (fstat(fd,&buf)<0){
00180     perror("error in DaqOpenTag");
00181     ERROR(ERR_FILE);
00182     next_event_offset = -1;
00183   }
00184   FileLength = buf.st_size;
00185   
00186   Bank_RICP lr;
00187 
00188   // Calculate the mmap offset - must be aligned to pagesize
00189   long pagesize = sysconf(_SC_PAGESIZE);
00190   int mmap_offset = (offset/pagesize)*pagesize;
00191 
00192   if(mmap_offset < 0) ERROR(ERR_FILE);
00193 
00194   int mapsize = buf.st_size - offset + pagesize;
00195                     //round up to the next page boundary
00196   if (mapsize<=0) {// <0 means previous event size exceeded file length
00197     if (verbose) printf("end of file encountered\n");
00198     ERROR(INFO_END_FILE) ;
00199     next_event_offset= -1;
00200   }
00201   //  if (verbose) printf( "pagesize = %d  mapsize %d offset %d\n",(int)pagesize, mapsize, offset);
00202   if (mapsize>MX_MAP_SIZE)    mapsize =  MX_MAP_SIZE;
00203   event_size = mapsize ; //needed for munmap() in destructor
00204 
00205   DATAP = NULL;
00206   // map to a file
00207   if((MMAPP = (char *)mmap(0, mapsize, PROT_READ | PROT_WRITE,
00208                            MAP_PRIVATE, fd, mmap_offset)) == (caddr_t) -1) { 
00209     char myerr[100];
00210     sprintf(myerr,"mapping file request 0x%x bytes 0x%x",mapsize,mmap_offset);
00211     perror(myerr); 
00212     ERROR(ERR_MEM);
00213     next_event_offset=-1;
00214   }
00215   //  if (verbose) printf("mapping file request 0x%x bytes 0x%x with page 0x%x at 0x%x\n",mapsize,mmap_offset,pagesize,MMAPP);
00216 
00217   // Set DATAP to the real value
00218   DATAP = MMAPP + (offset-mmap_offset);
00219   
00220   if (offset>=buf.st_size) {
00221     ERROR(ERR_FILE) ;
00222     next_event_offset = -1;
00223   }
00224 
00225   if (strncmp(DATAP,"RICP", 4) == 0) {
00226     // copy the logical record into local struct lr
00227     if (memcpy(&lr,DATAP,sizeof(lr))<0) perror("error in memcpy");
00228     // check the CRC
00229     if (!lr.test_CRC()) ERROR(ERR_CRC);
00230     // swap bytes
00231     if (lr.swap() < 0) ERROR(ERR_SWAP);
00232     // zero CRC
00233     lr.header.CRC = 0;
00234     
00235     char lcopy[10];
00236     
00237     strncpy(lcopy,lr.header.BankType,8);
00238     lcopy[8] = 0;
00239     //    printf("lr.header.BankType: %s\n",lcopy);
00240 
00241     if(strncmp(lr.header.BankType, "RICP", 4) != 0) { //not DATA
00242       perror("Have problem will the file\n");
00243       next_event_offset = -1;
00244     }
00245     else { // DATA record. Skip LR
00246       
00247       // save run number
00248       runnum = 0;
00249       //    DATAP +=sizeof(lr);
00250       next_event_offset = 4 * lr.Reserved[0].off+offset;
00251 
00252       if (lr.header.Token==0){ // hack
00253         next_event_offset = -1;
00254         printf("hack: do not know how to deal with token==0\n");
00255         DATAP = NULL;
00256       } 
00257       
00258       //   break; //no need to loop any further
00259     }
00260   }    
00261   printf("======= Event number: %d  with size %d============\n",lr.header.Token,lr.Reserved[0].off);
00262 }
00263 
00264 RichEventReader::RichEventReader()
00265 {
00266   DATAP = NULL;
00267   MMAPP = NULL;
00268   errnum = 0;
00269   runnum = 0;
00270   memset(errstr0, '\0', sizeof(errstr0));
00271   event_size = 0;
00272   fd = -1;
00273   next_event_offset = -1;
00274   verbose = 0;
00275   logfd = NULL; //no error logging
00276 }
00277 
00278 // unmapped version
00279 void RichEventReader::InitEventReader(int fdes, long offset)
00280 {//InitER
00281   long c_offset = offset;
00282   next_event_offset = -1;
00283 
00284   if (verbose) cout << "Initializing RichEventReader with a file" << endl;
00285 
00286   //initialize the error strings
00287   strcpy(err_string[0],"ERROR: FILE");
00288   strcpy(err_string[1],"ERROR: CRC");
00289   strcpy(err_string[2],"ERROR: SWAP");
00290   strcpy(err_string[3],"ERROR: BANK");
00291   strcpy(err_string[4],"ERROR: MEM");
00292   strcpy(err_string[5],"ERROR: NOT DATA BANK");
00293   strcpy(err_string[6],"ERROR: BAD ARG");
00294   strcpy(err_string[7],"ERROR: ENDR ENCOUNTERED");
00295   strcpy(err_string[8],"ERROR: BAD HEADER");
00296   strcpy(err_string[9],"INFO: MISSING BANK");
00297   strcpy(err_string[10],"INFO: END OF FILE");
00298 
00299 
00300   fd = fdes;
00301   int DATAPEVENTLENGTH=0;   // hack, the event length is not yet in datap
00302 
00303   char bank[9];
00304   memset(bank,'\0',sizeof(bank));
00305 
00306   int ret = lseek(fd, offset, SEEK_SET);
00307   if(ret < 0) {
00308      next_event_offset = -1;
00309     ERROR(ERR_FILE);
00310   }
00311 
00312   ret = read(fd,bank,8);
00313   if(ret < 0) {
00314     next_event_offset = -1;
00315     ERROR(ERR_FILE);
00316   }
00317 
00318   ret = lseek(fd, offset, SEEK_SET); // set pointer back to top of bank
00319   if(ret < 0) ERROR(ERR_FILE);
00320   //  printf("%s::%d  offset=0x%x  BANK %s\n",__FILE__,__LINE__,offset,bank);
00321 
00322   Bank_RICP lr;
00323   
00324   if (strncmp(bank,"RICP", 4) == 0) {
00325     // read the logical record
00326     ret = read(fd,&lr,sizeof(lr));
00327     if(ret < 0) ERROR(ERR_FILE);
00328     ret = lseek(fd, offset, SEEK_SET); // set pointer back to top of bank
00329     if(ret < 0) ERROR(ERR_FILE);
00330     c_offset += sizeof(lr);
00331     if (!lr.test_CRC()) ERROR(ERR_CRC);
00332     if (lr.swap() < 0) ERROR(ERR_SWAP);
00333     lr.header.CRC = 0;
00334     
00335     
00336     // get event length
00337     DATAPEVENTLENGTH = lr.Reserved[0].off;   // Hack for event len
00338     // save run number
00339     runnum = 0;
00340     next_event_offset = offset+lr.Reserved[0].off * 4;
00341     
00342   
00343     // check that the file contains the entire event
00344     struct stat statbuf;
00345     if(fstat(fd, &statbuf) < 0) ERROR(ERR_FILE);
00346     
00347     DATAP = (char *)malloc(DATAPEVENTLENGTH * 4);
00348     if(!DATAP) ERROR(ERR_MEM);
00349     
00350     ret = read(fd, DATAP, DATAPEVENTLENGTH*4);
00351     if(ret < 0) ERROR(ERR_FILE);
00352     // check CRC, swap
00353     if (!((Bank_RICP *)DATAP)->test_CRC()) ERROR(ERR_CRC);
00354     if (((Bank_RICP *)DATAP)->swap() < 0) ERROR(ERR_SWAP);
00355     
00356     event_size = DATAPEVENTLENGTH;
00357     
00358   }
00359   if (lr.header.Token==0){ // hack
00360     next_event_offset = -1;
00361     printf("hack: do not know how to deal with token==0\n");
00362     free(DATAP); 
00363     DATAP = NULL;
00364   } 
00365   printf("======= Event number: %d  size %d============\n",lr.header.Token, DATAPEVENTLENGTH);
00366   
00367 }
00368 
00369 RichEventReader::~RichEventReader()
00370 {
00371   //  cout << "Destroying event reader" << endl;
00372 
00373   if(fd == -1)              // Pointer construction ... their data
00374   {
00375     // Nothing needs done
00376   }
00377   else if(MMAPP != NULL)    // Memory Mapped file
00378   {
00379     // Unmap memory
00380     //    if (verbose) printf("0x%x  of size 0x%x\n",MMAPP,event_size);
00381     munmap(MMAPP,event_size); //unmap 
00382   }
00383   else                      // file buffer
00384   {
00385     // free my malloc
00386     free(DATAP);
00387   }
00388   if (logfd!=NULL) fclose(logfd);
00389 }
00390 
00391 EventInfo RichEventReader::getEventInfo()
00392 {
00393   //cout << "Getting event info" << endl;
00394   EventInfo ei;
00395   Bank_RICP *dp = (Bank_RICP *)DATAP; 
00396   ei.EventLength = dp->Reserved[0].off;
00397   ei.EventSeqNo = dp->header.Token;
00398   ei.RICHPresent = (0x80);
00399   return ei;
00400 }
00401 
00402 void RichEventReader::printEventInfo(FILE * fd)
00403 {
00404   EventInfo ei = getEventInfo();
00405   // ei.printEventInfo(fd);
00406 }
00407 
00408 long RichEventReader::NextEventOffset()
00409 {
00410   return next_event_offset;
00411 }
00412 
00413 int RichEventReader::MemUsed()
00414 {
00415   return event_size;
00416 }
00417 
00418 void RichEventReader::setVerbose(int v)
00419 {
00420   verbose = v;
00421 }
00422 
00423 char * RichEventReader::findBank(char *bankid)
00424 {
00425   // Fix up DATAP
00426   Bank_RICP *pBankDATAP = (Bank_RICP *)this->getDATAP();
00427   return (char *)pBankDATAP;
00428   
00429 }
00430 
00431 void RichEventReader::fprintError(int err, char *file, int line, char *userstring)
00432 {
00433   if (logfd==NULL) return; //no file designated
00434   if (err<0 || err>MX_MESSAGE) return; //protect against bad error code
00435   fprintf(logfd,"%s  %s::%d   %s\n",err_string[err-1],file,line,userstring);
00436   fflush(logfd);
00437 }