Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

GaudiCommon.icpp

Go to the documentation of this file.

// $Id: GaudiCommon.icpp,v 1.20 2008/06/05 12:10:20 marcocle Exp $

// ============================================================================
// CVS tag $Name: v11r1 $ version $Revision: 1.20 $
// ============================================================================
// ============================================================================
// include files
// ============================================================================
// STL & STD
// ============================================================================
#include <algorithm>
#include <cstdlib>
// ============================================================================
/* @file GaudiCommon.cpp
 *
 *  Implementation file for class : GaudiCommon
 *
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @date   2005-08-08
 */
// GaudiKernel
// ============================================================================
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/Property.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/SmartRef.h"
#include "GaudiKernel/Stat.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/IJobOptionsSvc.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/AlgTool.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/Print.h"
#include "GaudiAlg/GaudiCommon.h"
#include "GaudiAlg/GaudiAlgorithm.h"
#include "GaudiAlg/GaudiTool.h"
// ============================================================================
// Boost
// ============================================================================
#include "boost/format.hpp"
#include "boost/lexical_cast.hpp"
// ============================================================================
// Disable warning on windows
#ifdef _WIN32
#pragma warning ( disable:4661 ) // incomplete explicit templates
#endif
// ============================================================================

//=============================================================================
// Destructor
//=============================================================================
template < class PBASE >
GaudiCommon<PBASE>::~GaudiCommon() { resetMsgStream(); }
//==========================================================================

// ============================================================================
// constructor initialisation
// ============================================================================
template <class PBASE>
void
GaudiCommon<PBASE>::initGaudiCommonConstructor( const IInterface * parent )
{
  // initialise data members
  m_msgLevel    = MSG::NIL;
  m_msgStream   = 0;
  m_updMgrSvc   = 0;
  m_fastContainersSvc   = 0;
  m_typePrint   = true;
  m_propsPrint  = false;
  m_statPrint   = true;
  m_errorsPrint = true;
  m_context     = "" ;
  m_rootInTES   = "" ;
  m_globalTimeOffset = 0.0 ;

  // printout of counters:
  
  // the header row for counters printout 
  m_header  = " |    Counter                                      |     #     |    sum     | mean/eff^* | rms/err^*  |     min     |     max     |" ;
  // format for regular statistical printout rows
  m_format1 = " | %|-48.48s|%|50t||%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |" ;
  // format for "efficiency" statistical printout rows
  m_format2 = " |*%|-48.48s|%|50t||%|10d| |%|11.5g| |(%|#9.6g| +- %|-#9.6g|)%%|   -------   |   -------   |" ;
  // flag to use the special "efficiency" format 
  m_useEffFormat = true ; 
  
  
  // job options
  // print error counters at finalization ?
  this->declareProperty ( "ErrorsPrint"     , m_errorsPrint ) ;
  // print properties at initalization?
  this->declareProperty ( "PropertiesPrint" , m_propsPrint  ) ;
  // print statistical counters at finalization ?
  this->declareProperty ( "StatPrint"       , m_statPrint   ) ;
  // insert  the actual C++ type of the algorithm or tool in the messages?
  this->declareProperty ( "TypePrint"       , m_typePrint   ) ;
  // context
  this->declareProperty ( "Context"         , m_context     ) ;
  // root in TES
  this->declareProperty ( "RootInTES"       , m_rootInTES   ) ;
  // root on TES ( temporary )
  this->declareProperty ( "RootOnTES"       , m_rootOnTES   ) ;
  // global time offset
  this->declareProperty ( "GlobalTimeOffset", m_globalTimeOffset ) ;


  // the header row for counters printout 
  this->declareProperty 
    ( "StatTableHeader"        , m_header                          , 
      "The header row for the output Stat-table"                   ) ;
  // format for regular statistical printout rows
  this->declareProperty 
    ( "RegularRowFormat"       , m_format1                         , 
      "The format for the regular row in the output Stat-table"    ) ;
  // format for "efficiency" statistical printout rows
  this->declareProperty 
    ( "EfficiencyRowFormat"    , m_format2                         , 
      "The format for the regular row in the outptu Stat-table"    ) ; 
  // flag to use the special "efficiency" format 
  this->declareProperty 
    ( "UseEfficiencyRowFormat" , m_useEffFormat                    , 
      "Use the special format for printout of efficiency counters" ) ;


  // add handler for message level changes
  this->outputLevelProperty().declareUpdateHandler( &GaudiCommon<PBASE>::msgLevelHandler, this );

  // setup context from parent if available
  if ( parent )
  {
    if      ( const GaudiAlgorithm* gAlg = dynamic_cast<const GaudiAlgorithm*>(parent) )
    {
      m_context = gAlg->context();
      m_rootInTES = gAlg->rootInTES();
      m_globalTimeOffset = gAlg->globalTimeOffset();
    }
    else if ( const GaudiTool*     gTool = dynamic_cast<const GaudiTool*>     (parent) )
    {
      m_context = gTool->context();
      m_rootInTES = gTool->rootInTES();
      m_globalTimeOffset = gTool->globalTimeOffset();
    }
  }

  // Get the job option service
  IJobOptionsSvc* jos = svc<IJobOptionsSvc>( "JobOptionsSvc" );

  // Get the "Context" option if in the file...
  const std::vector<const Property*>* myList = jos->getProperties( this->name() );
  if ( 0 != myList )
  {
    // Iterate over the list to set the options
    for ( std::vector<const Property*>::const_iterator iter = myList->begin();
          iter != myList->end();
          ++iter )
    {
      const StringProperty* sp = dynamic_cast<const StringProperty*>(*iter);
      if ( 0 != sp )
      {
        if ( "Context" == (*iter)->name() )
        {
          m_context = sp->value();
        } else if ( "RootInTES" == (*iter)->name() ) {
          m_rootInTES = sp->value();
        } else if ( "GlobalTimeOffset" == (*iter)->name() ) {
          m_globalTimeOffset = atof( sp->value().c_str() );
        }
      }
    }
  }

  // release tool
  release( jos ).ignore();

}
//=============================================================================

