GaudiTuples.h

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.                                             *
\***********************************************************************************/
#ifndef GAUDIALG_GAUDITUPLES_H
#define GAUDIALG_GAUDITUPLES_H 1
// ============================================================================
/* @file GaudiTuples.h
 *
 *  Header file for class : GaudiTuples
 *
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @date   2005-08-08
 */
// ============================================================================
// Include files
// ============================================================================
#include "boost/algorithm/string/replace.hpp"
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/ClassID.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiHistoAlg.h"
#include "GaudiAlg/GaudiHistoTool.h"
#include "GaudiAlg/Maps.h"
#include "GaudiAlg/Tuple.h"
#include "GaudiAlg/TupleObj.h"
// ============================================================================
// ============================================================================
template <class PBASE>
class GAUDI_API GaudiTuples : public PBASE {
public:
  // ==========================================================================
  typedef GaudiAlg::HistoID HistoID;
  typedef Tuples::Tuple Tuple;
  typedef GaudiAlg::TupleID TupleID;
  // ==========================================================================
public:
  // ==========================================================================
  Tuple nTuple( const std::string& title, const CLID& clid = CLID_ColumnWiseTuple ) const;

  Tuple nTuple( const TupleID& ID, const std::string& title, const CLID& clid = CLID_ColumnWiseTuple ) const;

  Tuple evtCol( const std::string& title, const CLID& clid = CLID_ColumnWiseTuple ) const;

