CalibObjManager.h

#pragma once
 
#include <string>
#include <memory>
 
#include <TDirectory.h>
#include <TNamed.h>
#include <TTree.h>
 
#include <framework/dataobjects/EventMetaData.h>
#include <framework/logging/Logger.h>
 
#include <calibration/Utilities.h>
 
namespace Belle2 {
  class CalibObjManager {
 
  public:
    CalibObjManager(TDirectory* dir = nullptr) : m_dir(dir) {};
 
    virtual ~CalibObjManager() {m_templateObjects.clear();}
 
    void setDirectory(TDirectory* dir) {m_dir = dir;}
 
    void addObject(const std::string& name, std::shared_ptr<TNamed> object);
 
    void writeCurrentObjects(const Calibration::ExpRun& expRun);
 
    void clearCurrentObjects(const Calibration::ExpRun& expRun);
 
    void createDirectories();
 
    void createExpRunDirectories(Calibration::ExpRun& expRun) const;
 
    unsigned int getHighestIndexObject(const std::string& name, const TDirectory* dir) const;
 
    void deleteHeldObjects();
 
    bool isRegistered(const std::string& name) const;
 
    template<class T>
    T* getObject(const std::string& name, const Belle2::Calibration::ExpRun expRun)
    {
      std::string objectDirName = name + '/' + getObjectExpRunName(name, expRun);
      TDirectory* objectDir = m_dir->GetDirectory(objectDirName.c_str());
      // Does the object name have a directory available? (framework problem if not)
      if (not objectDir) {
        // Is the object name known to us? (user problem if not)
        if (not isRegistered(name)) {
          B2ERROR("The requested object name '" << name << "' isn't known to CalibObjManager!");
          return nullptr;
        }
        B2FATAL("TDirectory for registered object " << name << " not found: " << objectDirName);
      }
      unsigned int highestIndex = getHighestIndexObject(name, objectDir);
      std::string highestIndexName = name + "_" + std::to_string(highestIndex);
      // First check if we currently have an object we're using.
      T* obj = dynamic_cast<T*>(objectDir->FindObject(highestIndexName.c_str()));
      if (!obj) {
        B2DEBUG(100, "Highest index is only file resident for " << highestIndexName << " in " << objectDir->GetPath() <<
                ". Will make a higher one");
        std::string newName = name + "_" + std::to_string(highestIndex + 1);
        obj = cloneObj<T>(dynamic_cast<T*>(m_templateObjects[name].get()), newName);
        obj->SetDirectory(objectDir);
        obj->Reset();
        // Did SetDirectory work? Or was it a dummy class method?
        T* objTest;
        objectDir->GetObject(newName.c_str(), objTest);
        if (!objTest) {
          B2DEBUG(100, "SetDirectory was a dummy function. Adding to Object to TDirectory manually.");
          objectDir->Add(obj);
        }
      }
      return obj;
    }
 
  private:
 
    template<class T>
    T* cloneObj(T* source, const std::string& newName) const
    {
      B2DEBUG(100, "Held object " << source->GetName() << " will be treated as a generic TNamed and have Clone(newname) called.");
      return dynamic_cast<T*>(source->Clone(newName.c_str()));
    }
 
    TDirectory* m_dir;
 
    std::map<std::string, std::shared_ptr<TNamed>> m_templateObjects;
 
    std::string getSuffix(const Belle2::Calibration::ExpRun& key) const;
 
    std::string getSuffix(const EventMetaData& emd) const;
 
    std::string getObjectExpRunName(const std::string& name, const Calibration::ExpRun& expRun) const;
 
    unsigned int extractKeyIndex(const std::string& keyName) const;
  };
  template<>
  TTree* CalibObjManager::cloneObj(TTree* source, const std::string& newName) const;
}