StorageRootOutputModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/core/Environment.h>
#include <framework/datastore/DataStore.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/dataobjects/FileMetaData.h>
#include <framework/dataobjects/EventMetaData.h>
 
#include <TFile.h>
#include <TTree.h>
 
#include <optional>
#include <string>
#include <vector>
 
// For online storage
#include <daq/slc/database/DBInterface.h>
#include <daq/slc/psql/PostgreSQLInterface.h>
 
namespace Belle2 {
  class StorageRootOutputModule : public Module {
 
  public:
 
    StorageRootOutputModule();
 
    virtual ~StorageRootOutputModule();
 
    virtual void initialize() override;
 
    virtual void endRun() override;
 
    virtual void event() override;
 
    virtual void terminate() override;
 
    virtual std::vector<std::string> getFileNames(bool outputFiles = true) override
    {
      B2ASSERT("StorageRootOutput is not an input module", outputFiles);
      if (!m_ignoreCommandLineOverride) {
        // This will warn if already consumed which is what we want
        std::string outputFileArgument = Environment::Instance().consumeOutputFileOverride(getName());
        if (!outputFileArgument.empty())
          m_outputFileName = outputFileArgument;
        m_ignoreCommandLineOverride = true;
      }
      return {m_outputFileName};
    }
 
  private:
 
    void closeFile();
 
    void openFile();
 
    void fillTree(DataStore::EDurability durability);
 
    void fillFileMetaData();
 
    //first the steerable variables:
 
    std::string m_outputFileName;
 
    std::vector<std::string> m_branchNames[DataStore::c_NDurabilityTypes];
 
    std::vector<std::string> m_additionalBranchNames[DataStore::c_NDurabilityTypes];
 
    std::vector<std::string> m_excludeBranchNames[DataStore::c_NDurabilityTypes];
 
    int m_compressionAlgorithm{0};
 
    int m_compressionLevel{1};
 
    int m_splitLevel;
 
    int m_autoflush;
 
    int m_autosave;
 
    int m_basketsize;
 
    bool m_updateFileCatalog;
 
    bool m_ignoreCommandLineOverride;
 
    std::optional<uint64_t> m_outputSplitSize{std::nullopt};
 
    //then those for purely internal use:
 
    int m_fileIndex{0};
 
    unsigned int m_nFullEvents{0};
 
    TFile* m_file;
 
    TTree* m_tree[DataStore::c_NDurabilityTypes];
 
    std::vector<DataStore::StoreEntry*> m_entries[DataStore::c_NDurabilityTypes];
 
    std::vector<std::string> m_parentLfns;
 
    std::map<std::string, std::string> m_additionalDataDescription;
 
    unsigned long m_experimentLow;
 
    unsigned long m_runLow;
 
    unsigned long m_eventLow;
 
    unsigned long m_experimentHigh;
 
    unsigned long m_runHigh;
 
    unsigned long m_eventHigh;
 
    bool m_buildIndex{false};
 
    bool m_keepParents{false};
 
    bool m_regularFile{true};
 
    StoreObjPtr<EventMetaData> m_eventMetaData;
    StoreObjPtr<FileMetaData> m_fileMetaData{"", DataStore::c_Persistent};
    FileMetaData* m_outputFileMetaData;
 
    int m_expno{0};
    int m_runno{0};
    DBInterface* m_db;
    std::string m_runType;
    std::string m_HLTName;
    std::string m_disk;
    int m_nDisk;
    int m_processNumber;
    bool m_firstEvent{false};
    bool m_ramdiskBuffer{false};
  };
} // end namespace Belle2