THistSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2021 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 GAUDISVC_THISTSVC_H
#define GAUDISVC_THISTSVC_H
 
// system includes:
#include <map>
#include <set>
#include <string>
#include <vector>
 
// Gaudi includes:
#include "GaudiKernel/IFileMgr.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/ITHistSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Service.h"
 
// ROOT includes:
#include "TEfficiency.h"
#include "TGraph.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TList.h"
#include "TObject.h"
#include "TTree.h"
 
class IIncidentSvc;
class TClass;
 
class THistSvc : public extends<Service, ITHistSvc, IIncidentListener, IIoComponent> {
public:
  using extends::extends;
 
  StatusCode initialize() override;
  StatusCode reinitialize() override;
  StatusCode finalize() override;
 
public:
  // Methods from ITHistSvc
 
  StatusCode regHist( const std::string& name ) override;
  StatusCode regHist( const std::string& name, std::unique_ptr<TH1> hist ) override;
  StatusCode regHist( const std::string& name, std::unique_ptr<TH1> hist, TH1* hist_ptr ) override;
  StatusCode regHist( const std::string& name, TH1* ) override;
 
  StatusCode getHist( const std::string& name, TH1*&, size_t index = 0 ) const override;
  StatusCode getHist( const std::string& name, TH2*&, size_t index = 0 ) const override;
  StatusCode getHist( const std::string& name, TH3*&, size_t index = 0 ) const override;
 
 
 
  StatusCode regTree( const std::string& name ) override;
  StatusCode regTree( const std::string& name, std::unique_ptr<TTree> ) override;
  StatusCode regTree( const std::string& name, TTree* ) override;
  StatusCode getTree( const std::string& name, TTree*& ) const override;
 
 
 
  StatusCode regGraph( const std::string& name ) override;
  StatusCode regGraph( const std::string& name, std::unique_ptr<TGraph> ) override;
  virtual StatusCode regGraph( const std::string& name, TGraph* ) override;
  StatusCode getGraph( const std::string& name, TGraph*& ) const override;
 
  StatusCode regEfficiency( const std::string& name ) override;
  StatusCode regEfficiency( const std::string& name, std::unique_ptr<TEfficiency> ) override;
  virtual StatusCode regEfficiency( const std::string& name, TEfficiency* ) override;
  StatusCode getEfficiency( const std::string& name, TEfficiency*& ) const override;
 
 
 
  StatusCode regShared( const std::string& name, std::unique_ptr<TH1>, LockedHandle<TH1>& ) override;
  StatusCode regShared( const std::string& name, std::unique_ptr<TH2>, LockedHandle<TH2>& ) override;
  StatusCode regShared( const std::string& name, std::unique_ptr<TH3>, LockedHandle<TH3>& ) override;
  StatusCode regShared( const std::string& name, std::unique_ptr<TGraph>, LockedHandle<TGraph>& ) override;
  StatusCode regShared( const std::string& name, std::unique_ptr<TEfficiency>, LockedHandle<TEfficiency>& ) override;
  StatusCode getShared( const std::string& name, LockedHandle<TH1>& ) const override;
  StatusCode getShared( const std::string& name, LockedHandle<TH2>& ) const override;
  StatusCode getShared( const std::string& name, LockedHandle<TH3>& ) const override;
  StatusCode getShared( const std::string& name, LockedHandle<TGraph>& ) const override;
  StatusCode getShared( const std::string& name, LockedHandle<TEfficiency>& ) const override;
 
 
 
  StatusCode deReg( const std::string& name ) override;
  StatusCode deReg( TObject* obj ) override;
 
  StatusCode merge( const std::string& id ) override;
  StatusCode merge( TObject* ) override;
 
  bool exists( const std::string& name ) const override;
  bool existsHist( const std::string& name ) const override;
  bool existsTree( const std::string& name ) const override;
  bool existsGraph( const std::string& name ) const override;
  bool existsEfficiency( const std::string& name ) const override;
 
 
 
  std::vector<std::string> getHists() const override;
  std::vector<std::string> getTrees() const override;
  std::vector<std::string> getGraphs() const override;
  std::vector<std::string> getEfficiencies() const override;
 
