---

AlephEpioExManager.cpp

Go to the documentation of this file.

//
//  Implementation of class AlephEpioExManager
//
//  Author : G. Dissertori  ,  30.08.2000
//

#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <string>
#include "mt19937-1.h"
#include "AlephExManager.h"
#include "AlephEpioExManager.h"
#include "AlephDbManager.h"
#include "AlephIoManager.h"
#include "AlephCardsReader.h"
#include "AlephInteractiveHandler.h"
#include "DefaultInteractiveActions.h"
#include "AlephRegisteredAction.h"

extern ofstream fout;

//
// the constructor
//
AlephEpioExManager::AlephEpioExManager()
{
  // call the constructor of the base class
  AlephManagerSetup("EpioExManager");
  fout << " An AlephEpioExManager has been created " << endl;
}

//
// the destructor
//
AlephEpioExManager::~AlephEpioExManager() {}

//
// the initialization step
//
AlephRC AlephEpioExManager::initialize()
{
  // get debug level
  int debug = (AlephSession::TheAlephSession())->debugLevel();
  // say something
  fout << " AlephEpioExManager :  initializing .... " << endl;
  fout << " AlephEpioExManager :  Setting random generator seed to ";
  // first check is the IoManager is there 
  AlephManager* ioManager = (AlephSession::TheAlephSession())->aAlephManager("IoManager");
  unsigned long theseed = 1;
  if (ioManager != NULL)
    {
      AlephStatus ioManStatus = ioManager->status();
      if (ioManStatus == INITIALIZED)
       {
        // get the SEED card (if not, there is an unknown value)
        theseed = (((AlephIoManager*)ioManager)->theCardsReader()).getSeed();
       }
    }
  fout << theseed << endl;
  sgenrand(theseed);
  // initialize alpha and bos
  BOS_INITIALIZE();
  if (debug >= 0) 
  {
    fout << endl;
    fout << " C bos_initialize CALLED ******* "<< endl;  
    fout << endl;
  }
  // initialisation of default interactive functions
  AlephRegisteredAction<GeneralEventInfo> code100;
  AlephRegisteredAction<CollectTracks> code200;
  AlephRegisteredAction<CollectLeptons> code300;
  AlephRegisteredAction<CollectJets> code400;
  // User Initialization
  fout << " AlephEpioExManager :  calling user init " << endl;
  UserInit();
  return AlephOK;
}

//
// the termination step
//
AlephRC AlephEpioExManager::terminate()
{
  // say something
  fout << " AlephEpioExManager :  terminating .... " << endl;
  fout << " AlephEpioExManager :  calling user term " << endl;
  UserTerm();
  // This is here to close alpha and  to write out the histograms (if there have been created any)
  CLOSE_RUN();
  // set the status
  setStatus(TERMINATED); 
  return AlephOK;
}

//
// the running step
//
AlephRC AlephEpioExManager::run()
{
  // check first if the database manager is up
  AlephManager* dbManager = (AlephSession::TheAlephSession())->aAlephManager("DbManager");
  if (dbManager == NULL)
    {
      fout << " FATAL : AlephEpioExManager : there is NO DbManager !! " << endl;
      return AlephERROR;
    }
  else
    {
      // check if it is initialized
      AlephStatus dbManStatus = dbManager->status();
      if (dbManStatus != INITIALIZED) dbManager->initialize(); 
      // check the session type
      string sessionTy = (AlephSession::TheAlephSession())->sessionType();
      // if it is batch, call the loop function
      fout << " The session type is " << sessionTy << endl;
      if (sessionTy == "BATCH") 
        {
          AlephRC  loopRC = loopAll();
          return loopRC;
        }
      else // else do interactive stuff
      if (sessionTy  == "INTER")
        {
          // call next user request
          AlephRC  loopRC = loopInter();
          return loopRC;
        }
      else  // do nothing
        {
          fout << "  FATAL : AlephEpioExManager : do not know this session Type !! " << endl;
          return AlephERROR;
        }
    }
}