//=============================================================================
// Initialise the common functionality
//=============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::initialize()
{

  // initialize base class
  const StatusCode sc = PBASE::initialize();
  if ( sc.isFailure() )
  { return Error ( "Failed to initialise base class PBASE", sc ) ; }
   

  // some debug printout
  if ( msgLevel(MSG::DEBUG) )
  {
    debug() << "Initialize base class GaudiCommon<PBASE>" << endreq;
    if ( !context().empty() )
      debug() << "Created with context = '" << context() << "'" << endreq;
  }

  // some temporary checks to see if people are using RootOnTES and warn if so
  // TO BE REMOVED ASAP ...
  if ( m_rootInTES.empty() && !m_rootOnTES.empty() )
  {
    m_rootInTES = m_rootOnTES;
    Warning( "RootOnTES option is OBSOLETE -> Use RootInTES instead. RootInTES has been updated to " 
             + m_rootInTES, StatusCode::SUCCESS ).ignore();
  }
  else if ( !m_rootInTES.empty() && !m_rootOnTES.empty() )
  {
    Warning( "Options RootOnTES AND RootInTES are defined ! Use RootInTES. RootOnTES is ignored", 
             StatusCode::SUCCESS ).ignore();
  }

  // Check rootInTES ends with a /
  if ( !m_rootInTES.empty() && 
       m_rootInTES.substr(m_rootInTES.size()-1) != "/" ) m_rootInTES += "/";

  // properties will be printed if asked for or in "MSG::DEBUG" mode
  if      ( propsPrint()         ) { printProps(MSG::ALWAYS); }
  else if ( msgLevel(MSG::DEBUG) ) { printProps(MSG::DEBUG);  }

  return sc;
}
//=============================================================================

//=============================================================================
// Finalize the common functionality
//=============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::finalize()
{
  StatusCode sc = StatusCode::SUCCESS;

  // print the general information about statistical counters
  if ( msgLevel(MSG::DEBUG) || (statPrint() && !counters().empty()) )
  {
    // print general statictical counters
    printStat ( statPrint() ? MSG::ALWAYS : MSG::DEBUG ) ;
  }

  // release all located tools and services
  if ( msgLevel(MSG::DEBUG) )
  {
    debug() << "Tools to release :";
    for ( AlgTools::const_iterator i = m_tools.begin();
          i != m_tools.end(); ++i )
    {
      debug() << " " << (*i)->name();
    }
    debug() << endreq;
  }
  while ( !m_tools.empty() ) { sc = sc && release( m_tools.back() ) ; }

  // release all located services
  if ( msgLevel(MSG::DEBUG) )
  {
    debug() << "Services to release :";
    for ( Services::const_iterator i = m_services.begin();
          i != m_services.end(); ++i )
    {
      debug() << " " << (*i).second;
    }
    debug() << endreq;
  }
  while ( !m_services.empty() ) { sc = sc && release( m_services.back().first ); }

  // format printout
  if ( !m_errors.empty() || !m_warnings.empty() || !m_exceptions.empty() )
  {
    always() << "Exceptions/Errors/Warnings Statistics : "
             << m_exceptions .size () << "/"
             << m_errors     .size () << "/"
             << m_warnings   .size () << endreq ;
    if ( errorsPrint() ) { printErrors () ; }
  }

  // delete the MsgStream
  resetMsgStream();

  // clear *ALL* counters explicitely
  m_counters   .clear() ;
  m_exceptions .clear() ;
  m_warnings   .clear() ;
  m_errors     .clear() ;

  // finalize base class
  return sc && PBASE::finalize();
}
//=============================================================================

