TRestDetectorTriggerAnalysisProcess.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 "TRestDetectorTriggerAnalysisProcess.h"
 
using namespace std;
 
ClassImp(TRestDetectorTriggerAnalysisProcess);
 
TRestDetectorTriggerAnalysisProcess::TRestDetectorTriggerAnalysisProcess() { Initialize(); }
 
TRestDetectorTriggerAnalysisProcess::TRestDetectorTriggerAnalysisProcess(const char* configFilename) {
    Initialize();
    if (LoadConfigFromFile(configFilename)) LoadDefaultConfig();
}
 
TRestDetectorTriggerAnalysisProcess::~TRestDetectorTriggerAnalysisProcess() { delete fSignalEvent; }
 
void TRestDetectorTriggerAnalysisProcess::LoadDefaultConfig() { SetTitle("Default config"); }
 
void TRestDetectorTriggerAnalysisProcess::Initialize() {
    SetSectionName(this->ClassName());
    SetLibraryVersion(LIBRARY_VERSION);
 
    fSignalEvent = new TRestDetectorSignalEvent();
}
 
void TRestDetectorTriggerAnalysisProcess::LoadConfig(const string& configFilename, const string& name) {
    if (LoadConfigFromFile(configFilename, name)) LoadDefaultConfig();
}
 
void TRestDetectorTriggerAnalysisProcess::InitProcess() {
    std::vector<string> fObservables;
    fObservables = TRestEventProcess::ReadObservables();
 
    for (unsigned int i = 0; i < fObservables.size(); i++)
        if (fObservables[i].find("Integral_Eth") != string::npos)
            fIntegralObservables.push_back(fObservables[i]);
 
    for (unsigned int i = 0; i < fIntegralObservables.size(); i++) {
        Double_t th = atof(fIntegralObservables[i].substr(12, fIntegralObservables[i].length() - 12).c_str());
        fThreshold.push_back(th);
    }
}
 
TRestEvent* TRestDetectorTriggerAnalysisProcess::ProcessEvent(TRestEvent* inputEvent) {
    TRestDetectorSignalEvent* fInputSignalEvent = (TRestDetectorSignalEvent*)inputEvent;
    fSignalEvent->SetEventInfo(fInputSignalEvent);
    for (int sgnl = 0; sgnl < fInputSignalEvent->GetNumberOfSignals(); sgnl++)
        fSignalEvent->AddSignal(*fInputSignalEvent->GetSignal(sgnl));
 
    vector<Double_t> integral;
    for (unsigned int i = 0; i < fIntegralObservables.size(); i++) integral.push_back(0);
 
    Int_t maxT = fSignalEvent->GetMaxTime() / fSampling;  // convert to time bin
    Int_t minT = fSignalEvent->GetMinTime() / fSampling;
 
    Int_t triggerStarts = 0;
 
    unsigned int counter = 0;
    unsigned int nObs = fIntegralObservables.size();
    for (int i = minT - fADCLength / 2; i <= maxT && counter < nObs; i++) {
        Double_t en = fSignalEvent->GetIntegralWithTime(i * fSampling, (i + fADCLength / 2) * fSampling);
 
        for (unsigned int n = 0; n < nObs; n++)
            if (integral[n] == 0 && en > fThreshold[n]) {
                // We define the trigger start only for the first threshold definition
                if (n == 0) triggerStarts = i;
                integral[n] = fSignalEvent->GetIntegralWithTime(i * fSampling, (i + fADCLength) * fSampling);
            }
 
        // Break condition
        counter = 0;
        for (unsigned int n = 0; n < nObs; n++)
            if (integral[n] > 0) counter++;
    }
 
    for (unsigned int i = 0; i < nObs; i++) {
        SetObservableValue(fIntegralObservables[i], integral[i]);
    }
 
    Double_t full = fSignalEvent->GetIntegralWithTime(minT * fSampling - 1, maxT * fSampling + 1);
 
    SetObservableValue("RawIntegral", full);
    SetObservableValue("TriggerStarts", triggerStarts);
 
    if (fSignalEvent->GetNumberOfSignals() <= 0) return fSignalEvent;
 
    return fSignalEvent;
}