FairRootManager.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#ifndef FAIR_ROOT_MANAGER_H
#define FAIR_ROOT_MANAGER_H

#include "FairLogger.h"
#include "FairSink.h"
#include "FairSource.h"

#include <Rtypes.h>    // for Bool_t, Int_t, UInt_t, etc
#include <TChain.h>    // for TChain
#include <TMCtls.h>    // for multi-threading
#include <TObject.h>   // for TObject
#include <TString.h>   // for TString, operator<
#include <map>         // for map, multimap, etc
#include <memory>
#include <string>
#include <type_traits>   // is_pointer, remove_pointer, is_const, remove...
#include <typeinfo>
#include <vector>

class BinaryFunctor;
class FairEventHeader;
class FairFileHeader;
class FairLink;
class FairTSBufferFunctional;
class FairWriteoutBuffer;
class TBranch;
class TClonesArray;
class TObjArray;
class TCollection;
class TFile;
class TFolder;
class TIterator;
class TList;
class TNamed;
class TRefArray;
class TTree;

class FairRootManager : public TObject
{
  public:
    virtual ~FairRootManager();
    Bool_t AllDataProcessed();
    Int_t AddBranchToList(const char* name);
    Int_t CheckBranch(const char* BrName);

    void CloseSink()
    {
        if (fSink) {
            fSink->Close();
        }
    }
    void CreateGeometryFile(const char* geofile);
    void Fill();
    void LastFill();
    TClonesArray* GetEmptyTClonesArray(TString branchName);
    TClonesArray* GetTClonesArray(TString branchName);
    void UpdateBranches();

    TString GetBranchName(Int_t id);
    Int_t GetBranchId(TString const& BrName);

    Int_t GetMCTrackBranchId() const { return fMCTrackBranchId; }

    TList* GetBranchNameList() { return fBranchNameList; }
    const std::vector<std::string>& GetReqBranchNames() const { return fReqBrNames; }

    TObject* GetObject(const char* BrName);

    template<typename T>
    T InitObjectAs(const char* BrName);

    Double_t GetEventTime();
    TObject* GetCloneOfLinkData(const FairLink link);
    TClonesArray* GetCloneOfTClonesArray(const FairLink link);

    void InitTSBuffer(TString branchName, BinaryFunctor* function);
    TClonesArray* GetData(TString branchName, BinaryFunctor* function, Double_t parameter);
    TClonesArray* GetData(TString branchName,
                          BinaryFunctor* startFunction,
                          Double_t startParameter,
                          BinaryFunctor* stopFunction,
                          Double_t stopParameter);
    void RegisterTSBuffer(TString branchName, FairTSBufferFunctional* functionalBuffer)
    {
        fTSBufferMap[branchName] = functionalBuffer;
    }
    void TerminateTSBuffer(TString branchName);
    void TerminateAllTSBuffer();
    FairTSBufferFunctional* GetTSBuffer(TString branchName) { return fTSBufferMap[branchName]; }

    static FairRootManager* Instance();

    Int_t ReadEvent(Int_t i = 0);
    Int_t ReadNonTimeBasedEventFromBranches(Int_t i = 0);
    void ReadBranchEvent(const char* BrName);
    void ReadBranchEvent(const char* BrName, Int_t entry);

    Int_t GetRunId();

    Bool_t ReadNextEvent(Double_t dt);
    void Register(const char* name, const char* Foldername, TNamed* obj, Bool_t toFile);
    void Register(const char* name, const char* Foldername, TCollection* obj, Bool_t toFile);

    template<typename T>
    void RegisterAny(const char* name, T*& obj, Bool_t toFile);
    bool CreatePersistentBranchesAny();

    void RegisterInputObject(const char* name, TObject* obj);

    TClonesArray* Register(TString branchName, TString className, TString folderName, Bool_t toFile);
    FairWriteoutBuffer* RegisterWriteoutBuffer(TString branchName, FairWriteoutBuffer* buffer);
    void UpdateListOfTimebasedBranches();
    void RunWithTimeStamps() { fTimeStamps = kTRUE; }

    void SetBranchNameList(TList* list);
    void SetTimeBasedBranchNameList(TList* list);

    void FillEventHeader(FairEventHeader* feh)
    {
        if (fSource)
            fSource->FillEventHeader(feh);
    }

