Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

HistogramPersistencySvc.cpp

Go to the documentation of this file.

// $Id: HistogramPersistencySvc.cpp,v 1.8 2008/05/14 16:33:17 marcocle Exp $ 
// ============================================================================
//      HistogramPersistencySvc.cpp
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: implementation of the Event data persistency service
//               This specialized service only deals with event related 
//               data
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  PERSISTENCYSVC_HISTOGRAMPERSISTENCYSVC_CPP
// ============================================================================
// Include files 
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IJobOptionsSvc.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IRegistry.h"
// ============================================================================
// local
// ============================================================================
#include "HistogramPersistencySvc.h"
// ============================================================================
// AIDA 
// ============================================================================
#include "AIDA/IBaseHistogram.h"
// ============================================================================
// Instantiation of a static factory class used by clients to create
// instances of this service
DECLARE_SERVICE_FACTORY(HistogramPersistencySvc)
// ============================================================================
// Finalize the service.
StatusCode HistogramPersistencySvc::finalize()
{
  //
  MsgStream log ( msgSvc() , name() );
  if ( !(m_convert.empty() && m_exclude.empty()) )
  { // print message if any of the two properties is used
    log << MSG::INFO  << "Histograms Converted/Excluded: " 
        << m_converted.size() << "/" << m_excluded.size() << endreq ;
  }
  //
  if ( !m_excluded.empty() ) 
  {
    log << MSG::DEBUG << "Excluded  Histos : #" << m_excluded.size() ;
    for ( Set::const_iterator item = m_excluded.begin() ; 
          m_excluded.end() != item ; ++item ) 
    { log << std::endl << "  '" << (*item) << "'" ; }
    log << endreq ;
  }
  //
  if ( !m_converted.empty() ) 
  {
    log << MSG::DEBUG << "Converted Histos : #" << m_converted.size() ;
    for ( Set::const_iterator item = m_converted.begin() ; 
          m_converted.end() != item ; ++item ) 
    { log << std::endl << "  '" << (*item) << "'" ; }
    log << endreq ;
  }
  //
  StatusCode status = PersistencySvc::finalize();
  return status;
}
// ============================================================================
// Initialize the service.
// ============================================================================
StatusCode HistogramPersistencySvc::initialize()     {
  StatusCode status = PersistencySvc::initialize();
  if ( status.isSuccess() )   {
    status = reinitialize();
  }
  return status;
}
// ============================================================================
// Reinitialize the service.
// ============================================================================
StatusCode HistogramPersistencySvc::reinitialize()
{
  MsgStream log(msgSvc(), name());
  // Obtain the IProperty of the ApplicationMgr
  SmartIF<IProperty> prpMgr(serviceLocator());
  if ( !prpMgr.isValid() )   {
    log << MSG::FATAL << "IProperty interface not found in ApplicationMgr." << endreq;
    return StatusCode::FAILURE;
  }
  else {
    setProperty(prpMgr->getProperty("HistogramPersistency")).ignore();
  }
  
  // To keep backward compatibility, we set the property of conversion service
  // into JobOptions catalogue
  if( m_outputFile != "" ) {
    IJobOptionsSvc* joptsvc;
    if( serviceLocator()->service("JobOptionsSvc", joptsvc ).isSuccess() ) {
      StringProperty p("OutputFile", m_outputFile);
      if ( m_histPersName == "ROOT" ) {
        joptsvc->addPropertyToCatalogue("RootHistSvc", p).ignore();
      } else if (m_histPersName == "HBOOK" ) {
        joptsvc->addPropertyToCatalogue("HbookHistSvc", p).ignore();
      }
      joptsvc->release();
    }
  }

  // Load the Histogram persistency service that's required as default
  setConversionSvc(0).ignore();
  if ( m_histPersName == "ROOT" ) {
    setConversionSvc(service("RootHistSvc")).ignore();
    if ( !conversionSvc() ) {
      return StatusCode::FAILURE;
    }
    enable(true);
  }
  else if ( m_histPersName == "HBOOK" ) {
    setConversionSvc(service("HbookHistSvc")).ignore();
    if ( !conversionSvc() ) {
      return StatusCode::FAILURE;
    }
    enable(true);
  }
  else if ( m_histPersName == "NONE" ) {
    enable(false);
    log << MSG::WARNING << "Histograms saving not required." << endreq;
  }
  else {
    setConversionSvc(service(m_histPersName)).ignore();
    if ( !conversionSvc() ) {
      return StatusCode::FAILURE;
    }
    enable(true);
    log << MSG::WARNING << "Unknown Histogram Persistency Mechanism " << m_histPersName << endreq;
  }
  return StatusCode::SUCCESS;
}
// ============================================================================
namespace 
{
  // ==========================================================================
  const std::string s_NULL = "<NULL>" ;
  // ==========================================================================
  // ==========================================================================
  inline bool match 
  ( const std::string& name , 
    const std::string& pat  ) 
  {
    // the most primitive match
    return std::string::npos != name.find ( pat );
  }
  // ==========================================================================
  inline const std::string& oname ( const DataObject* obj ) 
  {
    if ( 0 == obj ) { return s_NULL ; }
    const IRegistry* reg = obj->registry() ;
    return ( 0 == reg ) ? obj -> name () : reg -> identifier () ;
  }
  // ==========================================================================  
  inline bool match ( const DataObject*  obj , 
                      const std::string& pat ) 
  {
    if ( 0 == obj ) { return false ; }
    return match ( oname ( obj ) , pat ) ;
  }
  // ==========================================================================
}
// ============================================================================
// Convert the transient object to the requested representation.
// ============================================================================
StatusCode HistogramPersistencySvc::createRep
( DataObject*      pObj     , 
  IOpaqueAddress*& refpAddr )  
{
  // enable the conversion 
  enable ( true ) ;
  // conversion is possible ?
  if ( "NONE" == m_histPersName ) 
  {
    enable ( false ) ; 
    return PersistencySvc::createRep ( pObj , refpAddr ) ;   // RETURN 
  }
  // histogram ?
  if ( 0 != dynamic_cast<AIDA::IBaseHistogram*> ( pObj ) ) 
  {
    bool select = false ;
    // Empty ConvertHistos property means convert all
    if ( m_convert.empty() ) { select = true ; }
    else  
    {
      for ( Strings::const_iterator item = m_convert.begin() ; 
            m_convert.end() != item ; ++item ) 
      { if ( match ( pObj , *item ) ) { select = true ; break ; } }
    }
    // exclude ?
    for ( Strings::const_iterator item = m_exclude.begin() ;
          m_exclude.end() != item && select ; ++item ) 
    { if ( match ( pObj , *item ) ) { select = false ; break ; } }
    //
    enable ( select ) ;
    //
    const std::string& path = oname ( pObj ) ;
    //
    if ( !select ) { m_excluded.insert  ( path ) ; }
    else           { m_converted.insert ( path ) ; }
  }
  //
  return PersistencySvc::createRep ( pObj , refpAddr ) ;     // RETURN 
}
// ============================================================================
// Standard Constructor
// ============================================================================
HistogramPersistencySvc::HistogramPersistencySvc
( const std::string& name , 
  ISvcLocator*       svc  )
  :  PersistencySvc(name, svc)
  //
  , m_convert   () 
  , m_exclude   () 
  , m_converted () 
  , m_excluded  ()
  //
{
  std::vector<std::string> defServices;
  defServices.push_back("HbookHistSvc");
  defServices.push_back("RootHistSvc");
  m_svcNames.set(defServices);
  declareProperty ("HistogramPersistency", m_histPersName = "");
  declareProperty ("OutputFile", m_outputFile = "");
  //
  declareProperty 
    ("ConvertHistos" , m_convert , 
     "The list of patterns to be accepted for conversion" ) ;
  //
  declareProperty 
    ("ExcludeHistos" , m_exclude , 
     "The list of patterns to be excluded for conversion" ) ;
}
// ============================================================================
// Standard Destructor
// ============================================================================
HistogramPersistencySvc::~HistogramPersistencySvc()   {}
// ============================================================================


// ============================================================================
// The END
// ============================================================================

---