//=============================================================================
// Methods related to tools and services
//=============================================================================

// ============================================================================
// manual forced (and 'safe') release of the active tool or service
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::release ( const IInterface* interface ) const
{
  if ( 0 == interface )
  { return Error ( "release(IInterface):: IInterface* points to NULL!" ) ; }
  // dispatch between tools and services
  const IAlgTool* algTool = dynamic_cast<const IAlgTool*>( interface )  ;
  // perform teh actual release
  return 0 != algTool ? releaseTool( algTool ) : releaseSvc( interface ) ;
}
// ============================================================================

// ============================================================================
// manual forced (and 'save') release of the tool
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::releaseTool ( const IAlgTool* algTool ) const
{
  if( 0 == algTool   )
  { return Error ( "releaseTool(IAlgTool):: IAlgTool* points to NULL!" ) ; }
  if( 0 == this->toolSvc() )
  { return Error ( "releaseTool(IAlgTool):: IToolSvc* points to NULL!" ) ; }
  // find a tool in the list of active tools
  AlgTools::reverse_iterator it =
    std::find( m_tools.rbegin() , m_tools.rend() , algTool ) ;
  if(  m_tools.rend() == it )
  { return Warning("releaseTool(IAlgTool):: IAlgTool* is not active"   ) ; }
  // get the tool
  IAlgTool* t = *it ;
  // cache name
  const std::string name = t->name();
  if ( msgLevel(MSG::DEBUG) )
  { debug() << "Releasing tool '" << name << "'" << endreq; }
  // remove the tool from the lists
  m_tools.erase( --it.base() ) ;
  // release tool
  const StatusCode sc = this->toolSvc()->releaseTool( t ) ;
  // Check for more tools of the same name
  while ( (it = std::find(m_tools.rbegin(),m_tools.rend(),algTool)) != m_tools.rend() )
  {
    Warning( "Removing additional reference(s) to '"+name+"' in active tool list",
             StatusCode::SUCCESS, 1 ).ignore();
    m_tools.erase( --it.base() ) ;
  }
  if ( sc.isFailure() )
  { return Warning ( "releaseTool(IAlgTool):: error from IToolSvc whilst releasing "+name , sc ) ; }
  // return final status code
  return sc ;
}
// ============================================================================

// ============================================================================
// manual forced (and 'safe') release of the service
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::releaseSvc ( const IInterface* Svc  ) const
{
  if( 0 == Svc )
  { return Error ( "releaseSvc(IInterface):: IInterface* points to NULL!" ) ; }
  // find a service in the list of active services
  Services::reverse_iterator iS = m_services.rbegin();
  for ( ; iS != m_services.rend(); ++iS ) { if ( (*iS).first == Svc ) break; }
  if ( m_services.rend() == iS )
  { return Warning( "releaseSvc(IInterface):: IInterface* is not active" ) ; }
  // get the service
  IInterface * s = (*iS).first ;
  if ( msgLevel(MSG::DEBUG) )
  { debug() << "Releasing service '" << (*iS).second << "'" << endreq; }
  // remove the service from the list of active services
  m_services.erase( --iS.base() ) ;
  // release the service
  s->release() ;
  // return
  return StatusCode::SUCCESS ;
}
// ============================================================================

// ============================================================================
// Add the given tool to the list of active tools
// ============================================================================
template < class PBASE >
void GaudiCommon<PBASE>::addToToolList( IAlgTool * tool ) const
{
  AlgTools::const_iterator iTool = std::find( m_tools.begin(),
                                              m_tools.end(),
                                              tool );
  if ( iTool != m_tools.end() )
  {
    Warning( "Tool '" + tool->name() + "' already in list of active tools" ).ignore();
  }
  m_tools.push_back( tool ) ;
}
// ============================================================================

// ============================================================================
// Add the given service to the list of active services
// ============================================================================
template < class PBASE >
void GaudiCommon<PBASE>::addToServiceList( IInterface * svc,
                                           const std::string & name ) const
{
  const ServiceEntry sEntry( svc , name );
  Services::const_iterator iSvc = std::find( m_services.begin(),
                                             m_services.end(),
                                             sEntry );
  if ( iSvc != m_services.end() )
  {
    Warning( "Service '" + name + "' already in list of active services" ).ignore();
  }
  m_services.push_back( sEntry ) ;
}
// ============================================================================

