GaudiTuples.icpp

Go to the documentation of this file.

// ============================================================================
// Include files
// ============================================================================
// Gaudi
// ============================================================================
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/ToStream.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiTuples.h"
#include "GaudiAlg/Tuple.h"
#include "GaudiAlg/TupleObj.h"
#include "GaudiAlg/GaudiTupleAlg.h"
#include "GaudiAlg/TupleDetail.h"
#include "GaudiAlg/Print.h"
#include "GaudiAlg/HbookName.h"
// ============================================================================
/* @file GaudiTuples.cpp
 *
 *  Implementation file for class : GaudiTuples
 *
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @date   2005-08-08
 */
// ============================================================================
// Disable warning on windows
#ifdef _WIN32
#pragma warning ( disable:4661 ) // incomplete explicit templates
#endif
//=============================================================================
// small helper to simplify the code...

namespace {
    constexpr struct releaseAndClear_t {
        template <typename C> void operator()(C& c) const { 
            for (auto& i : c ) if (i.second) i.second->release();
            c.clear();
        }
    } releaseAndClear {};

   constexpr struct ordered_t {
       template <typename C> 
       std::map<typename C::key_type, typename C::mapped_type> operator()(const C& c) const {
               return { std::begin(c), std::end(c) };
       }
   } ordered {};
}

//=============================================================================
// Initialize ntupling
//=============================================================================
template <class PBASE>
StatusCode GaudiTuples<PBASE>::
#ifdef __ICC
  i_gtInitialize
#else
  initialize
#endif
  ()
{
  // initialize base class
  const StatusCode sc = PBASE::initialize();
  if ( sc.isFailure() ) return sc;

  if ( produceNTuples() )
  {
    // check the existance of service
    if ( this->ntupleSvc() == 0 )
    { return  this->Error( "INTupleSvc* points to NULL!" ); }
    // Print ntuple path
    this->Print( "The N-Tuple   path is set to be '" + nTuplePath() + "'",
                 StatusCode(StatusCode::SUCCESS, true) , MSG::DEBUG).ignore();
  }
  else
  { this->debug() << "Production of N-Tuples is switched OFF" << endmsg; }

  if ( produceEvtCols() )
  {
    // check the existance of service
    if ( 0 == this->evtColSvc() )
    { return  this->Error( "INTupleSvc* points to NULL!" ); }
    // Print EvtCol path
    this->Print( "The EventCol  path is set to be '" + evtColPath() + "'",
                 StatusCode(StatusCode::SUCCESS, true) , MSG::DEBUG ).ignore();
  }
  else
  { this->debug() << "Production of Event Collections is switched OFF" << endmsg; }

  return sc;
}

//=============================================================================
// finalize ntupling
//=============================================================================
template <class PBASE>
StatusCode GaudiTuples<PBASE>::
#ifdef __ICC
  i_gtFinalize
#else
  finalize
#endif
  ()
{
  if ( !( nTupleMapTitle () . empty () &&
          nTupleMapID    () . empty () &&
          evtColMapTitle () . empty () &&
          evtColMapID    () . empty ()
          ) )
  {
    const int nNtuples = nTupleMapID () . size () ;
    const int nEvtCols = evtColMapID () . size ();
    this->always()
      << "Booked " << nNtuples << " N-Tuples and " << nEvtCols
      << " Event Tag Collections" << endmsg ;
  }

  if ( produceNTuples () && tuplesPrint  () ) { printTuples  () ; }
  if ( produceEvtCols () && evtColsPrint () ) { printEvtCols () ; }

  // release ntuples and clear the container
  releaseAndClear(m_nTupleMapTitle);
  
  // release ntuples and clear the container
  releaseAndClear(m_nTupleMapID);
  
  // release ntuples and clear the container
  releaseAndClear(m_evtColMapTitle);
  
  // release ntuples and clear the container
  releaseAndClear(m_evtColMapID);
  
  // finalize base class
  return PBASE::finalize();
}

