TRestRawTDSToSignalProcess.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 "TRestRawTDSToSignalProcess.h"
 
ClassImp(TRestRawTDSToSignalProcess);
 
TRestRawTDSToSignalProcess::TRestRawTDSToSignalProcess() { Initialize(); }
 
TRestRawTDSToSignalProcess::~TRestRawTDSToSignalProcess() {}
 
void TRestRawTDSToSignalProcess::Initialize() { TRestRawToSignalProcess::Initialize(); }
 
void TRestRawTDSToSignalProcess::InitProcess() {
    ANABlockHead blockhead;
    if (fread(&blockhead, sizeof(blockhead), 1, fInputBinFile) != 1) return;
    totalbytesRead = sizeof(blockhead);
    nSamples = blockhead.NEvents;
    nChannels = blockhead.NHits / blockhead.NEvents;
    fRate = blockhead.SRate;
    pulseDepth = blockhead.PSize;
    RESTDebug << "nSamples " << nSamples << " NChannels " << nChannels << RESTendl;
    RESTDebug << "SRATE: " << (double)fRate << " PULSE DEPTH: " << pulseDepth
              << " PRETRIGGER: " << blockhead.Pretrigger << RESTendl;
    for (int i = 0; i < nChannels; i++) {
        fScale[i] = blockhead.mVdiv[i];
        negPolarity[i] = blockhead.NegPolarity[i];
    }
    tNow = static_cast<double>(blockhead.TimeStamp);
    fRunInfo->SetStartTimeStamp(tNow);
}
 
TRestEvent* TRestRawTDSToSignalProcess::ProcessEvent(TRestEvent* evInput) {
    // TDS block and event header
    ANABlockHead blockhead;
    ANAEventHead eventhead;
 
    // Initialize fSignalEvent, so it is empty if already filled in
    fSignalEvent->Initialize();
 
    // Read block header if any, note that we have nSamples events between 2 block headers
    if (nEvents % nSamples == 0 && nEvents != 0) {
        if (fread(&blockhead, sizeof(blockhead), 1, fInputBinFile) != 1) return nullptr;
        totalbytesRead += sizeof(blockhead);
        // Update timestamp from the blockHeader
        tNow = static_cast<double>(blockhead.TimeStamp);
    }
 
    // Always read event header at the beginning of event
    if (fread(&eventhead, sizeof(eventhead), 1, fInputBinFile) != 1) return nullptr;
    totalbytesRead += sizeof(eventhead);
    // This vector holds data which has a length of pulseDepth
    std::vector<Char_t> buffer(pulseDepth);
    fSignalEvent->SetID(nEvents);
    fSignalEvent->SetTime(tNow + static_cast<double>(eventhead.clockTicksLT) * 1E-6);
    // Need to initialize TRestRawSignal with the proper data length
    TRestRawSignal sgnl(pulseDepth);
 
    // We loop over the recorded channels, we have one data frame per channel
    for (int i = 0; i < nChannels; i++) {
        sgnl.SetSignalID(i);
        fSignalEvent->AddSignal(sgnl);
        // Read data frame and store in buffer
        if (fread((char*)&buffer[0], pulseDepth, 1, fInputBinFile) != 1) return nullptr;
        totalbytesRead += pulseDepth;
        for (int j = 0; j < pulseDepth; j++) {
            Short_t data = buffer[j];
            if (negPolarity[i]) data *= -1;  // Inversion in case pulses are negative
            data += 128;                     // Add 128 since the oscilloscope range is [-128:128]
            fSignalEvent->AddChargeToSignal(i, j, data);
        }
    }
 
    // Set end time stamp for the run
    fRunInfo->SetEndTimeStamp(tNow + static_cast<double>(eventhead.clockTicksLT) * 1E-6);
    nEvents++;
 
    return fSignalEvent;
}