GaudiTuples.icpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
// ============================================================================
// Include files
// ============================================================================
// Gaudi
// ============================================================================
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/ToStream.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiTupleAlg.h"
#include "GaudiAlg/GaudiTuples.h"
#include "GaudiAlg/HbookName.h"
#include "GaudiAlg/Print.h"
#include "GaudiAlg/Tuple.h"
#include "GaudiAlg/TupleDetail.h"
#include "GaudiAlg/TupleObj.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
 
//=============================================================================
// 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::SUCCESS, 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::SUCCESS, 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 ( !( m_nTupleMap.empty() && m_evtColMap.empty() ) ) {
    const int nNtuples = m_nTupleMap.size();
    const int nEvtCols = m_evtColMap.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
  m_nTupleMap.clear();
 
  // release ntuples and clear the container
  m_evtColMap.clear();
 
  // 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& m     = nTupleByTitle();
  auto  tuple = m.find( title );
  if ( tuple != m.end() ) return Tuple( 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 )
          .ignore();
    }
    // propose the tuple ID
    ID = TupleID( m_nTupleMap.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
  auto& m     = evtColByTitle();
  auto  tuple = m.find( title );
  if ( tuple != m.end() ) return Tuple( 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 )
          .ignore();
    }
    // proposed the tuple ID
    ID = TupleID( m_evtColMap.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 + "'" ).ignore();
    return Tuple( 0 );
  }
 
  // look up in the table
  auto& m     = nTupleByID();
  auto  tuple = m.find( ID );
  if ( tuple != m.end() ) return Tuple( 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() ) {
    auto r = m_nTupleMap.insert( nTupleMapItem{title, ID, createNTuple( title, nullptr, clid )} );
    if ( !r.second ) this->Error( "Failure to createNTuple" ).ignore();
    return Tuple( r.first->tuple );
  }
  // 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" ).ignore();
  }
 
  // 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;
  }
 
  auto r = m_nTupleMap.insert( nTupleMapItem{title, ID, createNTuple( title, tup, clid )} );
  if ( !r.second ) this->Error( "Failure to createNTuple" ).ignore();
  return Tuple( r.first->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 + "'" ).ignore();
    return Tuple( 0 );
  }
 
  // look up in the table
  auto& tuple = evtColByID();
  auto  i     = tuple.find( ID );
  if ( i != tuple.end() ) return Tuple( i->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() ) {
    auto r = m_evtColMap.insert( nTupleMapItem{title, ID, createEvtCol( title, nullptr, clid )} );
    if ( !r.second ) this->Error( "Failure to createEvtCol" ).ignore();
    return Tuple( r.first->tuple );
  }
  // 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" ).ignore();
  }
 
  // 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;
  }
  auto r = m_evtColMap.insert( nTupleMapItem{title, ID, createEvtCol( title, tup, clid )} );
  if ( !r.second ) this->Error( "Failure to createEvtCol" ).ignore();
  return Tuple( r.first->tuple );
}
// ============================================================================
// create TupleObj
// ============================================================================
template <class PBASE>
std::unique_ptr<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>
std::unique_ptr<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 ( m_nTupleMap.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 : this->nTupleOrdered() ) {
    if ( !entry.tuple->tuple() ) {
      this->error() << " NTuple::Tuple* points to NULL" << endmsg;
      continue;
    }
    this->always() << GaudiAlg::PrintTuple::print( entry.tuple->tuple(), entry.id ) << endmsg;
  }
  //
  return this->m_nTupleMap.size();
}
// ============================================================================
// perform the actual printout of Evt Tag Collections
// ============================================================================
template <class PBASE>
long GaudiTuples<PBASE>::printEvtCols() const {
  if ( m_evtColMap.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 : this->evtColOrdered() ) {
    if ( !entry.tuple->tuple() ) {
      this->error() << " NTuple::Tuple* points to NULL" << endmsg;
      continue;
    }
    this->always() << GaudiAlg::PrintTuple::print( entry.tuple->tuple(), entry.id )
                   << " Items:" << Gaudi::Utils::toString( entry.tuple->items() ) << endmsg;
  }
  //
  return this->m_evtColMap.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 {
  auto& m = nTupleByID();
  return m.find( ID ) != m.end();
}
// ============================================================================
// 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 {
  auto& m = evtColByID();
  return m.find( ID ) != m.end();
}
// ============================================================================
// 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
// ============================================================================