//=============================================================================
// Methods related to messaging
//=============================================================================

// ============================================================================
// Print the error  message and return status code
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Error( const std::string& msg ,
                                      const StatusCode   st  ,
                                      const size_t       mx  ) const
{
  // increase local counter of errors
  const size_t num = ++m_errors[msg] ;
  // If suppressed, just return
  if      ( num  > mx ) { return st ; }
  else if ( num == mx ) // issue one-time suppresion message
  { return Print ( "The   ERROR message is suppressed : '" +
                   msg + "'" , st , MSG::ERROR ) ; }
  // return message
  return Print ( msg , st , MSG::ERROR ) ;
}
// ============================================================================

// ============================================================================
// Print the warning  message and return status code
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Warning
( const std::string& msg ,
  const StatusCode   st  ,
  const size_t       mx  ) const
{
  // increase local counter of warnings
  const size_t num = ++m_warnings[msg] ;
  // If suppressed, just return
  if      ( num  > mx ) { return st ; }
  else if ( num == mx ) // issue one-time suppresion message
  { return Print ( "The WARNING message is suppressed : '" +
                   msg + "'" , st , MSG::WARNING ) ; }
  // return message
  return Print ( msg , st , MSG::WARNING ) ;
}
// ============================================================================

// ============================================================================
//  Print the message and return status code
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Print( const std::string& msg ,
                                      const StatusCode   st  ,
                                      const MSG::Level   lvl ) const
{
  // perform printout ?
  if ( !msgLevel( lvl ) ) { return st ; }   // RETURN

  // use the predefined stream
  MsgStream& str = msgStream( lvl ) ;
  if ( typePrint() ) { str << System::typeinfoName(typeid(*this)) << ":: " ; }
  // print the message
  str  << msg ;
  // test status code
  if      ( st.isSuccess() ) { }
  else if ( StatusCode::FAILURE != st.getCode() )
  { str << " StatusCode=" << st.getCode() ; }
  else
  { str << " StatusCode=FAILURE" ; }
  // perform print operation
  str << endreq ;
  // return
  return  st;
}
// ============================================================================

// ============================================================================
// Create and (re)-throw the exception
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Exception( const std::string    & msg ,
                                          const GaudiException & exc ,
                                          const StatusCode       sc  ) const
{
  // increase local counter of exceptions
  ++m_exceptions[ msg ];
  Print ( "Exception (re)throw: " + msg , sc , MSG::FATAL );
  throw   GaudiException( this->name() + ":: " + msg , this->name() , sc, exc);
  return  sc ;
}
// ============================================================================

// ============================================================================
// Create and (re)-throw the exception
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Exception( const std::string    & msg ,
                                          const std::exception & exc ,
                                          const StatusCode       sc  ) const
{
  // increase local counter of exceptions
  ++m_exceptions[ msg ];
  Print ( "Exception (re)throw: " + msg , sc , MSG::FATAL  );
  throw GaudiException( this->name() + ":: " + msg+"("+exc.what()+")", "", sc );
  return  sc ;
}
// ============================================================================

// ============================================================================
// Create and throw the exception
// ============================================================================
template < class PBASE >
StatusCode GaudiCommon<PBASE>::Exception( const std::string    & msg ,
                                          const StatusCode       sc  ) const
{
  // increase local counter of exceptions
  ++m_exceptions[ msg ];
  Print ( "Exception throw: " + msg , sc , MSG::FATAL );
  throw GaudiException( this->name() + ":: " + msg , "",  sc );
  return  sc ;
}
// ============================================================================

// ============================================================================
// perform the actual printout of counters
// ============================================================================
template < class PBASE >
long GaudiCommon<PBASE>::printStat( const MSG::Level level ) const
{
  // print statistics
  if ( counters().empty() ) { return 0 ; }
  MsgStream& msg = msgStream ( level ) ;
  //
  msg << "Number of counters : "  << counters().size() ;
  //
  if ( !counters().empty() ) { msg << std::endl << m_header ; }
  //
  for ( Statistics::const_iterator entry = counters().begin() ;
        counters().end() != entry ; ++entry )
  {
    msg << std::endl 
        << Gaudi::Utils::formatAsTableRow 
      ( entry -> first  , 
        entry -> second , 
        m_useEffFormat  , 
        m_format1       , m_format2 );
  }
  //
  msg << endreq ;
  //
  return counters().size() ;
}
// ============================================================================