    void SetLastFill(Bool_t val = kTRUE) { fFillLastData = val; }
    Int_t Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0);
    void WriteGeometry();
    void WriteFileHeader(FairFileHeader* f);
    void WriteFolder();

    Int_t CheckMaxEventNo(Int_t EvtEnd = 0);

    void StoreWriteoutBufferData(Double_t eventTime);
    void StoreAllWriteoutBufferData();
    void DeleteOldWriteoutBufferData();

    Int_t GetEntryNr() { return fEntryNr; }
    void SetEntryNr(Int_t val) { fEntryNr = val; }

    void SetUseFairLinks(Bool_t val) { fUseFairLinks = val; };
    Bool_t GetUseFairLinks() const { return fUseFairLinks; };

    /* void SetMixAllInputs(Bool_t Status) { */
    /*    fMixAllInputs=kTRUE; */
    /* } */

    void SetSource(FairSource* tempSource) { fSource = tempSource; }
    FairSource* GetSource() { return fSource; }
    Bool_t InitSource();

    void SetSink(FairSink* tempSink) { fSink = tempSink; }
    FairSink* GetSink() { return fSink; }
    Bool_t InitSink();

    void SetListOfFolders(TObjArray* ta) { fListFolder = ta; }
    TChain* GetInChain() { return fSourceChain; }
    TChain* GetSignalChainNo(UInt_t i) { return fSignalChainList[i]; }
    TTree* GetInTree()
    {
        if (fSourceChain)
            return fSourceChain->GetTree();
        return 0;
    }
    const TFile* GetRootFile()
    {
        if (fSourceChain)
            return fSourceChain->GetFile();
        return 0;
    }
    TFile* GetInFile()
    {
        if (fSourceChain)
            return fSourceChain->GetFile();
        return 0;
    }
    void SetInChain(TChain* tempChain, Int_t ident = -1);
    /* /\**Set the input tree when running on PROOF worker*\/ */

    void SetFinishRun(Bool_t val = kTRUE) { fFinishRun = val; }
    Bool_t FinishRun() { return fFinishRun; }

    static char* GetTreeName();

    static char* GetFolderName();

    Int_t GetInstanceId() const { return fId; }
    void UpdateFileName(TString& fileName);

    // vvvvvvvvvv depracted functions, replaced by FairSink vvvvvvvvvv
    TFile* GetOutFile();
    TTree* GetOutTree();
    // ^^^^^^^^^^ depracted functions, replaced by FairSink ^^^^^^^^^^

    Bool_t SpecifyRunId();

  private:
    // helper struct since std::pair has problems with type_info
    struct TypeAddressPair
    {
        TypeAddressPair(const std::type_info& oi, const std::type_info& pi, void* a)
            : origtypeinfo(oi)
            , persistenttypeinfo(pi)
            , ptraddr(a)
        {}
        const std::type_info& origtypeinfo;         // type_info of type addr points to
        const std::type_info& persistenttypeinfo;   // type_info of ROOT persistent branch (drops pointers)
        void* ptraddr;                              // address of a pointer (pointing to origtypeinfo);
    };

    FairRootManager();
    FairRootManager(const FairRootManager&);
    FairRootManager& operator=(const FairRootManager&);
    TObject* ActivateBranch(const char* BrName);
    void AddFriends();
    void AddMemoryBranch(const char*, TObject*);

    template<typename T>
    void AddMemoryBranchAny(const char* name, T** obj);
    template<typename T>
    T GetMemoryBranchAny(const char* name) const;

    template<typename T>
    void RegisterImpl(const char* name, const char* Foldername, T* obj, Bool_t toFile);

    Int_t CheckBranchSt(const char* BrName);
    void CreatePerMap();
    TObject* GetMemoryBranch(const char*);
    //   void                GetRunIdInfo(TString fileName, TString inputLevel);

    FairWriteoutBuffer* GetWriteoutBuffer(TString branchName);

    // private helper function to emit a warning
    void EmitMemoryBranchWrongTypeWarning(const char* brname, const char* typen1, const char* typen2) const;

    Int_t fOldEntryNr;
    TFolder* fOutFolder;
    TFolder* fRootFolder;
    Double_t fCurrentTime;
    TObject** fObj2;   

    Int_t fNObj;   

    std::map<TString, TObject*> fMap;   

    std::map<std::string, std::unique_ptr<TypeAddressPair const>> fAnyBranchMap;   
    std::vector<std::string> fPersistentBranchesAny;

    Int_t fBranchSeqId;
    TList* fBranchNameList;   

    std::vector<std::string> fReqBrNames;   

    Int_t fMCTrackBranchId;   

    TList* fTimeBasedBranchNameList;   

    std::map<TString, TClonesArray*> fActiveContainer;
    std::map<TString, FairTSBufferFunctional*> fTSBufferMap;     
    std::map<TString, FairWriteoutBuffer*> fWriteoutBufferMap;   
    std::map<Int_t, TBranch*> fInputBranchMap;                   

    Bool_t fTimeStamps;
    Bool_t fBranchPerMap;
    std::map<TString, Int_t> fBrPerMap;   

    std::map<TString, Int_t>::iterator fBrPerMapIter;

    UInt_t fCurrentEntryNo;   

    UInt_t fTimeforEntryNo;   
    Bool_t fFillLastData;     
    Int_t fEntryNr;           

    TObjArray* fListFolder;   

    FairSource* fSource;

    TChain* fSourceChain;
    std::map<UInt_t, TChain*> fSignalChainList;   

    FairEventHeader* fEventHeader;

    FairSink* fSink;

    Bool_t fUseFairLinks;   
    Bool_t fFinishRun;      

    TObjArray* fListOfBranchesFromInput;   

    TIterator* fListOfBranchesFromInputIter;   

    TRefArray* fListOfNonTimebasedBranches;   

    TIterator* fListOfNonTimebasedBranchesIter;   

    // global static data members
    static Int_t fgCounter;   // The counter of instances
    // data members
    Int_t fId;   // This manager ID

    ClassDef(FairRootManager, 12);
};