// batch loop
AlephRC AlephEpioExManager::loopAll()
{
  // check if user wants a reading or writing transaction
  // get it from the cards
  // first check if the IoManager is there
  AlephManager* ioManager = (AlephSession::TheAlephSession())->aAlephManager("IoManager");
  if (ioManager == NULL) 
    {
      fout << "  FATAL : AlephEpioExManager : there is no IoManager !! " << endl;
      return AlephERROR;
    }
  else
    {
      AlephStatus ioManStatus = ioManager->status();    
      if (ioManStatus != INITIALIZED) ioManager->initialize(); 
      // get the TATY card
      string transType = (((AlephIoManager*)ioManager)->theCardsReader()).getTaType();
      if (transType == "write")
        {         
          return loopAllWrite();
        }
      else
        {
          return loopAllRead();
        }
    }
}

// batch reading loop
AlephRC AlephEpioExManager::loopAllRead()
{
  // for epio reading we just use default dbmanager
  AlephDbManager* epioMan = theDbm();
  // get the cards Reader
  AlephCardsReader& cardsReader = theIom()->theCardsReader();
  // start a read transaction if not already done
  // HTLs are needed, than start a writing transaction
  epioMan->startTransaction(READING);
  // get the debug level
  int debug = (AlephSession::TheAlephSession())->debugLevel();
// main event loop
  int krun,kevt,ier1;
  EventCount = 0;
  do {
    READ_EVENT(krun,kevt,ier1);
    if (ier1 != 0) break;
    // set current Run and event numbers
    setCurrentRunEvt(krun,kevt);    
    EventCount++;
    if (debug >= 2) {
      fout << endl;
      fout << "*************************************************" << endl;
      fout << "** Run # " << krun << " , Evt # " << kevt << "  --> " << endl;
      fout << "*************************************************" << endl;
    }
    // prepare AlphaBanks for analysis
    AlphaBanks bb(AlphaBanks::BOS);
    bb.InitObjectStructure();
    if(!bb.isValid())
            fout << " AlephEpioExManager : inconsistency in event. Skipped " << endl;
    else
            UserEvent(bb);
    // some status report
    if (! (EventCount % 1000))
      {
        fout << endl;
        fout << "******* " << EventCount << 
                " events read " << endl;
        fout << "******* current Run # = " << krun << endl;
        fout << "******* current Evt # = " << kevt << endl;
        fout << endl;
      }
// end main event loop
  } while (ier1 == 0);
  fout << endl;
  fout << " *** " << EventCount << " Events have been read" << endl;
  fout << endl;
  // stop the transaction
  AlephRC stopRC = epioMan->stopTransaction();
  if (debug >= 0)
  {
    fout << endl;
    fout << " ****** AlephEpioExManager::loopAllRead : transaction stopped ****** " << endl;
    fout << endl;
  }
  return stopRC;
}
 
// batch writing loop
AlephRC AlephEpioExManager::loopAllWrite()
{
  // for epio reading we just use default dbmanager
  AlephDbManager* epioMan = theDbm();
  // get the cards Reader
  AlephCardsReader& cardsReader = theIom()->theCardsReader();
  // start a read transaction 
  epioMan->startTransaction(READING);
  // get the debug level
  int debug = (AlephSession::TheAlephSession())->debugLevel();
// main event loop
  int krun,kevt,ier1;
  EventCount = 0;
  AlephManager* dbManager = (AlephSession::TheAlephSession())->aAlephManager("DbManager");
  do {
    READ_EVENT(krun,kevt,ier1);
    if (ier1 != 0) break;
    // set current Run and event numbers
    setCurrentRunEvt(krun,kevt);    
    EventCount++;
    if (debug >= 2) {
      fout << endl;
      fout << "*************************************************" << endl;
      fout << "** Run # " << krun << " , Evt # " << kevt << "  --> " << endl;
      fout << "*************************************************" << endl;
    }
    // read the event from the BOS
    AlphaBanks bb(AlphaBanks::BOS);
    bb.InitObjectStructure();
    // the AlphaBanks will now be made persistant.
    ((AlephDbManager*)dbManager)->StoreEvent(&bb);
    // some status report
    if (! (EventCount % 1000))
      {
        fout << endl;
        fout << "******* " << EventCount << 
                " events read " << endl;
        fout << "******* current Run # = " << krun << endl;
        fout << "******* current Evt # = " << kevt << endl;
        fout << endl;
      }
// end main event loop
  } while (ier1 == 0);
  fout << endl;
  fout << " *** " << EventCount << " Events have been read and written to file." << endl;
  fout << endl;
  // stop the transaction
  AlephRC stopRC = epioMan->stopTransaction();
  if (debug >= 0)
  {
    fout << endl;
    fout << " ****** AlephEpioExManager::loopAllRead : transaction stopped ****** " << endl;
    fout << endl;
  }
  return stopRC;
}