// ============================================================================
// perform the actual printout of error counters
// ============================================================================
template < class PBASE >
long GaudiCommon<PBASE>::printErrors ( const MSG::Level level ) const
{
  // format for printout
  boost::format ftm ( " %s = %|.8s| %|23t| Message = '%s'" );

  { // print exceptions
    for ( Counter::const_iterator excp = m_exceptions.begin() ;
          excp  != m_exceptions.end() ; ++excp  )
    {
      msgStream(level)
        << ( ftm % "#EXCEPTIONS" % excp->second % excp->first       )
        << endreq;
    }
  }
  { // print errors
    for ( Counter::const_iterator error = m_errors.begin() ;
          error != m_errors.end() ; ++error )
    {
      msgStream(level)
        << ( ftm % "#ERRORS    " % error->second % error->first     )
        << endreq;
    }
  }
  { // print warnings
    for ( Counter::const_iterator warning = m_warnings.begin() ;
          warning != m_warnings.end() ; ++warning )
    {
      msgStream(level)
        << ( ftm % "#WARNINGS  " % warning->second % warning->first )
        << endreq;
    }
  }

  // return total number of errors+warnings+exceptions
  return
    m_exceptions .size () +
    m_errors     .size () +
    m_warnings   .size () ;
}
// ============================================================================

// ============================================================================
// ============================================================================
template < class PBASE >
long GaudiCommon<PBASE>::printProps ( const MSG::Level level ) const
{

  // print ALL properties
  MsgStream& msg = msgStream ( level );
  typedef std::vector<Property*> Properties;
  const Properties& properties = this->getProperties() ;
  msg << "List of ALL properties of "
      << System::typeinfoName( typeid( *this ) ) << "/" << this->name()
      << "  #properties = " << properties.size() << endreq ;
  for ( Properties::const_reverse_iterator property
          = properties.rbegin() ;
        properties.rend() != property ; ++property )
  {
    msg << "Property ['Name': Value] = "
        << ( **property)
        << endreq ;
  }
  return properties.size() ;
}
// ============================================================================

// ============================================================================
// Handle method for changes in the Messaging levels
// ============================================================================
template < class PBASE >
void GaudiCommon<PBASE>::msgLevelHandler ( Property & theProp )
{
  // Force a new MsgStream object, to pick up the new settings
  resetMsgStream();

  // adjust internal message level
  m_msgLevel =
    this->outputLevel() <  (int) MSG::NIL        ?  MSG::NIL    :
    this->outputLevel() >= (int) MSG::NUM_LEVELS ?  MSG::ALWAYS :
    MSG::Level( this->outputLevel() ) ;

  // Keep MessageSvc up to date if needed
  if ( this->msgSvc()->outputLevel(this->name()) != this->outputLevel() )
  {
    this->msgSvc()->setOutputLevel( this->name(), this->outputLevel() );
  }

  // printout message
  if ( msgLevel(MSG::DEBUG) )
  {
    debug() << "Property update for "
            << theProp.name() << " : new value = " << this->outputLevel() << endreq;
  }
}
// ============================================================================

// ============================================================================
// Methods for dealing with the TES and TDS
// ============================================================================

// ============================================================================
// put results into Gaudi Event Transient Store
// ============================================================================
template < class PBASE >
void GaudiCommon<PBASE>::put ( IDataProviderSvc*  svc     ,
                               DataObject*        object  ,
                               const std::string& location ,
                               const bool useRootInTES ) const
{
  // check arguments
  Assert ( 0 != svc              , "put():: Invalid 'service'!"       ) ;
  Assert ( 0 != object           , "put():: Invalid 'Object'!"        ) ;
  Assert ( !location.empty()     , "put():: Invalid 'address' = '' " ) ;
  // final data location
  const std::string & fullLocation = fullTESLocation( location, useRootInTES );
  // register the object!
  const StatusCode status = '/' == fullLocation[0] ?
    svc -> registerObject(             fullLocation , object ) :
    svc -> registerObject( "/Event/" + fullLocation , object ) ;
  // check the result!
  if ( status.isFailure() )
  { Exception ( "put():: could not register '"            +
                System::typeinfoName( typeid( *object ) ) +
                "' at address '" + fullLocation + "'"  , status ) ; }
  if ( msgLevel( MSG::DEBUG ) )
  { Print( "The object of type '"                    +
           System::typeinfoName( typeid( *object ) ) +
           "' is registered in TS at address '"
           + fullLocation + "'" , status , MSG::DEBUG ) ; }
}
// ============================================================================

---