G4Timer.cc File Reference

#include "G4Timer.hh"
#include "G4ios.hh"
#include <iomanip>
#include "G4ExceptionSeverity.hh"

Go to the source code of this file.

Functions
void	G4Exception (const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
std::ostream &	operator<< (std::ostream &os, const G4Timer &t)

Function Documentation

G4Exception()

void G4Exception	(	const char *	originOfException,
		const char *	exceptionCode,
		G4ExceptionSeverity	severity,
		const char *	comments
	)

Definition at line 35 of file G4Exception.cc.

{
  G4VExceptionHandler* exceptionHandler =
    G4StateManager::GetStateManager()->GetExceptionHandler();
  G4bool toBeAborted = true;
  if(exceptionHandler != nullptr)
  {
    toBeAborted = exceptionHandler->Notify(originOfException, exceptionCode,
                                           severity, description);
  }
  else
  {
    static const G4String& es_banner = G4ExceptionErrBannerStart();
    static const G4String& ee_banner = G4ExceptionErrBannerEnd();
    static const G4String& ws_banner = G4ExceptionWarnBannerStart();
    static const G4String& we_banner = G4ExceptionWarnBannerEnd();
    std::ostringstream message;
    message << "\n*** ExceptionHandler is not defined ***\n"
            << "*** G4Exception : " << exceptionCode << G4endl
            << "      issued by : " << originOfException << G4endl
            << description << G4endl;
    switch(severity)
    {
      case FatalException:
        G4cerr << es_banner << message.str() << "*** Fatal Exception ***"
               << ee_banner << G4endl;
        break;
      case FatalErrorInArgument:
        G4cerr << es_banner << message.str()
               << "*** Fatal Error In Argument ***" << ee_banner << G4endl;
        break;
      case RunMustBeAborted:
        G4cerr << es_banner << message.str() << "*** Run Must Be Aborted ***"
               << ee_banner << G4endl;
        break;
      case EventMustBeAborted:
        G4cerr << es_banner << message.str() << "*** Event Must Be Aborted ***"
               << ee_banner << G4endl;
        break;
      default:
        G4cout << ws_banner << message.str()
               << "*** This is just a warning message. ***" << we_banner
               << G4endl;
        toBeAborted = false;
        break;
    }
  }
  if(toBeAborted)
  {
    if(G4StateManager::GetStateManager()->SetNewState(G4State_Abort))
    {
      G4cerr << G4endl << "*** G4Exception: Aborting execution ***" << G4endl;
      abort();
    }
    else
    {
      G4cerr << G4endl << "*** G4Exception: Abortion suppressed ***" << G4endl
             << "*** No guarantee for further execution ***" << G4endl;
    }
  }
}

Referenced by G4Exception().

operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		const G4Timer &	t
	)

Definition at line 88 of file G4Timer.cc.

{
  // so fixed doesn't propagate
  std::stringstream ss;
  ss << std::fixed;
  if(t.IsValid())
  {
    ss << "User=" << t.GetUserElapsed() << "s Real=" << t.GetRealElapsed()
       << "s Sys=" << t.GetSystemElapsed() << "s";
#ifdef G4MULTITHREADED
    // avoid possible FPE error
    if(t.GetRealElapsed() > 1.0e-6)
    {
      G4double cpu_util = (t.GetUserElapsed() + t.GetSystemElapsed()) /
                          t.GetRealElapsed() * 100.0;
      ss << std::setprecision(1);
      ss << " [Cpu=" << std::setprecision(1) << cpu_util << "%]";
    }
#endif
  }
  else
  {
    ss << "User=****s Real=****s Sys=****s";
  }
  os << ss.str();
 
  return os;
}