diff --git a/inc/TRestRawDAQMetadata.h b/inc/TRestRawDAQMetadata.h index ef47653f..3b17a92e 100644 --- a/inc/TRestRawDAQMetadata.h +++ b/inc/TRestRawDAQMetadata.h @@ -28,29 +28,113 @@ #include "TRestMetadata.h" #include "TString.h" +namespace daq_metadata_types { + +enum class acqTypes : int { BACKGROUND = 0, CALIBRATION, PEDESTAL }; + +enum class electronicsTypes : int { DUMMY = 0, DCC, FEMINOS, ARC }; + +enum class chipTypes : int { AFTER = 0, AGET }; + +enum class triggerTypes : int { INTERNAL = 0, EXTERNAL, AUTO, TCM }; + +enum class compressModeTypes : int { ALLCHANNELS = 0, TRIGGEREDCHANNELS, ZEROSUPPRESSION }; + +const std::map acqTypes_map = {{"background", acqTypes::BACKGROUND}, + {"calibration", acqTypes::CALIBRATION}, + {"pedestal", acqTypes::PEDESTAL}}; + +const std::map electronicsTypes_map = {{"DUMMY", electronicsTypes::DUMMY}, + {"DCC", electronicsTypes::DCC}, + {"FEMINOS", electronicsTypes::FEMINOS}, + {"ARC", electronicsTypes::ARC}}; + +const std::map chipTypes_map = {{"after", chipTypes::AFTER}, + {"aget", chipTypes::AGET}}; + +const std::map triggerTypes_map = {{"internal", triggerTypes::INTERNAL}, + {"external", triggerTypes::EXTERNAL}, + {"auto", triggerTypes::AUTO}, + {"tcm", triggerTypes::TCM}}; + +const std::map compressMode_map = { + {"allchannels", compressModeTypes::ALLCHANNELS}, + {"triggeredchannels", compressModeTypes::TRIGGEREDCHANNELS}, + {"zerosuppression", compressModeTypes::ZEROSUPPRESSION}, +}; + +} // namespace daq_metadata_types + //! A metadata class to store DAQ information. class TRestRawDAQMetadata : public TRestMetadata { + public: + static constexpr int nAsics = 4; + static constexpr int nChannels = 79; + + struct FECMetadata { + Int_t id; + Int_t ip[nAsics]; + UShort_t clockDiv; + TString chipType; + UShort_t triggerDelay = 0; + std::array asic_polarity; + std::array asic_pedCenter; + std::array asic_pedThr; + std::array asic_gain; + std::array asic_shappingTime; + std::array asic_channelStart; + std::array asic_channelEnd; + std::array asic_isActive; + std::array asic_coarseThr; + std::array asic_fineThr; + std::array asic_multThr; + std::array asic_multLimit; + std::array, nChannels> asic_channelActive; + + bool operator<(const FECMetadata& fM) const { return id < fM.id; } + void operator=(const FECMetadata& fM) { + id = fM.id; + clockDiv = fM.clockDiv; + chipType = fM.chipType; + for (int i = 0; i < nAsics; i++) { + ip[i] = fM.ip[i]; + asic_polarity[i] = fM.asic_polarity[i]; + asic_pedCenter[i] = fM.asic_pedCenter[i]; + asic_pedThr[i] = fM.asic_pedThr[i]; + asic_gain[i] = fM.asic_gain[i]; + asic_shappingTime[i] = fM.asic_shappingTime[i]; + asic_channelStart[i] = fM.asic_channelStart[i]; + asic_channelEnd[i] = fM.asic_channelEnd[i]; + asic_isActive[i] = fM.asic_isActive[i]; + asic_coarseThr[i] = fM.asic_coarseThr[i]; + asic_fineThr[i] = fM.asic_fineThr[i]; + asic_multThr[i] = fM.asic_multThr[i]; + asic_multLimit[i] = fM.asic_multLimit[i]; + for (int j = 0; j < nChannels; j++) { + asic_channelActive[i][j] = fM.asic_channelActive[i][j]; + } + } + } + }; + private: void InitFromConfigFile() override; void Initialize() override; protected: - TString fOutBinFileName; - TString fElectronicsType; - std::vector fPedBuffer; // Pedestal script - std::vector fRunBuffer; // Run script - TString fNamePedScript; // Name of the run script e.g. /home/user/scripts/run - TString fNameRunScript; // Name of the pedestal script e.g. - // /home/user/scripts/ped - UInt_t fGain; // Value of the gain in the script you have to convert it to fC - UInt_t fShappingTime; // Value of the shapping time in the script you have to - // convert it to nS + TString fElectronicsType; // DCC, FEMINOS, ARC, ... + TString fTriggerType; // external, internal, auto or tcm + TString fAcquisitionType; // pedestal, calibration or background + TString fCompressMode; // allchannels, triggeredchannels, zerosuppression + Int_t fNEvents = 0; // 0 --> Infinite + Int_t fNPedestalEvents = 100; // Number of pedestal events to be acquired + std::vector fFEC; // Vector of FECMETADATA + TString fDecodingFile = ""; // Location of the decoding file + Int_t fMaxFileSize = 1000000000; // Maximum file size in bytes public: void PrintMetadata() override; - void PrintRunScript(); - void PrintPedScript(); // Constructor TRestRawDAQMetadata(); @@ -58,14 +142,22 @@ class TRestRawDAQMetadata : public TRestMetadata { // Destructor virtual ~TRestRawDAQMetadata(); - void SetScriptsBuffer(); - void SetParFromPedBuffer(); // Set gain and shaping time from a given buffer - void SetOutBinFileName(TString fName) { fOutBinFileName = fName; } + inline auto GetTriggerType() const { return fTriggerType; } + inline auto GetAcquisitionType() const { return fAcquisitionType; } + inline auto GetElectronicsType() const { return fElectronicsType; } + inline auto GetNEvents() const { return fNEvents; } + inline auto GetNPedestalEvents() const { return fNPedestalEvents; } + inline auto GetCompressMode() const { return fCompressMode; } + inline auto GetDecodingFile() const { return fDecodingFile; } + inline auto GetFECs() const { return fFEC; } + inline auto GetMaxFileSize() const { return fMaxFileSize; } + + void SetAcquisitionType(const std::string& typ) { fAcquisitionType = typ; } + void SetNEvents(const Int_t& nEv) { fNEvents = nEv; } - inline UInt_t GetGain() const { return fGain; } - inline UInt_t GetShappingTime() const { return fShappingTime; } - UInt_t GetValFromString(TString var, TString line); + void ReadFEC(); + void DumpFEC(const FECMetadata& fec); - ClassDefOverride(TRestRawDAQMetadata, 1); // REST run class + ClassDefOverride(TRestRawDAQMetadata, 3); // REST run class }; #endif diff --git a/inc/TRestRawSignal.h b/inc/TRestRawSignal.h index 2dc49075..585e9b8e 100644 --- a/inc/TRestRawSignal.h +++ b/inc/TRestRawSignal.h @@ -156,6 +156,8 @@ class TRestRawSignal { void InitializePointsOverThreshold(const TVector2& thrPar, Int_t nPointsOver, Int_t nPointsFlat = 512); + void ZeroSuppressionToRaw(); + UInt_t GetSeed() const { return fSeed; } Double_t GetIntegral(); @@ -208,6 +210,8 @@ class TRestRawSignal { void Scale(Double_t value); + double GetAmplitudeFast(const TVector2& baselineRange, double signalThreshold); + void WriteSignalToTextFile(const TString& filename); void Print() const; @@ -223,6 +227,7 @@ class TRestRawSignal { TRestRawSignal(); TRestRawSignal(Int_t nBins); + TRestRawSignal(Int_t sID, std::vector& sData); ~TRestRawSignal(); ClassDef(TRestRawSignal, 2); diff --git a/inc/TRestRawZeroSupressionToRawProcess.h b/inc/TRestRawZeroSupressionToRawProcess.h new file mode 100644 index 00000000..880d3368 --- /dev/null +++ b/inc/TRestRawZeroSupressionToRawProcess.h @@ -0,0 +1,62 @@ +/************************************************************************* + * 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. * + *************************************************************************/ + +#ifndef RESTProc_TRestRawZeroSupressionToRawProcess +#define RESTProc_TRestRawZeroSupressionToRawProcess + +#include "TRestEvent.h" +#include "TRestEventProcess.h" +#include "TRestRawSignalEvent.h" + +/// This process remove the offset on a zerosuppression acquired event +class TRestRawZeroSupressionToRawProcess : public TRestEventProcess { + private: + /// Pointer to TRestRawSignalEvent input event + TRestRawSignalEvent* fEvent; //! + + void Initialize() override; + + public: + RESTValue GetInputEvent() const override { return fEvent; } + RESTValue GetOutputEvent() const override { return fEvent; } + + void InitProcess() override; + + const char* GetProcessName() const override { return "ZeroSupressionToRaw"; } + + TRestEvent* ProcessEvent(TRestEvent* eventInput) override; + + void EndProcess() override; + + /// It prints out the process parameters stored in the metadata structure + void PrintMetadata() override { + BeginPrintProcess(); + + EndPrintProcess(); + } + + TRestRawZeroSupressionToRawProcess(); + ~TRestRawZeroSupressionToRawProcess(); + + ClassDefOverride(TRestRawZeroSupressionToRawProcess, 1); +}; +#endif diff --git a/macros/REST_Raw_NoiseRMS.C b/macros/REST_Raw_NoiseRMS.C new file mode 100644 index 00000000..14071e51 --- /dev/null +++ b/macros/REST_Raw_NoiseRMS.C @@ -0,0 +1,49 @@ + + +void REST_Raw_NoiseRMS(const std::string& fileName, int nEvents = 10) { + TRestRun run(fileName); + + TRestRawSignalEvent* rawEvent = (TRestRawSignalEvent*)run.GetInputEvent(); + + std::map channelMapMean; + std::map channelMapStd; + std::map channelMapCount; + + int entries = run.GetEntries(); + + nEvents = std::min(nEvents, entries); + + for (int i = 0; i < nEvents; i++) { + run.GetEntry(i); + int chId; + double mean = 0, rms = 0; + for (int s = 0; s < rawEvent->GetNumberOfSignals(); s++) { + TRestRawSignal* rawSignal = rawEvent->GetSignal(s); + const int daqChannel = rawSignal->GetSignalID(); + for (int p = 0; p < rawSignal->GetNumberOfPoints(); p++) { + short data = rawSignal->GetRawData(p); + channelMapMean[daqChannel] += data; + channelMapStd[daqChannel] += data * data; + channelMapCount[daqChannel]++; + } + } + } + + auto grE = new TGraphErrors(); + + int c = 0; + for (const auto& [channel, count] : channelMapCount) { + if (count > 0) { + double mean = channelMapMean[channel] / count; + double std = sqrt(channelMapStd[channel] / count - mean * mean); + std::cout << "Channel " << channel << " Mean " << mean << " Std " << std << endl; + grE->SetPoint(c, channel, mean); + grE->SetPointError(c, 0, std); + c++; + } + } + + std::cout << "Total number of events processed " << nEvents << endl; + + grE->Draw("AP"); +} diff --git a/src/TRestRawDAQMetadata.cxx b/src/TRestRawDAQMetadata.cxx index fd650dbd..9c8bd595 100644 --- a/src/TRestRawDAQMetadata.cxx +++ b/src/TRestRawDAQMetadata.cxx @@ -21,39 +21,63 @@ *************************************************************************/ ////////////////////////////////////////////////////////////////////////// -/// The TRestRawDaqMetadata ... +/// TRestRawDAQMetadata class is meant to hold DAQ information which is +/// stored in the root files generated using `restDAQ` package. It contains +/// information about the readout type DCC, FEMINOS,... and the different +/// parameters of the readout electronics (FEC, FEM, AGET, AFTER,...). Note +/// that the DAQ is under development, so further changes on this class are +/// foreseen: /// -/// TODO. This class might be obsolete today. It may need additional revision, -/// validation, and documentation. +/// ### Parameters +/// Describe any parameters this process receives: +/// * **electronicsType**: DAQ electronics type, only DCC and FEMINOS are +/// supported so far. +/// * **triggerType**: internal, external, auto or tcm +/// * **acquisitionType**: Type of acquisition: pedestal, calibration or +/// background +/// * **compressMode**: allchannels, triggeredchannels or zerosuppression +/// * **nEvents**: Number of events to be acquired (0 for infinite loop) +/// * **nPedestalEvents**: Number of pedestal events to be acquired +/// It also includes `FECMetadata` section (see example) /// -///
-/// -/// \warning **⚠ REST is under continous development.** This -/// documentation -/// is offered to you by the REST community. Your HELP is needed to keep this -/// code -/// up to date. Your feedback will be worth to support this software, please -/// report -/// any problems/suggestions you may find while using it at [The REST Framework -/// forum](http://ezpc10.unizar.es). You are welcome to contribute fixing typos, -/// updating -/// information or adding/proposing new contributions. See also our -/// Contribution -/// Guide. +/// ### Examples +/// Give examples of usage and RML descriptions that can be tested. +/// \code +/// +/// +/// +/// +/// +/// +/// /// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// \endcode /// -///-------------------------------------------------------------------------- +///---------------------------------------------------------------------- /// -/// RESTsoft - Software for Rare Event Searches with TPCs +/// REST-for-Physics - Software for Rare Event Searches Toolkit /// /// History of developments: /// /// 2015-Nov: First implementation as part of the conceptualization of existing -/// REST software. -/// Juanan Garcia +/// REST software. +/// JuanAn Garcia +/// +/// 2021-2022: New implementation for restDAQ package +/// JuanAn Garcia /// -/// \class TRestRawDAQMetadata -/// \author Juanan Garcia +/// \class TRestRawDAQMetadata +/// \author: Juanan Garcia e-mail: juanangp@unizar.es /// ///
/// @@ -68,9 +92,6 @@ TRestRawDAQMetadata::TRestRawDAQMetadata(const char* configFilename) : TRestMeta Initialize(); LoadConfigFromFile(fConfigFileName); - - SetScriptsBuffer(); - SetParFromPedBuffer(); } void TRestRawDAQMetadata::Initialize() { @@ -78,112 +99,158 @@ void TRestRawDAQMetadata::Initialize() { SetLibraryVersion(LIBRARY_VERSION); } -TRestRawDAQMetadata::~TRestRawDAQMetadata() { cout << "Deleting TRestRawDAQMetadata" << endl; } +TRestRawDAQMetadata::~TRestRawDAQMetadata() {} void TRestRawDAQMetadata::InitFromConfigFile() { - // string daqString; + TRestMetadata::InitFromConfigFile(); - fNamePedScript = GetParameter("pedScript"); - if (fNamePedScript == "") { - cout << "Pedestal script " << endl; - } - - fNameRunScript = GetParameter("runScript"); - if (fNameRunScript == "") { - cout << "Run script " << endl; - } - - fElectronicsType = GetParameter("electronics"); - if (fElectronicsType == "") { - cout << "electronic type not found " << endl; - } + ReadFEC(); } void TRestRawDAQMetadata::PrintMetadata() { - cout << endl; - cout << "====================================" << endl; - cout << "DAQ : " << GetTitle() << endl; - cout << "Pedestal script : " << fNamePedScript.Data() << endl; - cout << "Run script : " << fNameRunScript.Data() << endl; - cout << "Electronics type : " << fElectronicsType.Data() << endl; - cout << "Gain : " << GetGain() << endl; - cout << "Shapping time : " << GetShappingTime() << endl; - cout << "====================================" << endl; - - cout << endl; + RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl; + RESTMetadata << this->ClassName() << " content" << RESTendl; + RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl; + RESTMetadata << "Trigger type : " << fTriggerType.Data() << RESTendl; + RESTMetadata << "Acquisition type : " << fAcquisitionType.Data() << RESTendl; + RESTMetadata << "Compress mode : " << fCompressMode.Data() << RESTendl; + RESTMetadata << "Number of events : " << fNEvents << RESTendl; + RESTMetadata << "Number of pedestal events : " << fNPedestalEvents << RESTendl; + RESTMetadata << "Maximum file size : " << fMaxFileSize << " bytes" << RESTendl; + + for (const auto& f : fFEC) DumpFEC(f); + RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl; + + RESTMetadata << RESTendl; } -void TRestRawDAQMetadata::SetScriptsBuffer() { - TString folder = REST_PATH; - folder.Append("data/acquisition/"); - - TString fName; - - fName = folder + fNamePedScript; - - ifstream file(fName); - if (!file) { - cout << __PRETTY_FUNCTION__ << " ERROR:FILE " << fName << " not found " << endl; - return; - } - - string line; - while (getline(file, line)) { - fPedBuffer.push_back(line); - } - - file.close(); - - fName = folder + fNameRunScript; - - ifstream file2(fName); - if (!file2) { - cout << __PRETTY_FUNCTION__ << " ERROR:FILE " << fName << " not found " << endl; - return; - } - - while (getline(file2, line)) { - fRunBuffer.push_back(line); +void TRestRawDAQMetadata::ReadFEC() { + TiXmlElement* FECDef = GetElement("FEC"); + + while (FECDef) { + FECMetadata fec; + fec.id = StringToInteger(GetFieldValue("id", FECDef)); + std::string ip = GetFieldValue("ip", FECDef); + sscanf(ip.c_str(), "%d:%d:%d:%d", &fec.ip[0], &fec.ip[1], &fec.ip[2], &fec.ip[3]); + fec.chipType = GetFieldValue("chip", FECDef); + fec.clockDiv = StringToInteger(GetFieldValue("clockDiv", FECDef)); + // std::cout<<"FEC "< 0 && c % 10 == 0) RESTMetadata << RESTendl; + } + RESTMetadata << RESTendl; } -} - -UInt_t TRestRawDAQMetadata::GetValFromString(TString var, TString line) { - unsigned int val; - - unsigned int varSize = var.Sizeof(); - unsigned int lineSize = line.Sizeof(); - - TString diff(line(varSize - 1, lineSize - 1)); - - cout << diff.Data() << endl; - - sscanf(diff.Data(), "0x%x", &val); - - return val; + RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl; } diff --git a/src/TRestRawSignal.cxx b/src/TRestRawSignal.cxx index 8fd32f2f..9338a977 100644 --- a/src/TRestRawSignal.cxx +++ b/src/TRestRawSignal.cxx @@ -91,6 +91,8 @@ TRestRawSignal::TRestRawSignal(Int_t nBins) { fSignalData.resize(nBins, 0); } +TRestRawSignal::TRestRawSignal(Int_t sID, std::vector& sData) : fSignalID(sID), fSignalData(sData) {} + /////////////////////////////////////////////// /// \brief Default destructor /// @@ -821,6 +823,36 @@ void TRestRawSignal::CalculateBaseLineSigmaIQR(Int_t startBin, Int_t endBin) { } } +/////////////////////////////////////////////// +/// \brief This method calculate the baseline in a certain range and returns the maximum amplitude +/// if the signal is above certain threshold. The calculations are performed in a fast way only +/// using a single loop. +/// +double TRestRawSignal::GetAmplitudeFast(const TVector2& baselineRange, double signalThreshold) { + double max = 0; + fBaseLineSigma = 0; + fBaseLine = 0; + int nPoints = 0; + for (int i = 0; i < GetNumberOfPoints(); i++) { + short val = GetRawData(i); + if (val > max) max = val; + if (i < baselineRange.X() || i > baselineRange.Y() || val == 0) continue; + fBaseLine += val; + fBaseLineSigma += val * val; + nPoints++; + } + + if (nPoints > 0) { + fBaseLine /= nPoints; + fBaseLineSigma = TMath::Sqrt(fBaseLineSigma / nPoints - fBaseLine * fBaseLine); + } + + // Only pulses above certain threshold + if (max < (fBaseLine + signalThreshold * fBaseLineSigma)) return 0; + + return max - fBaseLine; +} + /////////////////////////////////////////////// /// \brief This method adds an offset to the signal data /// @@ -865,6 +897,20 @@ void TRestRawSignal::WriteSignalToTextFile(const TString& filename) { fclose(file); } +/////////////////////////////////////////////// +/// \brief This method transforms zero suppression +/// raw data into a raw data event using the firs +/// +void TRestRawSignal::ZeroSuppressionToRaw() { + Short_t offset = 0; + for (int i = 0; i < GetNumberOfPoints(); i++) { + const Short_t val = fSignalData[i]; + if (val == 0) continue; + if (offset == 0) offset = val; + fSignalData[i] = val - offset; + } +} + /////////////////////////////////////////////// /// \brief It prints the signal data on screen. /// diff --git a/src/TRestRawZeroSupressionToRawProcess.cxx b/src/TRestRawZeroSupressionToRawProcess.cxx new file mode 100644 index 00000000..ce026030 --- /dev/null +++ b/src/TRestRawZeroSupressionToRawProcess.cxx @@ -0,0 +1,92 @@ +/************************************************************************* + * 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. * + *************************************************************************/ + +///////////////////////////////////////////////////////////////////////// +/// TRestRawZeroSuppressionToRaw process remove the offset on a zerosuppression +/// acquired event using the first bin as baseline. +/// +/// ### Examples +/// Give examples of usage and RML descriptions that can be tested. +/// \code +/// +/// \endcode +/// +/// REST-for-Physics - Software for Rare Event Searches Toolkit +/// +/// History of developments: +/// +/// 2023-June: First implementation of TRestRawZeroSupressionToRawProcess +/// JuanAn Garcia +/// +/// \class TRestRawZeroSupressionToRawProcess +/// \author: JuanAn Garcia juanangp@unizar.es +/// +///
+/// + +#include "TRestRawZeroSupressionToRawProcess.h" + +ClassImp(TRestRawZeroSupressionToRawProcess); + +/////////////////////////////////////////////// +/// \brief Default constructor +/// +TRestRawZeroSupressionToRawProcess::TRestRawZeroSupressionToRawProcess() { Initialize(); } + +/////////////////////////////////////////////// +/// \brief Default destructor +/// +TRestRawZeroSupressionToRawProcess::~TRestRawZeroSupressionToRawProcess() {} + +/////////////////////////////////////////////// +/// \brief Function to initialize input/output event members and define +/// the section name +/// +void TRestRawZeroSupressionToRawProcess::Initialize() { + SetSectionName(this->ClassName()); + SetLibraryVersion(LIBRARY_VERSION); + fEvent = nullptr; +} + +/////////////////////////////////////////////// +/// \brief Process initialization. +/// +void TRestRawZeroSupressionToRawProcess::InitProcess() {} + +/////////////////////////////////////////////// +/// \brief The main processing event function +/// +TRestEvent* TRestRawZeroSupressionToRawProcess::ProcessEvent(TRestEvent* evInput) { + fEvent = (TRestRawSignalEvent*)evInput; + for (int n = 0; n < fEvent->GetNumberOfSignals(); n++) { + TRestRawSignal* rawSignal = fEvent->GetSignal(n); + rawSignal->ZeroSuppressionToRaw(); + } + + return fEvent; +} + +/////////////////////////////////////////////// +/// \brief Function to include required actions after all events have been +/// processed. +/// +void TRestRawZeroSupressionToRawProcess::EndProcess() {}