// ============================================================================
// get N-tuple object ( book on-demand ) with unique identidier
// ============================================================================
template <class PBASE>
Tuples::Tuple GaudiTuples<PBASE>::nTuple
( const std::string& title ,
  const CLID&        clid  ) const
{
  // look up in the table
  auto* tuple = m_nTupleMapTitle[ title ]  ;
  if ( tuple ) { return Tuple( tuple ) ; }                  // RETURN
  // Create the tuple ID
  TupleID ID;
  if ( this->useNumericAutoIDs() || title.empty() )
  {
    if ( ! this->useNumericAutoIDs() )
    {
      this -> Warning( "Cannot generate automatic literal ID from an empty title ! Using numeric ID instead for nTuple ID",
                       StatusCode::SUCCESS );
    }
    // propose the tuple ID
    ID = TupleID ( m_nTupleMapID.size() + 1 + nTupleOffSet() );
    // adjust the proposed ID
    while ( nTupleExists(ID) || evtColExists(ID) )
    { ID = TupleID ( ID.numeric() + 1 ) ; }
  }
  else
  {
    // use the title to create a unique literal ID
    ID = TupleID( this->convertTitleToID(title) );
    // Just in case ...
    while ( nTupleExists(ID) || evtColExists(ID) )
    { ID = TupleID(ID.idAsString()+"_"); }
  }
  // return
  return nTuple( ID , title , clid ) ;
}
// ============================================================================

// ============================================================================
// Access an Event Tag Collection object (book on-demand) with unique identifier
// ============================================================================
template <class PBASE>
Tuples::Tuple GaudiTuples<PBASE>::evtCol
( const std::string& title ,
  const CLID&        clid  ) const
{
  // look up in the table
  Tuples::TupleObj* tuple = m_evtColMapTitle[ title ]  ;
  if ( tuple ) { return Tuple( tuple ) ; }                   // RETURN
  // Create the tuple ID
  TupleID ID;
  if ( this->useNumericAutoIDs() || title.empty() )
  {
    if ( ! this->useNumericAutoIDs() )
    {
      this -> Warning( "Cannot generate automatic literal ID from an empty title ! Using numeric ID instead for evtCol ID",
                       StatusCode::SUCCESS );
    }
    // proposed the tuple ID
    ID = TupleID ( m_evtColMapID.size() + 1 + evtColOffSet() ) ;
    // adjust the proposed ID
    while ( nTupleExists(ID) || evtColExists(ID) )
    { ID = TupleID ( ID.numeric() + 1 ) ; }
  }
  else
  {
    // use the title to create a unique literal ID
    ID = TupleID( this->convertTitleToID(title) );
    // Just in case ...
    while ( nTupleExists(ID) || evtColExists(ID) )
    { ID = TupleID ( ID.idAsString()+"_" ) ; }
  }
  // return
  return evtCol( ID , title , clid ) ;
}
// ============================================================================

