TRestEventProcess.cxx

/*************************************************************************
 * 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.                  *
 *************************************************************************/
 
 
#include "TRestEventProcess.h"
 
#include <TBuffer.h>
#include <TClass.h>
#include <TDataMember.h>
 
#include "TRestManager.h"
#include "TRestRun.h"
 
using namespace std;
 
ClassImp(TRestEventProcess);
 
TRestEventProcess::TRestEventProcess() {
    fObservablesDefined.clear();
    fObservablesUpdated.clear();
    fSingleThreadOnly = false;
    fCanvasSize = TVector2(800, 600);
}
 
TRestEventProcess::~TRestEventProcess() {}
 
vector<string> TRestEventProcess::ReadObservables() {
    std::cout << "Entering ReadObservables" << std::endl;
    TiXmlElement* e = GetElement("observable");
    vector<string> obsNames;
    vector<string> obsTypes;
    vector<string> obsDesc;
 
    while (e != nullptr) {
        const char* obschr = e->Attribute("name");
        const char* _value = e->Attribute("value");
        const char* _type = e->Attribute("type");
        const char* _desc = e->Attribute("description");
 
        std::cout << "Name: " << obschr << std::endl;
 
        string value;
        if (_value == nullptr)
            value = "ON";
        else
            value = _value;
        string type;
        if (_type == nullptr)
            type = "double";
        else
            type = _type;
        string description;
        if (_desc == nullptr)
            description = "";
        else
            description = _desc;
 
        if (ToUpper(value) == "ON") {
            if (obschr != nullptr) {
                RESTDebug << this->ClassName() << " : setting observable \"" << obschr << "\"" << RESTendl;
                // vector<string> tmp = Split(obsstring, ":");
                obsNames.emplace_back(obschr);
                obsTypes.push_back(type);
                obsDesc.push_back(description);
            }
        }
 
        e = e->NextSiblingElement("observable");
 
    }  // now we get a list of all observal names, we add them into fAnalysisTree and fObservableInfo
 
    for (unsigned int i = 0; i < obsNames.size(); i++) {
        string obsName = this->GetName() + (string) "_" + obsNames[i];
        std::cout << "ADDING OBSERVABLE : " << obsName << std::endl;
        fAnalysisTree->AddObservable(obsName, obsTypes[i], obsDesc[i]);
        int id = fAnalysisTree->GetObservableID(obsName);
        if (id != -1) {
            fObservablesDefined[(string)GetName() + "_" + obsNames[i]] = id;
        }
    }
 
    return obsNames;
}
 
void TRestEventProcess::SetAnalysisTree(TRestAnalysisTree* tree) {
    fAnalysisTree = tree;
    if (fAnalysisTree == nullptr) return;
    ReadObservables();
}
 
void TRestEventProcess::SetFriendProcess(TRestEventProcess* p) {
    if (p == nullptr) return;
    for (const auto& fFriendlyProcess : fFriendlyProcesses) {
        if (fFriendlyProcess->GetName() == p->GetName()) {
            return;
        }
    }
    fFriendlyProcesses.push_back(p);
}
 
void TRestEventProcess::SetParallelProcess(TRestEventProcess* p) {
    if (p == nullptr) return;
    for (const auto& fParallelProcess : fParallelProcesses) {
        if (fParallelProcess == p || this == p) {
            return;
        }
    }
    fParallelProcesses.push_back(p);
}
 
Bool_t TRestEventProcess::OpenInputFiles(const vector<string>& files) { return false; }
 
Int_t TRestEventProcess::LoadSectionMetadata() {
    TRestMetadata::LoadSectionMetadata();
 
    if (ToUpper(GetParameter("observable", "")) == "ALL" ||
        ToUpper(GetParameter("observables", "")) == "ALL") {
        fDynamicObs = true;
    }
 
    // load cuts
    fCuts.clear();
    if (ToUpper(GetParameter("cutsEnabled", "false")) == "TRUE") {
        TiXmlElement* ele = fElement->FirstChildElement();
        while (ele != nullptr) {
            if (ele->Value() != nullptr && (string)ele->Value() == "cut") {
                if (ele->Attribute("name") != nullptr && ele->Attribute("value") != nullptr) {
                    string name = ele->Attribute("name");
                    name = (string)this->GetName() + "_" + name;
                    TVector2 value = StringTo2DVector(ele->Attribute("value"));
                    if (value.X() != value.Y()) fCuts.push_back(pair<string, TVector2>(name, value));
                }
            }
 
            else if (ele->Value() != nullptr && (string)ele->Value() == "parameter") {
                if (ele->Attribute("name") != nullptr && ele->Attribute("value") != nullptr) {
                    string name = ele->Attribute("name");
                    if (name.find("Cut") == name.size() - 3 || name.find("CutRange") == name.size() - 8) {
                        name = name.substr(0, name.find("Cut") + 3);
                        TVector2 value = StringTo2DVector(ele->Attribute("value"));
                        if (value.X() != value.Y()) fCuts.push_back(pair<string, TVector2>(name, value));
                    }
                }
            }
 
            ele = ele->NextSiblingElement();
        }
    }
 
    return 0;
}
 