// interactive loop
AlephRC AlephEpioExManager::loopInter()
{
  // check if user wants a reading or writing transaction
  // get it from the cards
  // first check if the IoManager is there
  AlephManager* ioManager = (AlephSession::TheAlephSession())->aAlephManager("IoManager");
  if (ioManager == NULL) 
    {
      fout << "  FATAL : AlephEpioExManager : there is no IoManager !! " << endl;
      return AlephERROR;
    }
  else
    {
      AlephStatus ioManStatus = ioManager->status();    
      if (ioManStatus != INITIALIZED) ioManager->initialize(); 
      // get the TATY card
      string transType = (((AlephIoManager*)ioManager)->theCardsReader()).getTaType();
      if (transType == "write")
        {         
          return loopInterWrite();
        }
      else
        {
          return loopInterRead();
        }
    }
}

// interactive reading loop
AlephRC AlephEpioExManager::loopInterRead()
{
  // for epio reading we just use default dbmanager
  AlephDbManager* epioMan = theDbm();
  // get the cards Reader
  AlephCardsReader& cardsReader = theIom()->theCardsReader();
  // start a read transaction if not already done
  // HTLs are needed, than start a writing transaction
  epioMan->startTransaction(READING);
  // get the debug level
  int debug = (AlephSession::TheAlephSession())->debugLevel();
  // instanciate the AlephInteractiveHandler
  AlephInteractiveHandler* Handler = AlephInteractiveHandler::TheAlephInteractiveHandler();
  int ier1=0;
  Handler->InitiateConnection(ier1);
// main event loop
  int krun,kevt;
  EventCount = 0;
  while(!ier1)
  {
    READ_EVENT(krun,kevt,ier1);
    if (ier1 != 0) break;
    // set current Run and event numbers
    setCurrentRunEvt(krun,kevt);    
    EventCount++;
    if (debug >= 2) {
      fout << endl;
      fout << "*************************************************" << endl;
      fout << "** Run # " << krun << " , Evt # " << kevt << "  --> " << endl;
      fout << "*************************************************" << endl;
    }
    // prepare AlphaBanks for analysis
    AlphaBanks bb(AlphaBanks::BOS);
    bb.InitObjectStructure();
    if(!bb.isValid())
            fout << " AlephEpioExManager : inconsistency in event. Skipped " << endl;
    else
            if(UserEvent(bb)||Handler->KeepAllEvents()) 
            {
                    ier1 = Handler->HandleEvent(bb);
            }
    // some status report
    if (! (EventCount % 1000))
      {
        fout << endl;
        fout << "******* " << EventCount << 
                " events read " << endl;
        fout << "******* current Run # = " << krun << endl;
        fout << "******* current Evt # = " << kevt << endl;
        fout << endl;
      }
// end main event loop
  };
  Handler->CloseConnection();
  fout << endl;
  fout << " *** " << EventCount << " Events have been read" << endl;
  fout << endl;
// stop the transaction
  AlephRC stopRC = epioMan->stopTransaction();
  if (debug >= 0)
  {
    fout << endl;
    fout << " ****** AlephEpioExManager::loopInterRead : transaction stopped ****** " << endl;
    fout << endl;
  }
  return stopRC;
}
 
// interactive writing loop
AlephRC AlephEpioExManager::loopInterWrite()
{
  fout << " in loopInterWrite : doing nothing for the moment ... " << endl;
  return AlephOK;
}

---