#include <EPStates.h>

Inheritance diagram for statemachine::HandleLumis:

Classes
class	LumiID

Public Types
typedef sc::transition< Run, NewRun, HandleRuns,&HandleRuns::finalizeRun >	reactions

Public Member Functions
bool	checkInvariant ()

LumiID const &	currentLumi () const

bool	currentLumiEmpty () const

void	exit ()

void	finalizeLumi ()

	HandleLumis (my_context ctx)

void	markLumiNonEmpty ()

void	setupCurrentLumi ()

	~HandleLumis ()

Private Attributes
LumiID	currentLumi_

bool	currentLumiEmpty_

edm::IEventProcessor &	ep_

bool	exitCalled_

bool	lumiException_

Detailed Description

Definition at line 313 of file EPStates.h.

Member Typedef Documentation

typedef sc::transition<Run, NewRun, HandleRuns, &HandleRuns::finalizeRun> statemachine::HandleLumis::reactions

Definition at line 339 of file EPStates.h.

Constructor & Destructor Documentation

statemachine::HandleLumis::HandleLumis ( my_context ctx )

Definition at line 437 of file EPStates.cc.

References checkInvariant().

                                          :
     my_base(ctx),
     ep_(context<Machine>().ep()),
     exitCalled_(false),
     currentLumiEmpty_(true),
     currentLumi_(InvalidLumiID),
     lumiException_(false)
   { 
     checkInvariant();
   }

statemachine::HandleLumis::~HandleLumis ( )

Definition at line 457 of file EPStates.cc.

References checkInvariant(), ep_, cmsCodeRules.cppFunctionSkipper::exception, exitCalled_, cms::Exception::explainSelf(), finalizeLumi(), lumiException_, argparse::message, runTheMatrix::msg, and edm::IEventProcessor::setExceptionMessageLumis().

                             {
     if (!exitCalled_) {
       try {
         checkInvariant();
         if (!lumiException_ && !context<HandleRuns>().runException()) {
           finalizeLumi();
         }
       }
       catch (cms::Exception& e) {
         std::ostringstream message;
         message << "------------------------------------------------------------\n"
                 << "Another exception was caught while trying to clean up lumis after\n" 
                 << "the primary exception.  We give up trying to clean up lumis at\n"
                 << "this point.  The description of this additional exception follows:\n" 
                 << "cms::Exception\n"
                 << e.explainSelf();
         std::string msg(message.str());
         ep_.setExceptionMessageLumis(msg);
       }
       catch (std::bad_alloc& e) {
         std::ostringstream message;
         message << "------------------------------------------------------------\n"
                 << "Another exception was caught while trying to clean up lumis\n" 
                 << "after the primary exception.  We give up trying to clean up lumis\n"
                 << "at this point.  This additional exception was a\n" 
                 << "std::bad_alloc exception thrown inside HandleLumis::finalizeLumi.\n"
                 << "The job has probably exhausted the virtual memory available\n"
                 << "to the process.\n";
         std::string msg(message.str());
         ep_.setExceptionMessageLumis(msg);
       }
       catch (std::exception& e) {
         std::ostringstream message;
         message << "------------------------------------------------------------\n"
                 << "Another exception was caught while trying to clean up lumis after\n" 
                 << "the primary exception.  We give up trying to clean up lumis at\n"
                 << "this point.  This additional exception was a\n" 
                 << "standard library exception thrown inside HandleLumis::finalizeLumi\n"
                 << e.what() << "\n";
         std::string msg(message.str());
         ep_.setExceptionMessageLumis(msg);
       }
       catch (...) {
         std::ostringstream message;
         message << "------------------------------------------------------------\n"
                 << "Another exception was caught while trying to clean up lumis after\n" 
                 << "the primary exception.  We give up trying to clean up lumis at\n"
                 << "this point.  This additional exception was of unknown type and\n" 
                 << "thrown inside HandleLumis::finalizeLumi\n";
         std::string msg(message.str());
         ep_.setExceptionMessageLumis(msg);
       }
     }
   }

Member Function Documentation

bool statemachine::HandleLumis::checkInvariant ( )

Definition at line 512 of file EPStates.cc.

Referenced by exit(), HandleLumis(), and ~HandleLumis().

                                    {
     assert(context<HandleRuns>().currentRun() != INVALID_RUN);
     return true;
   }