// FIXME: move to source since we can make it non-template dependent
template<typename T>
void FairRootManager::AddMemoryBranchAny(const char* brname, T** obj)
{
    if (fAnyBranchMap.find(brname) == fAnyBranchMap.end()) {
        auto& ot = typeid(T*);
        auto& pt = typeid(T);
        fAnyBranchMap[brname] = std::unique_ptr<TypeAddressPair const>(new TypeAddressPair(ot, pt, (void*)obj));
    }
}

// try to retrieve an object address from the registered branches/names
template<typename T>
T FairRootManager::GetMemoryBranchAny(const char* brname) const
{
    static_assert(std::is_pointer<T>::value, "Return type of GetMemoryBranchAny has to be a pointer");
    using P = typename std::remove_pointer<T>::type;
    auto iter = fAnyBranchMap.find(brname);
    if (iter != fAnyBranchMap.end()) {
        // verify type consistency
        if (typeid(P).hash_code() != iter->second->origtypeinfo.hash_code()) {
            EmitMemoryBranchWrongTypeWarning(brname, typeid(P).name(), iter->second->origtypeinfo.name());
            return nullptr;
        }
        return static_cast<T>(iter->second->ptraddr);
    }
    return nullptr;
}

template<typename T>
void FairRootManager::RegisterAny(const char* brname, T*& obj, bool persistence)
{
    AddBranchToList(brname);
    // we are taking the address of the passed pointer
    AddMemoryBranchAny<T>(brname, &obj);
    if (persistence) {
        auto& ot = typeid(T*);
        auto& pt = typeid(T);
        if (fSink)
            fSink->RegisterAny(brname, ot, pt, &obj);
        else
            LOG(fatal) << "The sink does not exist to store persistent branches.";
    }
}

// this function serves as a factory (or lookup) for memory managed
// instances associated to branches
// it returns a pointer to unmodifiable instance of T
template<typename TPtr>
TPtr FairRootManager::InitObjectAs(const char* brname)
{
    static_assert(std::is_pointer<TPtr>::value, "Return type of GetObjectAs has to be a pointer");
    using X = typename std::remove_pointer<TPtr>::type;
    static_assert(std::is_const<X>::value, "Return type of GetObjectAs has to be pointer to const class");
    using T = typename std::remove_const<X>::type;

    // is there already an object associated to the branch in memory??
    // then just return
    T** obj = GetMemoryBranchAny<T**>(brname);
    // obj is some address/instance holding TPtr instances
    if (obj != nullptr)
        return *obj;

    if (!fSource) {
        return nullptr;
    }

    // it does not seem to be the case, let us create the pointer which will be initialized
    // with the data (pointer to T)
    T** addr = new T*;
    // init the pointee to a default obj which we can return
    (*addr) = new T;
    // try to find and activate in the source
    auto succeeded = fSource->ActivateObjectAny((void**)addr, typeid(T), brname);

    if (!succeeded) {
        delete (*addr);
        delete addr;
        return nullptr;
    }
    // add into branch list
    AddMemoryBranchAny<T>(brname, addr);
    // register as a **requested** branch
    // (duplications are explicitely allowed)
    fReqBrNames.emplace_back(brname);

    // NOTE: ideally we would do proper resource management for addr and *addr
    // since the FairRootManager becomes owner of these pointers/instances; Unfortunately this
    // is quite a difficult task since we would have to store something like std::unique_ptr<T> in a member
    // container which we cannot know a priori; Some solutions we could think of in the future are
    // a) use the Destructor mechanism of ROOT::TClass since we still have the type info.
    // b) investigate if boost::any could be of help here
    // In any case, this problem is not very critical in the sense that FairRootManager is a singleton and hence
    // cannot really leak memory (Assuming that the destructors of T are not doing something non-trivial).
    return *addr;
}

#endif   // FAIR_ROOT_MANAGER_H