RootInputModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Heck, Christian Pulvermacher, Thomas Kuhr         *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/DataStore.h>
#include <framework/core/Environment.h>
#include <framework/dataobjects/FileMetaData.h>
#include <framework/dataobjects/EventMetaData.h>
 
#include <string>
#include <vector>
#include <set>
 
#include <TChain.h>
#include <TFile.h>
 
 
namespace Belle2 {
  class RootInputModule : public Module {
  public:
 
    RootInputModule();
 
    virtual ~RootInputModule();
 
    virtual void initialize() override;
 
    virtual void event() override;
 
    virtual void terminate() override;
 
    virtual std::vector<std::string> getFileNames(bool outputFiles = false) override
    {
      B2ASSERT("RootInput is not an output module", !outputFiles);
      std::vector<std::string> inputFiles = Environment::Instance().getInputFilesOverride();
      if (!m_ignoreCommandLineOverride and !inputFiles.empty()) {
        return inputFiles;
      }
      inputFiles = m_inputFileNames;
      if (!m_inputFileName.empty())
        inputFiles.push_back(m_inputFileName);
      return inputFiles;
    }
 
  protected:
 
 
  private:
    typedef std::vector<DataStore::StoreEntry*> StoreEntries;   
    void readTree();
 
    bool connectBranches(TTree* tree, DataStore::EDurability durability, StoreEntries* storeEntries);
 
    bool createParentStoreEntries();
 
    bool readParentTrees();
 
    void readPersistentEntry(long fileEntry);
 
    void entryNotFound(const std::string& entryOrigin, const std::string& name, bool fileChanged = true);
 
    void addEventListForIndexFile(const std::string& parentLfn);
 
    void realDataWorkaround(FileMetaData& metaData);
 
    //first the steerable variables:
    std::string m_inputFileName;
 
    std::vector<std::string> m_inputFileNames;
 
    std::vector<std::string> m_entrySequences;
 
    bool m_ignoreCommandLineOverride;
 
    std::vector<std::string> m_branchNames[DataStore::c_NDurabilityTypes];
 
    std::vector<std::string> m_excludeBranchNames[DataStore::c_NDurabilityTypes];
 
 
    unsigned int m_skipNEvents;
 
    int m_parentLevel;
 
    bool m_collectStatistics;
 
    std::vector<int> m_skipToEvent;
 
    //then those for purely internal use:
 
    long m_nextEntry;
 
    long m_lastPersistentEntry;
 
    std::string m_lastParentFileLFN;
 
 
    TChain* m_tree;
 
    TChain* m_persistent;
 
    std::set<std::string> m_connectedBranches[DataStore::c_NDurabilityTypes];
 
    StoreEntries m_storeEntries;
    StoreEntries m_persistentStoreEntries;
 
    std::vector<StoreEntries> m_parentStoreEntries;
 
    std::map<std::string, TTree*> m_parentTrees;
 
    struct ReadStats {
      long calls{0}; 
      long bytesRead{0}; 
      long bytesReadExtra{0}; 
      void add(const ReadStats& b)
      {
        calls += b.calls;
        bytesRead += b.bytesRead;
        bytesReadExtra += b.bytesReadExtra;
      }
      void addFromFile(const TFile* f)
      {
        calls += f->GetReadCalls();
        bytesRead += f->GetBytesRead();
        bytesReadExtra += f->GetBytesReadExtra();
      }
      std::string getString() const
      {
        std::string s;
        s += "read: " + std::to_string(bytesRead) + " Bytes";
        s += ", overhead: " + std::to_string(bytesReadExtra) + " Bytes";
        s += ", Read() calls: " + std::to_string(calls);
        return s;
      }
    };
 
    ReadStats m_readStats;
 
    int m_cacheSize{0};
 
    bool m_discardErrorEvents{true};
    unsigned int m_discardErrorMask{EventMetaData::c_HLTDiscard};
 
    bool m_processingAllEvents{true};
  };
} // end namespace Belle2