HandleLumis::LumiID const & statemachine::HandleLumis::currentLumi ( ) const

Definition at line 517 of file EPStates.cc.

References currentLumi_.

Referenced by finalizeLumi(), markLumiNonEmpty(), and setupCurrentLumi().

517 { return currentLumi_; }

statemachine::HandleLumis::currentLumi_

LumiID currentLumi_

Definition: EPStates.h:345

bool statemachine::HandleLumis::currentLumiEmpty ( ) const

Definition at line 519 of file EPStates.cc.

References currentLumiEmpty_.

519 { return currentLumiEmpty_; }

statemachine::HandleLumis::currentLumiEmpty_

bool currentLumiEmpty_

Definition: EPStates.h:344

void statemachine::HandleLumis::exit ( )

Definition at line 448 of file EPStates.cc.

References edm::IEventProcessor::alreadyHandlingException(), checkInvariant(), ep_, exitCalled_, finalizeLumi(), and lumiException_.

Referenced by argparse.ArgumentParser::error().

                          {
     if (ep_.alreadyHandlingException()) return;
     exitCalled_ = true;
     checkInvariant();
     if (!lumiException_ && !context<HandleRuns>().runException()) {
       finalizeLumi();
     }
   }

void statemachine::HandleLumis::finalizeLumi ( )

Definition at line 538 of file EPStates.cc.

References currentLumi(), currentLumi_, currentLumiEmpty_, edm::IEventProcessor::deleteLumiFromCache(), edm::IEventProcessor::endLumi(), ep_, statemachine::handleEmptyRunsAndLumis, fjr2json::lumi, lumiException_, DTTTrigCorrFirst::run, and edm::IEventProcessor::writeLumi().

Referenced by exit(), and ~HandleLumis().

                                  {
 
     lumiException_ = true;
 
     if (!currentLumiEmpty_ ||
         context<Machine>().emptyRunLumiMode() == handleEmptyRunsAndLumis) {
       ep_.endLumi(currentLumi().processHistoryID(), currentLumi().run(), currentLumi().lumi());
     }
 
     ep_.writeLumi(currentLumi().processHistoryID(), currentLumi().run(), currentLumi().lumi());
     ep_.deleteLumiFromCache(currentLumi().processHistoryID(), currentLumi().run(), currentLumi().lumi());
     currentLumi_ = InvalidLumiID;
 
     lumiException_ = false;
   }

void statemachine::HandleLumis::markLumiNonEmpty ( )

Definition at line 554 of file EPStates.cc.

References edm::IEventProcessor::beginLumi(), currentLumi(), currentLumiEmpty_, ep_, statemachine::handleEmptyRunsAndLumis, fjr2json::lumi, lumiException_, and DTTTrigCorrFirst::run.

                                      {
     if (currentLumiEmpty_) {
 
       if (context<Machine>().emptyRunLumiMode() != handleEmptyRunsAndLumis) {
         lumiException_ = true;
         ep_.beginLumi(currentLumi().processHistoryID(), currentLumi().run(), currentLumi().lumi());
         lumiException_ = false;
       }
       currentLumiEmpty_ = false;
     }
   }

void statemachine::HandleLumis::setupCurrentLumi ( )

Definition at line 521 of file EPStates.cc.

References edm::IEventProcessor::beginLumi(), currentLumi(), currentLumi_, currentLumiEmpty_, ep_, statemachine::handleEmptyRunsAndLumis, fjr2json::lumi, lumiException_, statemachine::Run::processHistoryID(), edm::IEventProcessor::readAndCacheLumi(), DTTTrigCorrFirst::run, and statemachine::Run::runNumber().

                                      {
 
     Run const& run = context<HandleRuns>().currentRun();
     assert (run != INVALID_RUN);
     lumiException_ = true;
     currentLumi_ = HandleLumis::LumiID(run.processHistoryID(), run.runNumber(), ep_.readAndCacheLumi());
 
     if (context<Machine>().emptyRunLumiMode() == handleEmptyRunsAndLumis) {
       assert(context<HandleRuns>().beginRunCalled());
       ep_.beginLumi(currentLumi().processHistoryID(), currentLumi().run(), currentLumi().lumi());
     }
 
     lumiException_ = false;
 
     currentLumiEmpty_ = true;
   }