TRestMetadata* TRestEventProcess::GetMetadata(const string& name) {
    TRestMetadata* m = nullptr;
    if (fRunInfo != nullptr) {
        m = fRunInfo->GetMetadata(name);
        if (m == nullptr) m = fRunInfo->GetMetadataClass(name);
    }
    if (fHostmgr != nullptr) {
        if (m == nullptr) m = fHostmgr->GetMetadata(name);
        if (m == nullptr) m = fHostmgr->GetMetadataClass(name);
    }
    return m;
}
 
TRestEventProcess* TRestEventProcess::GetFriend(const string& nameOrType) {
    TRestEventProcess* proc = GetFriendLive(nameOrType);
    if (proc == nullptr) {
        TRestMetadata* friendfromfile = GetMetadata(nameOrType);
        if (friendfromfile != nullptr && friendfromfile->InheritsFrom("TRestEventProcess")) {
            return (TRestEventProcess*)friendfromfile;
        }
        return nullptr;
    } else {
        return proc;
    }
}
 
TRestEventProcess* TRestEventProcess::GetFriendLive(const string& nameOrType) {
    for (const auto& fFriendlyProcess : fFriendlyProcesses) {
        if ((string)fFriendlyProcess->GetName() == nameOrType ||
            (string)fFriendlyProcess->ClassName() == nameOrType) {
            return fFriendlyProcess;
        }
    }
    return nullptr;
}
 
TRestEventProcess* TRestEventProcess::GetParallel(int i) {
    if (i >= 0 && i < (int)fParallelProcesses.size()) {
        return fParallelProcesses[i];
    }
    return nullptr;
}
 
bool TRestEventProcess::ApplyCut() {
    for (auto cut : fCuts) {
        string type = (string)fAnalysisTree->GetObservableType(cut.first);
        if (fAnalysisTree != nullptr && type == "double") {
            double val = fAnalysisTree->GetObservableValue<double>(cut.first);
            if (val > cut.second.Y() || val < cut.second.X()) {
                return true;
            }
        }
        if (fAnalysisTree != nullptr && type == "int") {
            int val = fAnalysisTree->GetObservableValue<int>(cut.first);
            if (val > cut.second.Y() || val < cut.second.X()) {
                return true;
            }
        }
    }
    return false;
}
 
/*
 
void TRestEventProcess::InitProcess()
{
// virtual function to be executed once at the beginning of process
// (before starting the process of the events)
cout << GetName() << ": Process initialization..." << endl;
}
*/
 
void TRestEventProcess::BeginOfEventProcess(TRestEvent* inEv) {
    RESTDebug << "Entering " << ClassName() << "::BeginOfEventProcess, Initializing output event..."
              << RESTendl;
    if (inEv != nullptr && GetOutputEvent().address != nullptr && (TRestEvent*)GetOutputEvent() != inEv) {
        TRestEvent* outEv = GetOutputEvent();
        outEv->Initialize();
 
        outEv->SetID(inEv->GetID());
        outEv->SetSubID(inEv->GetSubID());
        outEv->SetSubEventTag(inEv->GetSubEventTag());
 
        outEv->SetRunOrigin(inEv->GetRunOrigin());
        outEv->SetSubRunOrigin(inEv->GetSubRunOrigin());
 
        outEv->SetTime(inEv->GetTime());
    }
 
    fObservablesUpdated.clear();
 
    // TODO if fIsExternal and we already have defined the fAnalysisTree run#,
    // evId#, timestamp, etc at the analysisTree we could stamp the output event
    // here.
}
 
/*
 
void TRestEventProcess::ProcessEvent( TRestEvent *inputEvent )
{
// virtual function to be executed for every event to be processed
}
*/
 
