TRestDetectorSignalChannelActivityProcess.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 "TRestDetectorSignalChannelActivityProcess.h"
 
using namespace std;
 
ClassImp(TRestDetectorSignalChannelActivityProcess);
 
TRestDetectorSignalChannelActivityProcess::TRestDetectorSignalChannelActivityProcess() { Initialize(); }
 
TRestDetectorSignalChannelActivityProcess::TRestDetectorSignalChannelActivityProcess(
    const char* configFilename) {
    Initialize();
 
    if (LoadConfigFromFile(configFilename)) LoadDefaultConfig();
}
 
TRestDetectorSignalChannelActivityProcess::~TRestDetectorSignalChannelActivityProcess() {
    delete fSignalEvent;
}
 
void TRestDetectorSignalChannelActivityProcess::LoadDefaultConfig() { SetTitle("Default config"); }
 
void TRestDetectorSignalChannelActivityProcess::Initialize() {
    SetSectionName(this->ClassName());
    SetLibraryVersion(LIBRARY_VERSION);
 
    fSignalEvent = new TRestDetectorSignalEvent();
}
 
void TRestDetectorSignalChannelActivityProcess::LoadConfig(const string& configFilename, const string& name) {
    if (LoadConfigFromFile(configFilename, name)) LoadDefaultConfig();
}
 
void TRestDetectorSignalChannelActivityProcess::InitProcess() {
    fReadout = GetMetadata<TRestDetectorReadout>();
 
    RESTDebug << "TRestDetectorSignalChannelActivityProcess::InitProcess. Readout pointer : " << fReadout
              << RESTendl;
    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Info && fReadout)
        fReadout->PrintMetadata();
 
    if (!fReadOnly) {
        fDaqChannelsHisto = new TH1D("daqChannelActivity", "daqChannelActivity", fDaqHistogramChannels,
                                     fDaqStartChannel, fDaqEndChannel);
        if (fReadout) {
            fReadoutChannelsHisto =
                new TH1D("rChannelActivity", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_OneSignal =
                new TH1D("rChannelActivity_1", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_OneSignal_High =
                new TH1D("rChannelActivity_1H", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_TwoSignals =
                new TH1D("rChannelActivity_2", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_TwoSignals_High =
                new TH1D("rChannelActivity_2H", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_ThreeSignals =
                new TH1D("rChannelActivity_3", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_ThreeSignals_High =
                new TH1D("rChannelActivity_3H", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_MultiSignals =
                new TH1D("rChannelActivity_M", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
            fReadoutChannelsHisto_MultiSignals_High =
                new TH1D("rChannelActivity_MH", "readoutChannelActivity", fReadoutHistogramChannels,
                         fReadoutStartChannel, fReadoutEndChannel);
        }
    }
}
 
TRestEvent* TRestDetectorSignalChannelActivityProcess::ProcessEvent(TRestEvent* inputEvent) {
    TString obsName;
 
    TRestDetectorSignalEvent* fInputSignalEvent = (TRestDetectorSignalEvent*)inputEvent;
 
 
    fSignalEvent->SetID(fInputSignalEvent->GetID());
    fSignalEvent->SetSubID(fInputSignalEvent->GetSubID());
    fSignalEvent->SetTimeStamp(fInputSignalEvent->GetTimeStamp());
    fSignalEvent->SetSubEventTag(fInputSignalEvent->GetSubEventTag());
 
    Int_t N = fInputSignalEvent->GetNumberOfSignals();
    for (int sgnl = 0; sgnl < N; sgnl++) fSignalEvent->AddSignal(*fInputSignalEvent->GetSignal(sgnl));
 
    Int_t Nlow = 0;
    Int_t Nhigh = 0;
    for (int s = 0; s < fSignalEvent->GetNumberOfSignals(); s++) {
        TRestDetectorSignal* sgnl = fSignalEvent->GetSignal(s);
        if (sgnl->GetMaxValue() > fHighThreshold) Nhigh++;
        if (sgnl->GetMaxValue() > fLowThreshold) Nlow++;
    }
 
    for (int s = 0; s < fSignalEvent->GetNumberOfSignals(); s++) {
        TRestDetectorSignal* sgnl = fSignalEvent->GetSignal(s);
        // Adding signal to the channel activity histogram
        if (!fReadOnly && fReadout) {
            Int_t signalID = fSignalEvent->GetSignal(s)->GetID();
 
            Int_t p, m, readoutChannel;
            fReadout->GetPlaneModuleChannel(signalID, p, m, readoutChannel);
 
            fReadoutChannelsHisto->Fill(readoutChannel);
 
            if (sgnl->GetMaxValue() > fLowThreshold) {
                if (Nlow == 1) fReadoutChannelsHisto_OneSignal->Fill(readoutChannel);
                if (Nlow == 2) fReadoutChannelsHisto_TwoSignals->Fill(readoutChannel);
                if (Nlow == 3) fReadoutChannelsHisto_ThreeSignals->Fill(readoutChannel);
                if (Nlow > 3 && Nlow < 10) fReadoutChannelsHisto_MultiSignals->Fill(readoutChannel);
            }
 
            if (sgnl->GetMaxValue() > fHighThreshold) {
                if (Nhigh == 1) fReadoutChannelsHisto_OneSignal_High->Fill(readoutChannel);
                if (Nhigh == 2) fReadoutChannelsHisto_TwoSignals_High->Fill(readoutChannel);
                if (Nhigh == 3) fReadoutChannelsHisto_ThreeSignals_High->Fill(readoutChannel);
                if (Nhigh > 3 && Nhigh < 10) fReadoutChannelsHisto_MultiSignals_High->Fill(readoutChannel);
            }
        }
 
        if (!fReadOnly) {
            Int_t daqChannel = fSignalEvent->GetSignal(s)->GetID();
            fDaqChannelsHisto->Fill(daqChannel);
        }
    }
 
    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug)
        fAnalysisTree->PrintObservables();
 
    return fSignalEvent;
}
 
void TRestDetectorSignalChannelActivityProcess::EndProcess() {
    if (!fReadOnly) {
        fDaqChannelsHisto->Write();
        if (fReadout) {
            fReadoutChannelsHisto->Write();
 
            fReadoutChannelsHisto_OneSignal->Write();
            fReadoutChannelsHisto_TwoSignals->Write();
            fReadoutChannelsHisto_ThreeSignals->Write();
            fReadoutChannelsHisto_MultiSignals->Write();
 
            fReadoutChannelsHisto_OneSignal_High->Write();
            fReadoutChannelsHisto_TwoSignals_High->Write();
            fReadoutChannelsHisto_ThreeSignals_High->Write();
            fReadoutChannelsHisto_MultiSignals_High->Write();
        }
    }
}
 
void TRestDetectorSignalChannelActivityProcess::InitFromConfigFile() {
    fLowThreshold = StringToDouble(GetParameter("lowThreshold", "25"));
    fHighThreshold = StringToDouble(GetParameter("highThreshold", "50"));
 
    fDaqHistogramChannels = StringToInteger(GetParameter("daqChannels", "300"));
    fDaqStartChannel = StringToInteger(GetParameter("daqStartCh", "4320"));
    fDaqEndChannel = StringToInteger(GetParameter("daqEndCh", "4620"));
    fReadoutHistogramChannels = StringToInteger(GetParameter("readoutChannels", "128"));
    fReadoutStartChannel = StringToInteger(GetParameter("readoutStartCh", "0"));
    fReadoutEndChannel = StringToInteger(GetParameter("readoutEndCh", "128"));
}