THistSvc.h

Go to the documentation of this file.

#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 "TGraph.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TList.h"
#include "TObject.h"
#include "TTree.h"

class IIncidentSvc;

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 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 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 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;



  std::vector<std::string> getHists() const override;
  std::vector<std::string> getTrees() const override;
  std::vector<std::string> getGraphs() 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;


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 };

  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};
  Gaudi::Property<std::vector<std::string>> m_inputfile{this, "Input", {}, &THistSvc::setupInputFile};


  IIncidentSvc* p_incSvc  = nullptr;
  IFileMgr*     p_fileMgr = nullptr;

  bool m_signaledStop = false;
  bool m_delayConnect = false;
  bool m_okToConnect  = false;

  mutable std::string m_curstream;

  mutable THistSvcMutex_t m_svcMut;
};

// Include template implementation
#include "THistSvc.icc"

#endif // GAUDISVC_THISTSVC_H