  StatusCode getTHists( TDirectory* td, TList&, bool recurse = false ) const override;
  StatusCode getTHists( const std::string& name, TList&, bool recurse = false ) const override;
  StatusCode getTHists( TDirectory* td, TList& tl, bool recurse = false, bool reg = false ) override;
  StatusCode getTHists( const std::string& name, TList& tl, bool recurse = false, bool reg = false ) override;
 
  StatusCode getTTrees( TDirectory* td, TList&, bool recurse = false ) const override;
  StatusCode getTTrees( const std::string& name, TList&, bool recurse = false ) const override;
  StatusCode getTTrees( TDirectory* td, TList& tl, bool recurse = false, bool reg = false ) override;
  StatusCode getTTrees( const std::string& name, TList& tl, bool recurse = false, bool reg = false ) override;
 
  StatusCode getTEfficiencies( TDirectory* td, TList&, bool recurse = false ) const override;
  StatusCode getTEfficiencies( const std::string& name, TList&, bool recurse = false ) const override;
  StatusCode getTEfficiencies( TDirectory* td, TList& tl, bool recurse = false, bool reg = false ) override;
  StatusCode getTEfficiencies( const std::string& name, TList& tl, bool recurse = false, bool reg = false ) override;
 
 
public:
  // Methods from other interfaces
  // From IIncidentListener
  void handle( const Incident& ) override;
 
  // From IIoComponent
  StatusCode io_reinit() override;
 
private:
  typedef std::recursive_mutex THistSvcMutex_t;
  typedef std::mutex           histMut_t;
 
  class GlobalDirectoryRestore {
  public:
    GlobalDirectoryRestore( THistSvcMutex_t& mut );
    ~GlobalDirectoryRestore();
 
  private:
    TDirectory*                      m_gDirectory;
    TFile*                           m_gFile;
    int                              m_gErrorIgnoreLevel;
    std::lock_guard<THistSvcMutex_t> m_lock;
  };
 
  enum Mode { READ, WRITE, UPDATE, APPEND, SHARE, INVALID };
 
  static Mode charToMode( const char typ ) {
    switch ( typ ) {
    case 'O':
      return READ;
    case 'A':
      return APPEND;
    case 'R':
      return UPDATE;
    case 'S':
      return SHARE;
    default:
      return INVALID;
    }
  }
 
  struct THistID {
    std::string id{""};
    bool        temp{true};
    TObject*    obj{nullptr};
    TFile*      file{nullptr};
    Mode        mode{INVALID};
    histMut_t*  mutex{nullptr};
    bool        shared{false};
 
    THistID()                     = default;
    THistID( const THistID& rhs ) = default;
    THistID( std::string& i, bool& t, TObject* o, TFile* f ) : id( i ), temp( t ), obj( o ), file( f ) {}
    THistID( std::string& i, bool& t, TObject* o, TFile* f, Mode m )
        : id( i ), temp( t ), obj( o ), file( f ), mode( m ) {}
 
    void reset() {
      id     = "";
      temp   = true;
      obj    = nullptr;
      file   = nullptr;
      mode   = INVALID;
      mutex  = nullptr;
      shared = false;
    }
 
    bool operator<( THistID const& rhs ) const { return ( obj < rhs.obj ); }
 
    friend std::ostream& operator<<( std::ostream& ost, const THistID& hid ) {
      ost << "id: " << hid.id << " t: " << hid.temp << " s: " << hid.shared << " M: " << hid.mode << " m: " << hid.mutex
          << " o: " << hid.obj << " " << hid.obj->IsA()->GetName();
      return ost;
    }
  };
 
 
  std::vector<std::string> m_Rstream, m_Wstream;
 
  std::set<std::string> m_alreadyConnectedInFiles;
 
  std::set<std::string> m_alreadyConnectedOutFiles;
 
  // containers for fast lookups
  // same uid for all elements in vec
  typedef std::vector<THistID> vhid_t;
  // all THistIDs
  typedef std::list<vhid_t*> hlist_t;
  // uid: /stream/name -> vhid
  typedef std::unordered_map<std::string, vhid_t*> uidMap_t;
  // name -> vhid
  typedef std::unordered_multimap<std::string, vhid_t*>            idMap_t;
  typedef std::unordered_map<TObject*, std::pair<vhid_t*, size_t>> objMap_t;
 
