Back to index

CEventManager.C

 
//----------------------------------------------------------------------------- 
//  $Header: /nfs/ceres1/asis/offline/ceres/cool/project/RCS/CEventManager.C,v 2.2 1997/01/04 16:34:08 messer Exp $ 
// 
//  COOL Program Library   
//  Copyright (C) CERES collaboration, 1996 
// 
//  Implementation of class CEventManager. 
// 
//----------------------------------------------------------------------------- 
#include "CEventManager.h"  
#include <unistd.h> 
#include <iomanip.h> 
#include <stdlib.h> 
 
#ifdef CS_2 
#include <sys/filio.h>  // optimisation on CS-2 
#include <sys/asynch.h> //   ... 
#include <nfs/nfsio.h>  //   ... end. 
#endif 
 
 
CEventManager::CEventManager()  
{ 
  for (int i=0; i<maxOfstreamNumber; i++) { 
    outputEvtCounter[i]	= 0; 
    outputSoBCounter[i]	= 0; 
    outputEoBCounter[i]	= 0; 
    outputSoRCounter[i]	= 0; 
    outputEoRCounter[i]	= 0; 
    outputOoBCounter[i]	= 0; 
  } 
  nextOfstreamNumber    = 0; 
} 
 
CEventManager::CEventManager(const char* inFile, const char* outFile) : CEventServer(inFile) 
{ 
  for (int i=0; i<maxOfstreamNumber; i++) { 
    outputEvtCounter[i]	= 0; 
    outputSoBCounter[i]	= 0; 
    outputEoBCounter[i]	= 0; 
    outputSoRCounter[i]	= 0; 
    outputEoRCounter[i]	= 0; 
    outputOoBCounter[i]	= 0; 
  } 
 
  nextOfstreamNumber    = 0; 
  setOutput(outFile); 
} 
 
 
CEventManager::~CEventManager()  
{ 
  for (int i=0; i<maxOfstreamNumber; i++) { 
    ofs[i].close(); 
  } 
} 
 
 
CEventManager::CEventManager(const CEventManager &)  
{ 
   cerr << "CEventManager::CEventManager(const CEventManager&):\n"; 
   cerr << "\tFATAL ERROR\n"; 
   cerr << "\tCopy constructor for class CEventManager is not implemented.\n"; 
   cerr << "\tStopping current application to prevent unpredictable results.\n"; 
   exit(1); 
} 
 
 
CEventManager & CEventManager::operator = (const CEventManager &)  
{ 
   cerr << "CEventManager::operator= (const CEventManager&):\n"; 
   cerr << "\tFATAL ERROR\n"; 
   cerr << "\tAssignement operator for class CEventManager is not implemented.\n"; 
   cerr << "\tStopping current application to prevent unpredictable results.\n"; 
   exit(1); 
   return *this; 
} 
 
 
int CEventManager::setOutput(const char* name)  
{ 
  if (nextOfstreamNumber >= maxOfstreamNumber) { 
    cerr << "CEventManager::setOutput():\n"; 
    cerr << "\tFATAL ERROR\n"; 
    cerr << "\tno more space for new Cofstream. \n"; 
    cerr << "\taborting to prevent unpredictable results." << endl; 
    abort(); 
  } 
   // 
   //  Reset counter 
   // 
   outputEvtCounter[nextOfstreamNumber]	= 0; 
   outputSoBCounter[nextOfstreamNumber]	= 0; 
   outputEoBCounter[nextOfstreamNumber]	= 0; 
   outputSoRCounter[nextOfstreamNumber]	= 0; 
   outputEoRCounter[nextOfstreamNumber]	= 0; 
   outputOoBCounter[nextOfstreamNumber]	= 0; 
    
   // 
   //  Open output stream, close old stream (if any) 
   // 
 
   outputFilename[nextOfstreamNumber] = name; 
 
   ofs[nextOfstreamNumber].open(name); 
    
   // 
   //  Check status 
   // 
   if (!ofs[nextOfstreamNumber]) { 
      cerr << "CEventManager::CEventManager():\n"; 
      cerr << "\tERROR\n"; 
      cerr << "\tFailed to open file '" << name << "'.\n"; 
      cerr << "\tofs.rdstate()=" << dec << ofs[nextOfstreamNumber].rdstate() << endl; 
      cerr << "\tNo valid ouput source connected to manager.\n"; 
      filename = ""; 
   } 
   return nextOfstreamNumber++; 
} 
 
 
CBoolean CEventManager::writeCurrentEvent(int id) 
{ 
   if (!currentEvent || !ofs[id]) return False; 
    
   if (ofs[id].bad()) { 
      cerr << "CEventManager::writeCurrentEvent():\n"; 
      cerr << "\tERROR\n"; 
      cerr << "\tBad bit set for file stream '" << filename << "'.\n"; 
      cerr << "\tCannot store current event."; 
      return False; 
   } 
  
   currentEvent->writeEvent(ofs[id]); 
   switch (getCurrentEventType()) { 
      case Evt: 
	 outputEvtCounter[id]++; 
	 break; 
      case EoB: 
	 outputEoBCounter[id]++; 
	 break; 
      case SoB: 
	 outputSoBCounter[id]++; 
	 break; 
      case EoR: 
	 outputEoRCounter[id]++; 
	 break; 
      case SoR: 
	 outputSoRCounter[id]++; 
	 break; 
      case OoB: 
	 outputOoBCounter[id]++; 
	 break; 
      default: 
	 break; 
   } 
    
   ofs[id].flush();		// flush buffer to keep last event.... 
       
   if (ofs[id].bad()) { 
      cerr << "CEventManager::writeCurrentEvent():\n"; 
      cerr << "\tERROR\n"; 
      cerr << "\tBad bit set after write to file stream '" << filename << "'.\n"; 
      cerr << "\tData from current event not completely stored on file."; 
      return False; 
   }    
   return True; 
} 
 
 
void CEventManager::printSummary(ostream& ost) 
{ 
   int total = evtCounter+sobCounter+eobCounter+ 
               sorCounter+eorCounter+oobCounter; 
   ost << "\nEvent Manager Summary\n"; 
   CString line('=', 46); 
   ost << line << endl;  
   ost << "Input:                " << endl; 
   ost << "Open file:            " << outputFilename << endl; 
   ost << "File offset:          " << ifs.tellg() << endl; 
   ost << "Total events read:    " << dec << total << endl; 
   ost << "Evt events read:      " << dec << evtCounter << endl; 
   ost << "SoB events read:      " << dec << sobCounter << endl; 
   ost << "EoB events read:      " << dec << eobCounter << endl; 
   ost << "SoR events read:      " << dec << sorCounter << endl; 
   ost << "EoR events read:      " << dec << eorCounter << endl; 
   ost << "OoB events read:      " << dec << oobCounter << endl; 
   ost << "Stream error state:   " << ifs.rdstate() << endl; 
 
   for (int i=0; i<nextOfstreamNumber; i++) { 
     total = outputEvtCounter[i]+outputSoBCounter[i]+outputEoBCounter[i]+ 
       outputSoRCounter[i]+outputEoRCounter[i]+outputOoBCounter[i]; 
     ost << "Output:               " << endl; 
     ost << "Open file:            " << outputFilename << endl; 
     ost << "File offset:          " << ofs[i].tellp() << endl; 
     ost << "Total events written: " << dec << total << endl; 
     ost << "Evt events written:   " << dec << outputEvtCounter[i] << endl; 
     ost << "SoB events written:   " << dec << outputSoBCounter[i] << endl; 
     ost << "EoB events written:   " << dec << outputEoBCounter[i] << endl; 
     ost << "SoR events written:   " << dec << outputSoRCounter[i] << endl; 
     ost << "EoR events written:   " << dec << outputEoRCounter[i] << endl; 
     ost << "OoB events written:   " << dec << outputOoBCounter[i] << endl; 
     ost << "Stream error state:   " << ofs[i].rdstate() << endl; 
   } 
} 
 

Back to index