  Tuple evtCol( const TupleID& ID, const std::string& title, const CLID& clid = CLID_ColumnWiseTuple ) const;
  // ==========================================================================
public: // trivial accessors
  // ==========================================================================
  bool produceNTuples() const { return m_produceNTuples; }
  bool splitNTupleDir() const { return m_splitNTupleDir; }
  const std::string& nTupleLUN() const { return m_nTupleLUN; }
  const std::string& nTupleTopDir() const { return m_nTupleTopDir; }
  const std::string& nTupleDir() const { return m_nTupleDir; }
  TupleID::NumericID nTupleOffSet() const { return m_nTupleOffSet; }
  std::string nTuplePath() const;
  bool produceEvtCols() const { return m_produceEvtCols; }
  bool splitEvtColDir() const { return m_splitEvtColDir; }
  const std::string& evtColLUN() const { return m_evtColLUN; }
  const std::string& evtColTopDir() const { return m_evtColTopDir; }
  const std::string& evtColDir() const { return m_evtColDir; }
  TupleID::NumericID evtColOffSet() const { return m_evtColOffSet; }
  std::string evtColPath() const;
  bool tuplesPrint() const { return m_tuplesPrint; }
  bool evtColsPrint() const { return m_evtColsPrint; }
  // ==========================================================================
public:
  // ==========================================================================
  long printTuples() const;
  long printEvtCols() const;
  // ==========================================================================
  bool nTupleExists( const TupleID& ID ) const;
  bool evtColExists( const TupleID& ID ) const;
  // ==========================================================================
protected:
  // ==========================================================================
  virtual std::unique_ptr<Tuples::TupleObj> createNTuple( const std::string& name, NTuple::Tuple* tuple,
                                                          const CLID& clid ) const;
  virtual std::unique_ptr<Tuples::TupleObj> createEvtCol( const std::string& name, NTuple::Tuple* tuple,
                                                          const CLID& clid ) const;
  // ==========================================================================
public:
  // ==========================================================================
  template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<GaudiHistoAlg, PBASE>, U>>
  GaudiTuples( const std::string& name, ISvcLocator* pSvcLocator ) : PBASE( name, pSvcLocator ) {}
  template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<GaudiHistoTool, PBASE>, U>>
  GaudiTuples( const std::string& type, const std::string& name, const IInterface* parent )
      : PBASE( type, name, parent ) {}
  // ==========================================================================
protected:
  // ==========================================================================
  StatusCode initialize() override
#ifdef __ICC
  {
    return i_gtInitialize();
  }
  StatusCode i_gtInitialize()
#endif
      ;
  StatusCode finalize() override
#ifdef __ICC
  {
    return i_gtFinalize();
  }
  StatusCode i_gtFinalize()
#endif
      ;
  // ==========================================================================
private:
  // ==========================================================================
  Gaudi::Property<bool> m_produceNTuples{this, "NTupleProduce", true, "general switch to enable/disable N-tuples"};
  Gaudi::Property<bool> m_tuplesPrint{this, "NTuplePrint", true,
                                      [this]( auto& ) {
                                        // no action if not yet initialized
                                        if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                             this->tuplesPrint() )
                                          this->printTuples();
                                      },
                                      "print N-tuple statistics"};
  Gaudi::Property<bool> m_splitNTupleDir{this, "NTupleSplitDir", false,
                                         "split long directory names into short pieces (suitable for HBOOK)"};
  Gaudi::Property<TupleID::NumericID> m_nTupleOffSet{this, "NTupleOffSet", 0, "offset for numerical N-tuple ID"};
  Gaudi::Property<std::string>        m_nTupleLUN{this, "NTupleLUN", "FILE1", "Logical File Unit for N-tuples"};
  Gaudi::Property<std::string>        m_nTupleTopDir{this, "NTupleTopDir", "", "top-level directory for N-Tuples"};
  Gaudi::Property<std::string>        m_nTupleDir{
      this, "NTupleDir", boost::algorithm::replace_all_copy( this->name(), ":", "_" ), "subdirectory for N-Tuples"};

  Gaudi::Property<bool> m_produceEvtCols{this, "EvtColsProduce", false,
                                         "general switch to enable/disable Event Tag Collections"};
  Gaudi::Property<bool> m_evtColsPrint{this, "EvtColsPrint", false,
                                       [this]( auto& ) {
                                         // no action if not yet initialized
                                         if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                              this->evtColsPrint() )
                                           this->printEvtCols();
                                       },
                                       "print statistics for Event Tag Collections "};
  Gaudi::Property<bool> m_splitEvtColDir{this, "EvtColSplitDir", false, "split long directory names into short pieces"};
  Gaudi::Property<TupleID::NumericID> m_evtColOffSet{this, "EvtColOffSet", 0, "offset for numerical N-tuple ID"};
  Gaudi::Property<std::string> m_evtColLUN{this, "EvtColLUN", "EVTCOL", "Logical File Unit for Event Tag Collections"};
  Gaudi::Property<std::string> m_evtColTopDir{this, "EvtColTopDir", "",
                                              "Top-level directory for Event Tag Collections"};
  Gaudi::Property<std::string> m_evtColDir{this, "EvtColDir",
                                           boost::algorithm::replace_all_copy( this->name(), ":", "_" ),
                                           "Subdirectory for Event Tag Collections"};
  struct nTupleMapItem         final {
    std::string                       title;
    TupleID                           id;
    std::shared_ptr<Tuples::TupleObj> tuple;
  };
  struct title_t {};
  struct id_t {};
  struct order_t {};
  template <typename... Ts>
  using indexed_by = boost::multi_index::indexed_by<Ts...>;
  template <typename... Ts>
  using hashed_unique = boost::multi_index::hashed_unique<Ts...>;
  template <typename... Ts>
  using ordered_unique = boost::multi_index::ordered_unique<Ts...>;
  template <typename Obj, typename Type, Type Obj::*Member>
  using member = boost::multi_index::member<Obj, Type, Member>;
  template <typename T>
  using tag       = boost::multi_index::tag<T>;
  using nTupleMap = boost::multi_index_container<
      nTupleMapItem, indexed_by<hashed_unique<tag<title_t>, member<nTupleMapItem, std::string, &nTupleMapItem::title>>,
                                hashed_unique<tag<id_t>, member<nTupleMapItem, TupleID, &nTupleMapItem::id>>,
                                ordered_unique<tag<order_t>, member<nTupleMapItem, TupleID, &nTupleMapItem::id>>>>;

  // ==========================================================================
  mutable nTupleMap m_nTupleMap;

  decltype( auto ) nTupleByID() const { return m_nTupleMap.template get<id_t>(); }
  decltype( auto ) nTupleByTitle() const { return m_nTupleMap.template get<title_t>(); }
  decltype( auto ) nTupleOrdered() const { return m_nTupleMap.template get<order_t>(); }

  // ==========================================================================
  mutable nTupleMap m_evtColMap;

  decltype( auto ) evtColByID() const { return m_evtColMap.template get<id_t>(); }
  decltype( auto ) evtColByTitle() const { return m_evtColMap.template get<title_t>(); }
  decltype( auto ) evtColOrdered() const { return m_evtColMap.template get<order_t>(); }

  // ==========================================================================
};
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GAUDITUPLES_H