TRestRawFemDAQToSignalProcess.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 "TRestRawFemDAQToSignalProcess.h"
 
#include <TObjString.h>
 
#ifndef NO_YAML_CPP
#include <yaml-cpp/yaml.h>
#endif
 
using namespace std;
 
ClassImp(TRestRawFemDAQToSignalProcess);
 
TRestRawFemDAQToSignalProcess::TRestRawFemDAQToSignalProcess() { Initialize(); }
 
TRestRawFemDAQToSignalProcess::TRestRawFemDAQToSignalProcess(const char* configFilename) { Initialize(); }
 
TRestRawFemDAQToSignalProcess::~TRestRawFemDAQToSignalProcess() {}
 
void TRestRawFemDAQToSignalProcess::Initialize() {
    delete fSignalEvent;
    fSignalEvent = new TRestRawSignalEvent();
 
    fIsExternal = true;  // We need this in order to prevent error since we are not reading a rest root file
    fSingleThreadOnly = true;
}
 
void TRestRawFemDAQToSignalProcess::InitProcess() {
    // print input aqs file
    const auto inputFilename = fRunInfo->GetInputFileName(0);
 
    // verify it is a root file reading the last 5 characters
    if (inputFilename.substr(inputFilename.size() - 5) != ".root") {
        cerr << "TRestRawFemDAQToSignalProcess::InitProcess: Input file is not a root file" << endl;
        exit(1);
    }
 
    fInputFile = TFile::Open(inputFilename.c_str(), "READ");
    if (!fInputFile) {
        cerr << "TRestRawFemDAQToSignalProcess::InitProcess: Error opening input file" << endl;
        exit(1);
    }
    fInputFile->cd();
 
    fInputTree = fInputFile->Get<TTree>("SignalEvent");
    fRunInfo->SetFeminosDaqTotalEvents(fInputTree->GetEntries());
 
    if (!fInputTree) {
        cerr << "TRestRawFemDAQToSignalProcess::InitProcess: Error opening input trees" << endl;
        exit(1);
    }
 
    TObjString* tsObj = (TObjString*)fInputFile->Get("startTime");
    TObjString* etObj = (TObjString*)fInputFile->Get("endTime");
    if (tsObj) {
        Double_t startTimestamp = std::stod(tsObj->GetString().Data());
        fRunInfo->SetStartTimeStamp(startTimestamp);
    }
    if (etObj) {
        Double_t endTimestamp = std::stod(etObj->GetString().Data());
        fRunInfo->SetEndTimeStamp(endTimestamp);
    }
 
#ifndef NO_YAML_CPP
    if (fUseFeminosDaqRunInfo) {
        TObjString* yamlConfigObj = (TObjString*)fInputFile->Get("RunConfigYAML");
        TObjString* yamlfNameObj = (TObjString*)fInputFile->Get("yaml_fileName");
 
        if (yamlConfigObj) {
            std::string yamlConfig = yamlConfigObj->GetString().Data();
            std::cout << "Config YAML: " << yamlConfig << std::endl;
            YAML::Node config = YAML::Load(yamlConfig);
            YAML::Node run = config["run"];
            // std::string exp  = run["experiment"].as<std::string>();
            // fRunInfo->fExperimentName = (TString)exp;
            std::string tag = run["tag"].as<std::string>();
            fRunInfo->SetRunTag(tag);
            std::string type = run["type"].as<std::string>();
            fRunInfo->SetRunType(type);
            // TODO Add run info?
        }
 
        if (yamlfNameObj) {
            std::string fileName = yamlfNameObj->GetString().Data();
            std::cout << "Config fileName: " << fileName << std::endl;
        }
    }
#else
    fUseFeminosDaqRunInfo = false;
#endif
 
    fInputTree->SetBranchAddress("timestamp", &fTimestamp);
    fInputTree->SetBranchAddress("signalsID", &fSignalIds);
    fInputTree->SetBranchAddress("pulses", &fSignalValues);
    fInputTree->SetBranchAddress("eventID", &fEventID);
}
 
TRestEvent* TRestRawFemDAQToSignalProcess::ProcessEvent(TRestEvent* inputEvent) {
    fSignalEvent->Initialize();
 
    fInputTree->GetEntry(fInputTreeEntry);
 
    fSignalEvent->SetID(fEventID);
 
    // fTimestamp is in seconds
    fSignalEvent->SetTime(fTimestamp);
 
    // get the first event timestamp
    if (fTimestamp < fStartTimestamp) {
        fStartTimestamp = fTimestamp;
    }
    // get the last event timestamp
    if (fTimestamp > fEndTimestamp) {
        fEndTimestamp = fTimestamp;
    }
 
    for (size_t i = 0; i < fSignalIds->size(); i++) {
        auto signal = TRestRawSignal();
        signal.Initialize();
 
        const auto id = fSignalIds->at(i);
        signal.SetID(id);
 
        for (int j = 0; j < 512; j++) {
            signal.AddPoint(short(fSignalValues->at(i * 512 + j)));
        }
 
        fSignalEvent->AddSignal(signal);
    }
 
    fInputTreeEntry++;
 
    if (fInputTreeEntry >= fInputTree->GetEntries()) {
        return nullptr;
    }
 
    return fSignalEvent;
}
 
void TRestRawFemDAQToSignalProcess::EndProcess() {
    if (fSetRunStartEndFromEvents) {
        fRunInfo->SetStartTimeStamp(fStartTimestamp);
        fRunInfo->SetEndTimeStamp(fEndTimestamp);
    }
}