// ============================================================================
// get N-tuple object ( book on-demand ) with forced ID
// ============================================================================
template <class PBASE>
Tuples::Tuple GaudiTuples<PBASE>::nTuple
( const TupleID&     ID     ,
  const std::string& title1 ,
  const CLID&        clid   ) const
{
  // Check ID
  if ( ID.undefined() )
  { this->Error("Undefined NTuple ID : Title='"+title1+"'"); return Tuple(0); }
  
  // look up in the table
  Tuples::TupleObj * tuple = m_nTupleMapID[ ID ] ;
  if( tuple ) { return Tuple( tuple ) ; }                   // RETURN
  
  // convert ID to the string
  const std::string tID = ID.idAsString() ;

  // adjust the NTuple title
  const std::string title = title1.empty() ? ( "NTuple #" + tID ) : title1 ;

  // book new ntuple
  if( produceNTuples() )
  {
    // book NTupel
    NTuple::Tuple * tup = nullptr;
    if ( ID.numeric() )
    {
      tup = this->ntupleSvc() -> book ( nTuplePath() , ID.numericID() , clid , title );
    }
    else if ( ID.literal() )
    {
      tup = this->ntupleSvc() -> book ( nTuplePath() , ID.literalID() , clid , title );
    }
    else { this->Error( "Undefined NTuple ID" ); }

    // assertion
    this->Assert( tup , "Could not book the N-Tuple='" + title + "'" ) ;
    // some printout
    if( tup -> registry() && this->msgLevel(MSG::DEBUG) )
    { this->debug() << "Booked NTuple '" << title << "' ID=" << tID
                    << "' Path='"  << nTuplePath() << "' TS='"
                    << tup -> registry() -> identifier() << "'" << endmsg; }

    tuple = createNTuple ( title , tup                , clid ) ;
  }
  else
  {
    tuple = createNTuple ( title , (NTuple::Tuple*) 0 , clid ) ;
  }
  // increment the reference
  tuple -> addRef();
  //
  m_nTupleMapID [ ID ] = tuple ;
  //
  tuple -> addRef();
  m_nTupleMapTitle[ title ] = tuple ;
  // return
  return Tuple( tuple ) ;
}
// ============================================================================
template <class PBASE>
Tuples::Tuple GaudiTuples<PBASE>::evtCol
( const TupleID&     ID     ,
  const std::string& title1 ,
  const CLID&        clid   ) const
{
  // Check ID
  if ( ID.undefined() )
  { this->Error("Undefined NTuple ID : Title='"+title1+"'"); return Tuple(0); }

  // look up in the table
  Tuples::TupleObj* tuple = m_evtColMapID[ID] ;
  if ( tuple ) { return Tuple( tuple ) ; }                   // RETURN
  
  // convert ID to the string
  const std::string tID = ID.idAsString() ;

  // adjust the NTuple title
  const std::string title = title1.empty() ? ( "EvtCol #" + tID ) : title1 ;

  // book new ntuple
  if( produceEvtCols() )
  {
    // book NTuple
    NTuple::Tuple* tup = nullptr;
    if (  ID.numeric() )
    {
      tup = this->evtColSvc()->book ( evtColPath() , ID.numericID() , clid , title ) ;
    }
    else if ( ID.literal() )
    {
      tup = this->evtColSvc()->book ( evtColPath() , ID.literalID() , clid , title ) ;
    }
    else { this->Error( "Undefined NTuple ID" ); }

    // assertion
    this->Assert( tup , "Could not book the EvtCol='" + title + "'" ) ;
    // some printout
    if( tup -> registry() && this->msgLevel(MSG::DEBUG) )
    { this->debug() << "Booked EvtCol '" << title << "' ID=" << tID
                    << "' Path='" << evtColPath() << "' TS='"
                    << tup -> registry() -> identifier() << "'" << endmsg ; }

    tuple = createEvtCol ( title , tup                , clid ) ;
  }
  else
  {
    tuple = createEvtCol ( title , (NTuple::Tuple*) 0 , clid ) ;
  }
  // increment the reference
  tuple -> addRef();
  //
  m_evtColMapID [ ID ] = tuple ;
  //
  tuple -> addRef();
  m_evtColMapTitle[ title ] = tuple ;
  // return
  return Tuple( tuple ) ;
}
// ============================================================================
// create TupleObj
// ============================================================================
template <class PBASE>
Tuples::TupleObj* GaudiTuples<PBASE>::createNTuple
( const std::string& name  ,
  NTuple::Tuple*     tuple ,
  const CLID&        clid  ) const
{
  return Tuples::createTupleObj
    ( this , "Tuple '" + name  + "'" , tuple , clid , Tuples::NTUPLE ) ;
}
// ============================================================================

