TRestRawFeminosRootToSignalProcess.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 "TRestRawFeminosRootToSignalProcess.h"
 
using namespace std;
 
ClassImp(TRestRawFeminosRootToSignalProcess);
 
TRestRawFeminosRootToSignalProcess::TRestRawFeminosRootToSignalProcess() { Initialize(); }
 
TRestRawFeminosRootToSignalProcess::TRestRawFeminosRootToSignalProcess(const char* configFilename) {
    Initialize();
}
 
TRestRawFeminosRootToSignalProcess::~TRestRawFeminosRootToSignalProcess() {}
 
void TRestRawFeminosRootToSignalProcess::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 TRestRawFeminosRootToSignalProcess::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 << "TRestRawFeminosRootToSignalProcess::InitProcess: Input file is not a root file" << endl;
        exit(1);
    }
 
    fInputFile = TFile::Open(inputFilename.c_str(), "READ");
    if (!fInputFile) {
        cerr << "TRestRawFeminosRootToSignalProcess::InitProcess: Error opening input file" << endl;
        exit(1);
    }
    fInputFile->cd();
 
    fInputRunTree = fInputFile->Get<TTree>("run");
    fInputEventTree = fInputFile->Get<TTree>("events");
 
    if (!fInputRunTree || !fInputEventTree) {
        cerr << "TRestRawFeminosRootToSignalProcess::InitProcess: Error opening input trees" << endl;
        exit(1);
    }
 
    if (fUseFeminosDaqRunInfo) {
        ULong64_t startTimeStampMilliseconds = 0;
        ULong64_t runNumber = 0;
        std::string* runTag = new std::string();
        std::string* runDescription = new std::string();
        fInputRunTree->SetBranchAddress("timestamp", &startTimeStampMilliseconds);
        fInputRunTree->SetBranchAddress("number", &runNumber);
        fInputRunTree->SetBranchAddress("tag", &runTag);
        fInputRunTree->SetBranchAddress("comments", &runDescription);
 
        /* // Unused because they cannot be set in the run info
        std::string* runComment = new std::string();
        fInputRunTree->SetBranchAddress("comments", &runComment);
        std::string* runDetector = new std::string();
        fInputRunTree->SetBranchAddress("detector", &runDetector);
        Float_t driftField = 0;
        fInputRunTree->SetBranchAddress("drift_field_V_cm_bar", &driftField);
        Float_t meshVoltage = 0;
        fInputRunTree->SetBranchAddress("mesh_voltage_V", &meshVoltage);
        Float_t detectorPressure = 0;
        fInputRunTree->SetBranchAddress("detector_pressure_bar", &detectorPressure);
        */
 
        // retrieve row 0
        fInputRunTree->GetEntry(0);
 
        // set run info
        Double_t startTimeStamp = startTimeStampMilliseconds / 1000.0;  // convert ms to seconds
        fRunInfo->SetStartTimeStamp(startTimeStamp);
        fRunInfo->SetRunNumber(runNumber);
        // mclient sets the run tag and description to "\n" if they are empty
        if (*runTag == "\n") {
            runTag->clear();
        }
        if (*runDescription == "\n") {
            runDescription->clear();
        }
        fRunInfo->SetRunTag(*runTag);
        fRunInfo->SetRunDescription(*runDescription);
        fRunInfo->SetFeminosDaqTotalEvents(fInputEventTree->GetEntries());
    }
 
    fInputEventTree->SetBranchAddress("timestamp", &fInputEventTreeTimestamp);
    fInputEventTree->SetBranchAddress("signal_ids", &fInputEventTreeSignalIds);
    fInputEventTree->SetBranchAddress("signal_values", &fInputEventTreeSignalValues);
}
 
TRestEvent* TRestRawFeminosRootToSignalProcess::ProcessEvent(TRestEvent* inputEvent) {
    fSignalEvent->Initialize();
 
    fInputEventTree->GetEntry(fInputTreeEntry);
 
    fSignalEvent->SetID(fInputTreeEntry);
 
    // fInputEventTreeTimestamp is in milliseconds and TRestEvent::SetTime(seconds, nanoseconds)
    fSignalEvent->SetTime(fInputEventTreeTimestamp / 1000, fInputEventTreeTimestamp % 1000 * 1000000);
 
    // get the first event timestamp (if we are not using FeminosDaq run info where this is set from the run
    // tree)
    if (!fUseFeminosDaqRunInfo && fInputEventTreeTimestamp < fStartTimestamp) {
        fStartTimestamp = fInputEventTreeTimestamp;
    }
    // get the last event timestamp
    if (fInputEventTreeTimestamp > fEndTimestamp) {
        fEndTimestamp = fInputEventTreeTimestamp;
    }
 
    for (size_t i = 0; i < fInputEventTreeSignalIds->size(); i++) {
        auto signal = TRestRawSignal();
        signal.Initialize();
 
        const auto id = fInputEventTreeSignalIds->at(i);
        signal.SetID(id);
 
        for (int j = 0; j < 512; j++) {
            signal.AddPoint(short(fInputEventTreeSignalValues->at(i * 512 + j)));
        }
 
        fSignalEvent->AddSignal(signal);
    }
 
    fInputTreeEntry += 1;
 
    if (fInputTreeEntry >= fInputEventTree->GetEntries()) {
        return nullptr;
    }
 
    return fSignalEvent;
}
 
void TRestRawFeminosRootToSignalProcess::EndProcess() {
    // use first event timestamp as start of run if we are not using FeminosDaq run info
    if (!fUseFeminosDaqRunInfo) {
        fRunInfo->SetStartTimeStamp(fStartTimestamp / 1000.0);  // convert from ms to s
    }
    // use last event timestamp as end of run
    fRunInfo->SetEndTimeStamp(fEndTimestamp / 1000.0);  // convert from ms to s
}