TRestEventProcess.h

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
#ifndef RestCore_TRestEventProcess
#define RestCore_TRestEventProcess
 
#include <TCanvas.h>
#include <TNamed.h>
 
#include <limits>
 
#include "TRestAnalysisTree.h"
#include "TRestEvent.h"
#include "TRestMetadata.h"
#include "TRestRun.h"
 
class TRestEventProcess : public TRestMetadata {
   protected:
    enum REST_Process_Output {
        No_Output,     
        Observable,    
        Internal_Var,  
        Full_Output,   
    };
 
   private:
    // unused datamember, set as private
    TRestEvent* fInputEvent = nullptr;  
    TRestEvent* fOutputEvent = nullptr;  
    REST_Process_Output fOutputLevel;  
 
    std::vector<TRestEventProcess*> fFriendlyProcesses;  
    std::vector<TRestEventProcess*> fParallelProcesses;  
   protected:
    TCanvas* fCanvas = nullptr;  
    TVector2 fCanvasSize;  
    TRestAnalysisTree* fAnalysisTree = nullptr;  
    TRestRun* fRunInfo = nullptr;  
    bool fIsExternal = false;  
    bool fSingleThreadOnly = false;  
    bool fReadOnly = false;  
    bool fDynamicObs = false;  
    bool fValidateObservables = false;  
    std::map<std::string, int> fObservablesUpdated;  
    std::map<std::string, int> fObservablesDefined;  
    std::vector<std::pair<std::string, TVector2>> fCuts;  
 
    // utils
    void BeginPrintProcess();
    void EndPrintProcess();
    template <class T>
    inline T* GetMetadata() {
        std::string type = REST_Reflection::GetTypeName<T>();
        return (T*)GetMetadata(type);
    }
    TRestMetadata* GetMetadata(const std::string& nameOrType);
    TRestEventProcess* GetFriend(const std::string& nameOrType);
    TRestEventProcess* GetFriendLive(const std::string& nameOrType);
    inline size_t GetNumberOfParallelProcesses() const { return fParallelProcesses.size(); }
    TRestEventProcess* GetParallel(int i);
    template <class T>
    std::vector<T> GetParallelDataMembers(T* member_of_process) {
        std::vector<T> result;
        int offset = (int)((char*)member_of_process - (char*)this);
        if (offset <= 0 || offset > this->IsA()->GetClassSize()) {
            std::cout << this->ClassName() << "::GetParallelDataMembers(): invalid object input!"
                      << std::endl;
            return result;
        }
        for (int i = 0; i < GetNumberOfParallelProcesses(); i++) {
            char* proc = (char*)GetParallel(i);
            if (proc == (char*)this) continue;
 
            result.push_back(*(T*)(proc + offset));
        }
        return result;
    }
    template <class T>
    inline void SetObservableValue(const std::string& name, const T& value) {
        if (fAnalysisTree == nullptr) {
            return;
        }
 
        std::string obsName = std::string(this->GetName()) + "_" + name;
        if (name == "t1t2") std::cout << "Observable: " << obsName << std::endl;
 
        if (fValidateObservables) {
            int id = fAnalysisTree->GetObservableID(obsName);
            std::cout << "Id: " << id << std::endl;
 
            if (id != -1) {
                fObservablesDefined[obsName] = id;
                fObservablesUpdated[obsName] = id;
                fAnalysisTree->SetObservable(obsName, value);
            } else if (fDynamicObs) {
                fAnalysisTree->SetObservable(obsName, value);
                int n = fAnalysisTree->GetObservableID(obsName);
                if (n != -1) {
                    fObservablesDefined[obsName] = id;
                    fObservablesUpdated[obsName] = id;
                }
            }
        } else {
            int id = fAnalysisTree->GetObservableID(obsName);
            if (id != -1) {
                fAnalysisTree->SetObservableValue(id, value);
            } else if (fDynamicObs) {
                fAnalysisTree->SetObservableValue(obsName, value);
            }
        }
    }
 
    template <class T>
    T GetObservableValue(const std::string& name) {
        if (fAnalysisTree != nullptr) {
            return fAnalysisTree->GetObservableValue<T>(name);
        }
        return std::numeric_limits<T>::quiet_NaN();
    }
 
    inline void CreateCanvas() {
        if (fCanvas != nullptr) {
            return;
        }
        fCanvas = new TCanvas(this->GetName(), this->GetTitle(), fCanvasSize.X(), fCanvasSize.Y());
    }
 
   public:
    bool ApplyCut();
 
    virtual const char* GetProcessName() const = 0;
    Int_t LoadSectionMetadata() override;
    virtual void InitFromConfigFile() override {
        std::map<std::string, std::string> parameters = GetParametersList();
        for (auto& p : parameters) {
            p.second = ReplaceMathematicalExpressions(fRunInfo->ReplaceMetadataMembers(p.second));
        }
        ReadParametersList(parameters);
    }
    std::vector<std::string> ReadObservables();
    // open a list of input files to be processed, only used if is external process
    virtual Bool_t OpenInputFiles(const std::vector<std::string>& files);
    // add an input file during process
    virtual Bool_t AddInputFile(const std::string& file) { return false; }
    // reset the entry by moving file ptr to 0 with fseek
    virtual Bool_t ResetEntry() { return false; }
 
    inline void SetObservableValidation(bool validate) { fValidateObservables = validate; }
 
    inline void RegisterAllObservables(Bool_t value = true) { fDynamicObs = value; }
 
    // process running methods
    virtual void InitProcess() {}
    virtual void BeginOfEventProcess(TRestEvent* inputEvent = nullptr);
    virtual TRestEvent* ProcessEvent(TRestEvent* inputEvent) = 0;
    virtual void EndOfEventProcess(TRestEvent* inputEvent = nullptr);
    virtual void EndProcess() {}
 
    // setters
    void SetAnalysisTree(TRestAnalysisTree* tree);
    inline void SetRunInfo(TRestRun* r) { fRunInfo = r; }
    inline void SetCanvasSize(Int_t x, Int_t y) { fCanvasSize = TVector2(x, y); }
    void SetFriendProcess(TRestEventProcess* p);
    void SetParallelProcess(TRestEventProcess* p);
    virtual void NotifyAnalysisTreeReset() {}
 
    // getters
    virtual RESTValue GetInputEvent() const = 0;
    virtual RESTValue GetOutputEvent() const = 0;
    virtual Long64_t GetTotalBytes() const { return -1; }
    virtual Long64_t GetTotalBytesRead() const { return 0; }
    inline Bool_t singleThreadOnly() const { return fSingleThreadOnly; }
    inline Bool_t isExternal() const { return fIsExternal; }
    inline TRestRun* GetRunInfo() const { return fRunInfo; }
    inline TRestAnalysisTree* GetAnalysisTree() const { return fAnalysisTree; }
    TRestAnalysisTree* GetFullAnalysisTree();
    inline TCanvas* GetCanvas() const { return fCanvas; }
    std::vector<std::string> GetListOfAddedObservables();
 
    // Constructor
    TRestEventProcess();
    // Destructor
    ~TRestEventProcess();
 
    ClassDefOverride(TRestEventProcess, 3);  // Base class for a REST process
};
 
#define _ApplyCut(evt)              \
    if (ApplyCut()) return nullptr; \
    return evt;
 
#endif