OutputStreamData.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
 
 
//
// includes
//
 
#include <EventLoop/OutputStreamData.h>
 
#include <AsgMessaging/StatusCode.h>
#include <RootCoreUtils/Assert.h>
#include <RootCoreUtils/RootUtils.h>
#include <TH1.h>
#include <TTree.h>
#include <tuple>//for std::ignore
 
//
// method implementations
//
 
namespace EL
{
  namespace Detail
  {
    namespace
    {
      class DirectoryReset {
      public:
        DirectoryReset() : m_dir( *gDirectory ) {}
        ~DirectoryReset() { m_dir.cd(); }
      private:
        TDirectory& m_dir;
      };
 
 
 
      struct MyWriter : public SH::DiskWriter
      {
 
      public:
        std::unique_ptr<TFile> m_file;
 
        explicit MyWriter (std::unique_ptr<TFile> val_file)
          : m_file (std::move (val_file))
        {
          if (m_file == nullptr)
            throw std::runtime_error ("encountered null pointer for output file");
          m_path = m_file->GetName();
        }
 
        ~MyWriter ()
        {
          if (m_file != nullptr)
            close();
        }
        //cppcheck-suppress returnByReference
        std::string getPath () const
        {
          return m_path;
        }
 
        TFile *getFile ()
        {
          RCU_REQUIRE2_SOFT (m_file != nullptr, "file already closed");
          return m_file.get();
        }
 
        void doClose ()
        {
          RCU_REQUIRE2_SOFT (m_file != nullptr, "file already closed");
          m_file->Write ();
          m_file->Close ();
          m_file = nullptr;
        }
        private:
          std::string m_path;
      };
 
 

      std::unique_ptr<TFile> checkedOpenFile (const std::string& path, const std::string& mode)
      {
        std::unique_ptr<TFile> result (TFile::Open (path.c_str(), mode.c_str()));
        if (result == nullptr)
          throw std::runtime_error ("failed to open file " + path + " with mode " + mode);
        return result;
      }
    }
 
 
 
    void OutputStreamData ::
    testInvariant () const
    {
      RCU_INVARIANT (m_writer != nullptr);
    }
 
 
 
    OutputStreamData ::
    OutputStreamData (const std::string& val_fileName, const std::string& mode)
      : OutputStreamData (checkedOpenFile (val_fileName, mode))
    {
      // no invariant used
    }
 
 
 
    OutputStreamData ::
    OutputStreamData (std::unique_ptr<TFile> file)
      : OutputStreamData (std::make_unique<MyWriter> (std::move (file)))
    {
      // no invariant used
    }
 
 
 
    OutputStreamData ::
    OutputStreamData (std::unique_ptr<SH::DiskWriter> val_writer)
      : m_writer (std::move (val_writer))
    {
      RCU_NEW_INVARIANT (this);
    }
 
 
 
    const std::string& OutputStreamData ::
    mainStreamName () const noexcept
    {
      RCU_READ_INVARIANT (this);
      return m_mainStreamName;
    }
 
 
 
    void OutputStreamData ::
    setMainStreamName (const std::string& val_mainStreamName)
    {
      RCU_CHANGE_INVARIANT (this);
      if (!m_mainStreamName.empty())
        throw std::runtime_error ("main stream name already set");
      m_mainStreamName = val_mainStreamName;
    }
 
 
 
    TFile *OutputStreamData ::
    file () const noexcept
    {
      RCU_READ_INVARIANT (this);
      TFile *result = m_writer->file();
      RCU_PROVIDE (result != nullptr);
      return result;
    }
 
 
 
    void OutputStreamData ::
    close ()
    {
      RCU_CHANGE_INVARIANT (this);
      saveOutput ();
      m_writer->close ();
    }
 
 
 
    std::string OutputStreamData ::
    finalFileName () const
    {
      RCU_READ_INVARIANT (this);
      return m_writer->path ();
    }
 
 
 