  hlist_t  m_hlist;
  uidMap_t m_uids;
  idMap_t  m_ids;
 
  // Container holding all TObjects and vhid*s
  objMap_t m_tobjs;
 
  std::map<std::string, std::pair<TFile*, Mode>>  m_files; // stream->file
  typedef std::multimap<std::string, std::string> streamMap;
  streamMap                                       m_fileStreams; // fileName->streams
 
  // stream->filename of shared files
  std::map<std::string, std::string> m_sharedFiles;
 
 
 
  template <typename T>
  StatusCode regHist_i( std::unique_ptr<T> hist, const std::string& name, bool shared );
  template <typename T>
  StatusCode regHist_i( std::unique_ptr<T> hist, const std::string& name, bool shared, THistID*& hid );
  template <typename T>
  T* getHist_i( const std::string& name, const size_t& ind = 0, bool quiet = false ) const;
  template <typename T>
  T* readHist_i( const std::string& name ) const;
 
  template <typename T>
  LockedHandle<T> regShared_i( const std::string& id, std::unique_ptr<T> hist );
  template <typename T>
  LockedHandle<T> getShared_i( const std::string& name ) const;
 
 
 
  template <typename T>
  T*     readHist( const std::string& name ) const;
  TTree* readTree( const std::string& name ) const;
 
  void        updateFiles();
  StatusCode  writeObjectsToFile();
  StatusCode  connect( const std::string& );
  TDirectory* changeDir( const THistSvc::THistID& hid ) const;
  std::string stripDirectoryName( std::string& dir ) const;
  void        removeDoubleSlash( std::string& ) const;
 
  void MergeRootFile( TDirectory*, TDirectory* );
 
  bool findStream( const std::string& name, std::string& root, std::string& rem, TFile*& file ) const;
  void parseString( const std::string& id, std::string& root, std::string& rem ) const;
 
  void setupInputFile();
 
  void setupOutputFile();
 
  void copyFileLayout( TDirectory*, TDirectory* );
 
  size_t findHistID( const std::string& id, const THistID*& hid, const size_t& index = 0 ) const;
 
  void dump() const;
 
  StatusCode merge( const THistID& );
  StatusCode merge( vhid_t* );
 
  StatusCode rootOpenAction( FILEMGR_CALLBACK_ARGS );
  StatusCode rootOpenErrAction( FILEMGR_CALLBACK_ARGS );
 
 
 
  Gaudi::Property<int>                      m_autoSave{this, "AutoSave", 0};
  Gaudi::Property<int>                      m_autoFlush{this, "AutoFlush", 0};
  Gaudi::Property<bool>                     m_print{this, "PrintAll", false};
  Gaudi::Property<int>                      m_maxFileSize{this, "MaxFileSize", 10240,
                                     "maximum file size in MB. if exceeded,"
                                     " will cause an abort. -1 to never check."};
  Gaudi::Property<int>                      m_compressionLevel{this, "CompressionLevel", 1, [this]( auto& ) {
                                            this->warning()
                                                << "\"CompressionLevel\" Property has been deprecated. "
                                                << "Set it via the \"CL=\" parameter in the \"Output\" Property"
                                                << endmsg;
                                          }};
  Gaudi::Property<std::vector<std::string>> m_outputfile{
      this, "Output", {}, &THistSvc::setupOutputFile, "", "OrderedSet<std::string>"};
  Gaudi::Property<std::vector<std::string>> m_inputfile{
      this, "Input", {}, &THistSvc::setupInputFile, "", "OrderedSet<std::string>"};
 
 
  IIncidentSvc* p_incSvc  = nullptr;
  IFileMgr*     p_fileMgr = nullptr;
 
  bool m_signaledStop = false;
  bool m_delayConnect = false;
  bool m_okToConnect  = false;
 
  const TClass* m_ttreeClass = nullptr;
 
  mutable std::string m_curstream;
 
  mutable THistSvcMutex_t m_svcMut;
};
 
// Include template implementation
#include "THistSvc.icc"
 
#endif // GAUDISVC_THISTSVC_H