// ============================================================================
// create TupleObj for event tag collection
// ============================================================================
template <class PBASE>
Tuples::TupleObj* GaudiTuples<PBASE>::createEvtCol
( const std::string& name  ,
  NTuple::Tuple*     tuple ,
  const CLID&        clid  ) const
{
  return Tuples::createTupleObj
    ( this , "EvtCol '" + name  + "'" , tuple , clid , Tuples::EVTCOL ) ;
}
// ============================================================================
// perform the actual printout of N-tuples
// ============================================================================
template <class PBASE>
long GaudiTuples<PBASE>::printTuples  () const
{

  if ( nTupleMapTitle().empty() && nTupleMapID().empty() )
  { if (this->msgLevel(MSG::DEBUG)) this->debug() << "No N-Tuples   are booked" << endmsg ; }
  else
  { this->always() << "List of booked N-Tuples in directory "
                   << "\"" << nTuplePath() << "\"" << endmsg ; }
  
  for ( const auto& entry : ordered(nTupleMapID()) )
  {
    if ( !entry.second ) { continue ; }
    const NTuple::Tuple* tuple = entry.second->tuple() ;
    if ( !tuple )
    { this->error() << " NTuple::Tuple* points to NULL" << endmsg ; continue ; }
    this->always() << GaudiAlg::PrintTuple::print ( tuple , entry.first ) << endmsg ;
  }
  //
  return this->nTupleMapID().size() ;
}
// ============================================================================
// perform the actual printout of Evt Tag Collections
// ============================================================================
template <class PBASE>
long GaudiTuples<PBASE>::printEvtCols () const
{
  if ( evtColMapTitle().empty() && evtColMapID().empty() )
  { this->always() << "No Event Tag Collections are booked" << endmsg ; }
  else
  { this->always() << "List of booked Event Tag Collections in directory "
                   << "\"" << evtColPath() << "\"" << endmsg ; }
  for ( const auto& entry : ordered( evtColMapID() ) )
  {
    if ( !entry.second ) { continue ; }
    const auto tuple = entry.second->tuple() ;
    if ( !tuple )
    { this->error() << " NTuple::Tuple* points to NULL" << endmsg ; continue ; }
    this->always() << GaudiAlg::PrintTuple::print ( tuple , entry.first )
                   << " Items:"
                   << Gaudi::Utils::toString ( entry.second->items() ) << endmsg ;
  }
  //
  return this->evtColMapID().size() ;
}
// ============================================================================
// check the existence AND validity of the N-Tuple with the given ID
// ============================================================================
template <class PBASE>
bool GaudiTuples<PBASE>::nTupleExists ( const TupleID& ID ) const
{ 
  return m_nTupleMapID.end() != m_nTupleMapID.find ( ID ) ; 
}
// ============================================================================
// check the existence AND validity of the Event Tag Collection with the given ID
// ============================================================================
template <class PBASE>
bool GaudiTuples<PBASE>::evtColExists ( const TupleID& ID ) const
{ 
  return m_evtColMapID.end() != m_evtColMapID.find ( ID ) ; 
}
// ============================================================================
// Handle method for changes in the 'NTuplePrint'      property
// ============================================================================
template <class PBASE>
void GaudiTuples<PBASE>::printNTupleHandler  ( Property& )
{
  // no action if not yet initialized
  if ( this -> FSMState() < Gaudi::StateMachine::INITIALIZED ) { return ; }
  if ( this -> tuplesPrint() ) { this -> printTuples () ; }
}
// ============================================================================
// Handle method for changes in the 'EvtColsPrint'      property
// ============================================================================
template <class PBASE>
void GaudiTuples<PBASE>::printEvtColHandler  ( Property& )
{
  // no action if not yet initialized
  if ( this -> FSMState() < Gaudi::StateMachine::INITIALIZED ) { return ; }
  if ( this -> evtColsPrint() ) { this -> printEvtCols () ; }
}
// ============================================================================
// get the constructed N-Tuple path
// ============================================================================
template <class PBASE>
std::string GaudiTuples<PBASE>::nTuplePath() const
{
  const std::string path = nTupleLUN() + "/" + nTupleTopDir() + nTupleDir();
  return ( splitNTupleDir() ? dirHbookName( path ) : path ) ;
}
// ============================================================================
// get the constructed Event Tag Collection path
// ============================================================================
template <class PBASE>
std::string GaudiTuples<PBASE>::evtColPath() const
{
  std::string path = evtColLUN() + "/" + evtColTopDir() + evtColDir();
  return ( splitEvtColDir() ? dirHbookName( path ) : path );
}
// ============================================================================
// The END
// ============================================================================