    void OutputStreamData ::
    saveOutput ()
    {
      RCU_CHANGE_INVARIANT (this);
      TFile *const file {m_writer->file()};
      RCU_ASSERT (file != nullptr);
      for (std::unique_ptr<TObject>& object : m_output)
      {
        std::string name = object->GetName();
        TDirectory *dir = makeDirectoryFor (name);
        if (dir != file)
        {
          TNamed *named = dynamic_cast<TNamed*>(object.get());
          if (named)
            named->SetName (name.c_str());
        }
 
        if (RCU::SetDirectory (object.get(), dir))
        {
          // SetDirectory transferred ownership to the directory, so release
          // it here to avoid a double delete.
          //placate cppcheck using std::ignore
          std::ignore = object.release();
        } else
        {
          // WriteObject writes a copy and takes no ownership, so we keep
          // owning the object and let the unique_ptr delete it below.
          dir->WriteObject (object.get(), name.c_str());
        }
      }
      m_outputHistMap.clear ();
      m_outputTreeMap.clear ();
      m_output.clear ();
    }
 
 
 
    void OutputStreamData ::
    addOutput (std::unique_ptr<TObject> outputObject)
    {
      RCU_CHANGE_INVARIANT (this);
 
      TTree *const tree = dynamic_cast<TTree*> (outputObject.get());
      if (tree)
      {
        std::string name = tree->GetName();
        std::string treeName = tree->GetName();
 
        TDirectory *dir = makeDirectoryFor (treeName);
 
        // if we are in a sub-directory we need to rename the tree
        if (name != treeName)
          tree->SetName (treeName.c_str());
 
        // pass ownership of the tree to the directory
        tree->SetDirectory (dir);
        outputObject.release();
 
        m_outputTreeMap[name] = tree;
 
 
      } else
      {
        TH1 *const hist = dynamic_cast<TH1*> (outputObject.get());
 
        m_outputHistMap[outputObject->GetName()] = outputObject.get();
        m_output.emplace_back (std::move (outputObject));
        if (hist)
          hist->SetDirectory (nullptr);
      }
    }
 
 
 
    void OutputStreamData ::
    addClone (const TObject& prototypeObject)
    {
      // no invariant used
 
      // Do not change the user's "current directory" during any of the
      // following...
      DirectoryReset dirReset;
 
      // Make a clone of the object, and make sure we are already in
      // the right directory if needed
      std::string name = prototypeObject.GetName();
      TDirectory *dir = makeDirectoryFor (name);
      dir->cd();
 
      std::unique_ptr<TObject> clone {prototypeObject.Clone()};
 
      // Hold on to the pointer of the tree in our internal cache.
      addOutput (std::move (clone));
    }
 
 
 
    TDirectory *OutputStreamData ::
    makeDirectoryFor (std::string& name)
    {
      RCU_CHANGE_INVARIANT (this);
 
      TDirectory *result = file();
      std::string::size_type split = name.rfind ("/");
      if (split == std::string::npos)
      {
        return result;
      } else
      {
        const std::string dirname = name.substr (0, split);
        name = name.substr (split + 1);
        TDirectory *subdir = dynamic_cast<TDirectory*>(result->Get (dirname.c_str()));
        if (!subdir)
        {
          result->mkdir (dirname.c_str());
          subdir = dynamic_cast<TDirectory*>(result->Get (dirname.c_str()));
          RCU_ASSERT (subdir != nullptr);
        }
        result = subdir;
        RCU_ASSERT (result != nullptr);
        return result;
      }
    }
 
 
 
    TObject *OutputStreamData ::
    getOutputHist (const std::string& name) const noexcept
    {
      RCU_READ_INVARIANT (this);
 
      auto iter = m_outputHistMap.find (name);
      return iter != m_outputHistMap.end() ? iter->second : nullptr;
    }
 
 
 
    TTree *OutputStreamData ::
    getOutputTree (const std::string& name) const noexcept
    {
      RCU_READ_INVARIANT (this);
 
      auto iter = m_outputTreeMap.find (name);
      return iter != m_outputTreeMap.end() ? iter->second : nullptr;
    }
  }
}