void TRestEventProcess::EndOfEventProcess(TRestEvent* inputEvent) {
    RESTDebug << "Entering TRestEventProcess::EndOfEventProcess (" << ClassName() << ")" << RESTendl;
    if (fValidateObservables) {
        if (fObservablesDefined.size() != fObservablesUpdated.size()) {
            for (auto x : fObservablesDefined) {
                if (fObservablesUpdated.count(x.first) == 0) {
                    // the observable is added through <observable section but not set in the process
                    RESTWarning
                        << "The observable  '" << x.first << "' is defined but not set by "
                        << this->ClassName()
                        << ", the event is empty? Makesure all observables are set through ProcessEvent()"
                        << RESTendl;
                }
            }
        }
    }
}
 
/*
 
void TRestEventProcess::EndProcess()
{
// virtual function to be executed once at the end of the process
// (after all events have been processed)
cout << GetName() << ": Process ending..." << endl;
}
*/
 
void TRestEventProcess::BeginPrintProcess() {
    RESTMetadata.setcolor(COLOR_BOLDGREEN);
    RESTMetadata.setborder("||");
    RESTMetadata.setlength(100);
    // metadata << " " << endl;
    cout << endl;
    RESTMetadata << "=" << RESTendl;
    RESTMetadata << "Process : " << ClassName() << RESTendl;
    RESTMetadata << "Name: " << GetName() << "  Title: " << GetTitle()
                 << "  VerboseLevel: " << GetVerboseLevelString() << RESTendl;
    RESTMetadata << " ----------------------------------------------- " << RESTendl;
    RESTMetadata << " " << RESTendl;
 
    if (!fObservablesDefined.empty()) {
        RESTMetadata << " Analysis tree observables added by this process " << RESTendl;
        RESTMetadata << " +++++++++++++++++++++++++++++++++++++++++++++++ " << RESTendl;
    }
 
    auto iter = fObservablesDefined.begin();
    while (iter != fObservablesDefined.end()) {
        RESTMetadata << " ++ " << iter->first << RESTendl;
        iter++;
    }
 
    if (!fObservablesDefined.empty()) {
        RESTMetadata << " +++++++++++++++++++++++++++++++++++++++++++++++ " << RESTendl;
        RESTMetadata << " " << RESTendl;
    }
}
 
void TRestEventProcess::EndPrintProcess() {
    if (fCuts.size() > 0) {
        RESTMetadata << "Cuts enabled" << RESTendl;
        RESTMetadata << "------------" << RESTendl;
 
        auto iter = fCuts.begin();
        while (iter != fCuts.end()) {
            if (iter->second.X() != iter->second.Y())
                RESTMetadata << iter->first << ", range : ( " << iter->second.X() << " , " << iter->second.Y()
                             << " ) " << RESTendl;
            iter++;
        }
    }
 
    RESTMetadata << " " << RESTendl;
    RESTMetadata << "=" << RESTendl;
    RESTMetadata << RESTendl;
    RESTMetadata.resetcolor();
    RESTMetadata.setborder("");
    RESTMetadata.setlength(10000);
}
 
// Double_t TRestEventProcess::GetDoubleParameterFromFriends(string className, string parName) {
//    for (size_t i = 0; i < fFriendlyProcesses.size(); i++)
//        if ((string)fFriendlyProcesses[i]->ClassName() == (string)className)
//            return StringToDouble(fFriendlyProcesses[i]->GetParameter((string)parName));
//
//    return PARAMETER_NOT_FOUND_DBL;
//}
//
// Double_t TRestEventProcess::GetDoubleParameterFromFriendsWithUnits(string className, string parName) {
//    for (size_t i = 0; i < fFriendlyProcesses.size(); i++)
//        if ((string)fFriendlyProcesses[i]->ClassName() == (string)className)
//            return fFriendlyProcesses[i]->GetDblParameterWithUnits((string)parName);
//
//    return PARAMETER_NOT_FOUND_DBL;
//}
 
TRestAnalysisTree* TRestEventProcess::GetFullAnalysisTree() {
    if (fHostmgr != nullptr && fHostmgr->GetProcessRunner() != nullptr)
        return fHostmgr->GetProcessRunner()->GetOutputAnalysisTree();
    return nullptr;
}
 
std::vector<string> TRestEventProcess::GetListOfAddedObservables() {
    vector<string> list;
    auto iter = fObservablesDefined.begin();
    while (iter != fObservablesDefined.end()) {
        list.push_back(iter->first);
        iter++;
    }
    return list;
}