Commit 9c9d09d2 authored by Pascal Raisig's avatar Pascal Raisig Committed by Pierre-Alain Loizeau
Browse files

Fill Rich unpacker with some life.

Seems to have similar issues with the includes like PSD.
parent ac94a162
......@@ -81,6 +81,15 @@ void run_unpack_tsa(std::string infile = "test.tsa", UInt_t runid = 0, const cha
psdconfig->SetParFilesBasePath(parfilesbasepathPsd);
// -------------
// ---- RICH ----
auto richconfig = std::make_shared<CbmRichUnpackConfig>("", runid);
// psdconfig->SetDebugState();
richconfig->SetDoWriteOutput();
// psdconfig->SetDoWriteOptOutA("CbmPsdDsp");
std::string parfilesbasepathRich = Form("%s/macro/beamtime/mcbm2021/", srcDir.Data());
richconfig->SetParFilesBasePath(parfilesbasepathRich);
// -------------
// ---- TRD ----
TString trdsetuptag = "";
cbmsetup->GetGeoTag(ECbmModuleId::kTrd, trdsetuptag);
......@@ -113,8 +122,9 @@ void run_unpack_tsa(std::string infile = "test.tsa", UInt_t runid = 0, const cha
// ----- CbmSourceTsArchive -------------------------------------------
auto source = new CbmSourceTsArchive(infile.data());
auto unpack = source->GetRecoUnpack();
unpack->SetUnpackConfig(trdconfig);
unpack->SetUnpackConfig(psdconfig);
unpack->SetUnpackConfig(richconfig);
unpack->SetUnpackConfig(trdconfig);
// ------------------------------------------------------------------------
......
......@@ -11,6 +11,7 @@
#include <Rtypes.h>
#include <RtypesCore.h>
#include <cstdint>
#include <numeric>
#include "../../core/detectors/psd/PronyFitter.h"
......@@ -143,10 +144,9 @@ bool CbmPsdUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UI
const uint8_t* msContent = reinterpret_cast<const uint8_t*>(ts->content(icomp, imslice));
uint32_t uSize = msDescriptor.size;
auto msidx = msDescriptor.idx;
auto mstime = msDescriptor.idx;
auto mstime = static_cast<double>(msidx);
LOG(debug4) << "Microslice: " << msidx << " from EqId " << std::hex << eqid << std::dec << " has size: " << uSize;
LOG(debug4) << "Microslice: " << mstime << " from EqId " << std::hex << eqid << std::dec << " has size: " << uSize;
if (0 == fvbMaskedComponents.size()) fvbMaskedComponents.resize(ts->num_components(), kFALSE);
......@@ -203,7 +203,7 @@ bool CbmPsdUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UI
while (PsdReader.GetTotalGbtWordsRead() < uNbMessages) {
int ReadResult = PsdReader.ReadMs();
if (fair::Logger::Logging(fair::Severity::debug)) {
printf("\nMicroslice idx: %lu\n", msidx);
printf("\nMicroslice idx: %lu\n", mstime);
PsdReader.PrintOut(); /*PsdReader.PrintSaveBuff();*/
}
if (ReadResult == 0) {
......@@ -228,10 +228,8 @@ bool CbmPsdUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UI
}
UInt_t uChanUId = fviPsdChUId[uHitChannel]; //unique ID
auto dTime = static_cast<double>(PsdReader.VectPackHdr.at(hit_iter).uAdcTime * 12.5);
dTime -= fdTimeOffsetNs; // Subtract system-side offset
dTime += msidx; // Add the microslice start time
dTime -= fTsStartTime; // Get the time relative to the TS start time
auto dTime = dMsRelativeTime + (double) PsdReader.VectPackHdr.at(hit_iter).uAdcTime * 12.5 - fdTimeOffsetNs;
Double_t dEdep = (double) PsdReader.VectHitHdr.at(hit_iter).uSignalCharge / getMipCalibration(uHitChannel);
/// Energy deposition from FPGA [MeV]
......@@ -291,7 +289,7 @@ bool CbmPsdUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UI
uFitWfm = Pfitter.GetFitWfm();
}
CbmPsdDsp dsp = CbmPsdDsp(uChanUId, dTime, dEdep, uZL, dAccum, dAdcTime,
CbmPsdDsp dsp = CbmPsdDsp(uChanUId, dTime, fTsStartTime, dEdep, uZL, dAccum, dAdcTime,
dEdepWfm, dAmpl, uMinimum, uTimeMax, uWfm,
......@@ -300,6 +298,8 @@ bool CbmPsdUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UI
// Create the actual digi and move it to the output vector
makeDigi(dsp);
if (dTime < prev_hit_time) printf("negative time btw hits! %f after %f \n", dTime, prev_hit_time);
prev_hit_time = dTime;
} // for (uint64_t hit_iter = 0; hit_iter < PsdReader.VectHitHdr.size(); hit_iter++) {
......
......@@ -132,7 +132,7 @@ set(LINKDEF CbmRichRecoLinkDef.h)
Set(LIBRARY_NAME CbmRichReco)
Set(DEPENDENCIES
KF L1 CbmRichBase CbmRecoBase CbmBase CbmData Base MLP boost_regex Gdml
fles_ipc # for unpacker
# fles_ipc # for unpacker
)
GENERATE_LIBRARY()
......
......@@ -16,5 +16,239 @@ CbmRichUnpackAlgo::CbmRichUnpackAlgo() : CbmRecoUnpackAlgo(fgkFlesSubsystemIdTrd
CbmRichUnpackAlgo::~CbmRichUnpackAlgo() {}
// ---- GetParContainerRequest ----
std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
CbmRichUnpackAlgo::GetParContainerRequest(std::string /*geoTag*/, std::uint32_t /*runId*/)
{
// Basepath for default Trd parameter sets (those connected to a geoTag)
std::string basepath = Form("%s", fParFilesBasePath.data());
std::string temppath = "";
// // Get parameter container
temppath = basepath + "mRichPar.par";
LOG(info) << "HelloWorld " << temppath;
fParContVec.emplace_back(std::make_pair(temppath, std::make_shared<CbmMcbm2018RichPar>()));
return &fParContVec;
}
// ---- calculateTime
double CbmRichUnpackAlgo::calculateTime(uint32_t epoch, uint32_t coarse, uint32_t fine)
{
return ((double) epoch) * 2048. * 5. + ((double) coarse) * 5. - ((double) fine) * 0.005;
}
// ---- getLogHeader
std::string CbmRichUnpackAlgo::getLogHeader(CbmMcbm2018RichMicrosliceReader& reader)
{
std::stringstream stream;
stream << "[" << fNrProcessedTs << "-" << reader.GetWordCounter() << "/" << reader.GetSize() / 4 << " "
<< reader.GetWordAsHexString(reader.GetCurWord()) << "] ";
return stream.str();
}
// ---- init
Bool_t CbmRichUnpackAlgo::init() { return kTRUE; }
// ---- initParSet(FairParGenericSet* parset) ----
Bool_t CbmRichUnpackAlgo::initParSet(FairParGenericSet* parset)
{
LOG(info) << fName << "::initParSet - for container " << parset->ClassName();
if (parset->IsA() == CbmMcbm2018RichPar::Class()) return initParSet(static_cast<CbmMcbm2018RichPar*>(parset));
// If we do not know the derived ParSet class we return false
LOG(error) << fName << "::initParSet - for container " << parset->ClassName() << " failed, since" << fName
<< "::initParSet() does not know the derived ParSet and what to do with it!";
return kFALSE;
}
// ---- initParSet(CbmTrdParSetAsic* parset) ----
Bool_t CbmRichUnpackAlgo::initParSet(CbmMcbm2018RichPar* parset)
{
LOG(debug) << fName << "::initParSetAsic - ";
fUnpackPar = *parset;
LOG(info) << fName << "::initParSetRichMcbm2018 - Successfully initialized Spadic hardware address map";
return kTRUE;
}
// ---- isLog ----
bool CbmRichUnpackAlgo::isLog()
{
//if (fTsCounter == 25215) return true;
return false;
}
// ---- unpack
bool CbmRichUnpackAlgo::unpack(const fles::Timeslice* ts, std::uint16_t icomp, UInt_t imslice)
{
const fles::MicrosliceView mv = ts->get_microslice(icomp, imslice);
const fles::MicrosliceDescriptor& msDesc = mv.desc();
CbmMcbm2018RichMicrosliceReader reader;
reader.SetData(mv.content(), msDesc.size);
// There are a lot of MS with 8 bytes size
// Does one need these MS?
if (reader.GetSize() <= 8) return true;
while (true) {
processTrbPacket(reader);
// -4*2 for 2 last words which contain microslice index
if (reader.GetOffset() >= reader.GetSize() - 8) break;
// -4*3 for 0xffffffff padding and 2 last words which contain microslice index
if (reader.IsNextPadding() && reader.GetOffset() >= reader.GetSize() - 12) break;
}
uint32_t msIndexWord1 = reader.NextWord();
if (isLog()) LOG(DEBUG4) << getLogHeader(reader) << "Microslice Index 1:" << reader.GetWordAsHexString(msIndexWord1);
uint32_t msIndexWord2 = reader.NextWord();
if (isLog()) LOG(DEBUG4) << getLogHeader(reader) << "Microslice Index 2:" << reader.GetWordAsHexString(msIndexWord2);
return true;
}
void CbmRichUnpackAlgo::processTrbPacket(CbmMcbm2018RichMicrosliceReader& reader)
{
processMbs(reader, false); // Current MBS
processMbs(reader, true); // Previous MBS
uint32_t trbNum = reader.NextWord(); // TRB trigger number
if (isLog()) LOG(debug4) << getLogHeader(reader) << "TRB Num:" << reader.GetWordAsHexString(trbNum);
processHubBlock(reader);
}
void CbmRichUnpackAlgo::processMbs(CbmMcbm2018RichMicrosliceReader& reader, bool isPrev)
{
uint32_t word = reader.NextWord();
uint32_t mbsNum = word & 0xffffff; //24 bits
uint32_t nofCtsCh = (word >> 24) & 0xff; // 8 bits
if (isLog())
LOG(debug4) << getLogHeader(reader) << "MBS mbsNum:0x" << std::hex << mbsNum << std::dec
<< " nofCtsCh:" << nofCtsCh;
for (uint32_t i = 0; i < nofCtsCh; i++) {
uint32_t wordEpoch = reader.NextWord();
uint32_t epoch = CbmMcbm2018RichTdcWordReader::ProcessEpoch(wordEpoch);
if (isLog()) LOG(debug4) << getLogHeader(reader) << "MBS ch:" << i << " epoch:" << epoch;
uint32_t wordTime = reader.NextWord();
CbmMcbm2018RichTdcTimeData td;
CbmMcbm2018RichTdcWordReader::ProcessTimeData(wordTime, td);
if (isLog()) LOG(debug4) << getLogHeader(reader) << "MBS ch:" << i << " " << td.ToString();
double fullTime = calculateTime(epoch, td.fCoarse, td.fFine);
if (isPrev && td.fChannel == 0) fMbsPrevTimeCh0 = fullTime;
if (isPrev && td.fChannel == 1) fMbsPrevTimeCh1 = fullTime;
}
double mbsCorr = fMbsPrevTimeCh1 - fMbsPrevTimeCh0;
if (isLog())
LOG(debug4) << getLogHeader(reader) << "MBS Prev ch1:" << std::setprecision(15) << fMbsPrevTimeCh1
<< " ch0:" << fMbsPrevTimeCh0 << " corr:" << mbsCorr;
}
// ---- processTimeDataWord ----
void CbmRichUnpackAlgo::processTimeDataWord(CbmMcbm2018RichMicrosliceReader& reader, int iTdc, uint32_t epoch,
uint32_t tdcWord, uint32_t subSubEventId, std::vector<double>& raisingTime)
{
CbmMcbm2018RichTdcTimeData td;
CbmMcbm2018RichTdcWordReader::ProcessTimeData(tdcWord, td);
double fullTime = calculateTime(epoch, td.fCoarse, td.fFine);
if (td.fChannel == 0) {
if (td.IsRisingEdge()) {
fPrevLastCh0ReTime[subSubEventId] = fLastCh0ReTime[subSubEventId];
fLastCh0ReTime[subSubEventId] = fullTime;
if (isLog())
LOG(debug4) << getLogHeader(reader) << "SubSubEv[" << iTdc << "] " << td.ToString()
<< " CH0 Last:" << std::setprecision(15) << fLastCh0ReTime[subSubEventId]
<< " PrevLast:" << fPrevLastCh0ReTime[subSubEventId]
<< " diff:" << fLastCh0ReTime[subSubEventId] - fPrevLastCh0ReTime[subSubEventId];
}
}
else {
double dT = fullTime - fPrevLastCh0ReTime[subSubEventId];
double mbsCorr = fMbsPrevTimeCh1 - fMbsPrevTimeCh0;
double fullTimeCorr = dT - mbsCorr;
if (isLog())
LOG(debug4) << getLogHeader(reader) << "SubSubEv[" << iTdc << "] " << td.ToString()
<< " time:" << std::setprecision(15) << fullTime << " fullTimeCorr:" << fullTimeCorr;
if (td.fChannel < 1 || td.fChannel >= raisingTime.size()) {
LOG(error) << "ERROR: channel number is out of limit. Channel:" << td.fChannel;
}
if (td.IsRisingEdge()) {
// always store the latest raising edge. It means that in case RRFF situation only middle RF will be matched.
raisingTime[td.fChannel] = fullTimeCorr;
}
else {
if (raisingTime[td.fChannel] == -1.) {
//No raising channel was found before. Skip this falling edge time.
if (isLog())
LOG(debug4) << getLogHeader(reader) << "SubSubEv[" << iTdc << "] "
<< "No raising channel was found before. Skip this falling edge time.";
}
else {
// Matching was found, calculate ToT, if tot is in a good range -> create digi
double ToT = fullTimeCorr - raisingTime[td.fChannel];
if (isLog())
LOG(debug4) << getLogHeader(reader) << "SubSubEv[" << iTdc << "] "
<< "ToT:" << ToT;
if (ToT >= fToTMin && ToT <= fToTMax) {
// if (fbMonitorMode) {
// TH1D* h = GetTotH1(subSubEventId, td.fChannel);
// if (h != nullptr) h->Fill(ToT);
// TH2D* h2 = GetTotH2(subSubEventId);
// if (h2 != nullptr) h2->Fill(td.fChannel, ToT);
// }
writeOutputDigi(subSubEventId, td.fChannel, raisingTime[td.fChannel], ToT);
}
// pair was created, set raising edge to -1.
raisingTime[td.fChannel] = -1.;
}
}
}
}
void CbmRichUnpackAlgo::writeOutputDigi(Int_t fpgaID, Int_t channel, Double_t time, Double_t tot)
{
Double_t ToTcorr = fbDoToTCorr ? fUnpackPar.GetToTshift(fpgaID, channel) : 0.;
Int_t pixelUID = this->getPixelUID(fpgaID, channel);
//check ordering
// Double_t finalTime = time + (Double_t) msRefTS - fSystemTimeoffset;
Double_t finalTime = time - fSystemTimeoffset - fTsStartTime;
Double_t lastTime = 0.;
if (fOutputVec.size() < 1) { fOutputVec.emplace_back(pixelUID, finalTime, tot - ToTcorr); }
else {
lastTime = fOutputVec[fOutputVec.size() - 1].GetTime();
if (fOutputVec[0].GetTime() > finalTime) {
fOutputVec.emplace(fOutputVec.begin(), pixelUID, finalTime, tot - ToTcorr);
}
else if (lastTime > finalTime) {
for (int i = fOutputVec.size() - 1; i >= 0; i--) {
lastTime = fOutputVec[i].GetTime();
if (lastTime <= finalTime) {
fOutputVec.emplace(fOutputVec.begin() + i + 1, pixelUID, finalTime, tot - ToTcorr);
break;
}
}
}
else {
fOutputVec.emplace_back(pixelUID, finalTime, tot - ToTcorr);
}
}
}
ClassImp(CbmRichUnpackAlgo)
......@@ -21,6 +21,8 @@
#ifndef CbmRichUnpackAlgo_H
#define CbmRichUnpackAlgo_H
// #include "CbmMcbm2018RichPar.h"
#include "../../core/detectors/rich/CbmMcbm2018RichPar.h"
#include "CbmRecoUnpackAlgo.tmpl"
#include "CbmRichDigi.h"
......@@ -34,8 +36,165 @@
#include <memory>
#include <utility>
class CbmRichUnpackAlgo : public CbmRecoUnpackAlgo<CbmRichDigi> {
public:
enum class CbmMcbm2018RichErrorType
{
mtsError,
tdcHeader,
tdcTrailer,
ctsHeader,
ctsTrailer,
subEventError
};
enum class CbmMcbm2018RichTdcWordType
{
TimeData,
Header,
Epoch,
Trailer,
Debug,
Error
};
class CbmMcbm2018RichTdcTimeData {
public:
uint32_t fCoarse = 0; // 11 bits
uint32_t fEdge = 0; // 1 bit
uint32_t fFine = 0; // 10 bits
uint32_t fChannel = 0; // 7 bits
std::string ToString()
{
std::stringstream stream;
stream << "channel:" << fChannel << " coarse:" << fCoarse << " fine:" << fFine
<< " edge:" << ((fEdge == 1) ? "R" : "F");
return stream.str();
}
bool IsRisingEdge() { return (fEdge == 1); }
};
class CbmMcbm2018RichTdcWordReader {
public:
static CbmMcbm2018RichTdcWordType GetTdcWordType(uint32_t tdcWord)
{
uint32_t tdcTimeDataMarker = (tdcWord >> 31) & 0x1; // 1 bit
uint32_t tdcMarker = (tdcWord >> 29) & 0x7; // 3 bits
if (tdcTimeDataMarker == 0x1) {
// TODO: I also include tdcMarker == 0x5, some tdc time data words have this marker. Is it correct?
if (tdcMarker == 0x4 || tdcMarker == 0x5) { return CbmMcbm2018RichTdcWordType::TimeData; }
else {
return CbmMcbm2018RichTdcWordType::Error;
}
}
if (tdcMarker == 0x0) return CbmMcbm2018RichTdcWordType::Trailer;
if (tdcMarker == 0x1) return CbmMcbm2018RichTdcWordType::Header;
if (tdcMarker == 0x2) return CbmMcbm2018RichTdcWordType::Debug;
if (tdcMarker == 0x3) return CbmMcbm2018RichTdcWordType::Epoch;
return CbmMcbm2018RichTdcWordType::Error;
}
static void ProcessTimeData(uint32_t tdcWord, CbmMcbm2018RichTdcTimeData& outData)
{
outData.fCoarse = static_cast<uint32_t>(tdcWord & 0x7ff); // 11 bits
outData.fEdge = static_cast<uint32_t>((tdcWord >> 11) & 0x1); // 1 bit
outData.fFine = static_cast<uint32_t>((tdcWord >> 12) & 0x3ff); // 10 bits
outData.fChannel = static_cast<uint32_t>((tdcWord >> 22) & 0x7f); // 7 bits
}
static uint32_t ProcessEpoch(uint32_t tdcWord) { return static_cast<uint32_t>(tdcWord & 0xfffffff); }
static uint16_t ProcessHeader(uint32_t tdcWord)
{
// for the moment just extract error bits
return static_cast<uint16_t>(tdcWord & 0xff); //8 bits
}
static uint16_t ProcessTrailer(uint32_t tdcWord)
{
// for the moment just extract error bits
return static_cast<uint16_t>(tdcWord & 0xffff);
}
static void ProcessDebug(uint32_t tdcWord)
{
LOG(debug4) << "ProcessDebug is not implemented. tdcWord:0x" << std::hex << tdcWord << std::dec;
// for the moment do nothing
}
};
class CbmMcbm2018RichMicrosliceReader {
private:
const uint8_t* fData = nullptr;
size_t fSize = 0;
size_t fOffset = 0; // offset in bytes
size_t fWordCounter = 0;
uint32_t fCurWord;
public:
void SetData(const uint8_t* data, size_t size)
{
fData = data;
fSize = size;
fOffset = 0;
fWordCounter = 0;
fCurWord = 0;
}
const uint8_t* GetData() { return fData; }
size_t GetSize() { return fSize; }
size_t GetOffset() { return fOffset; }
size_t GetWordCounter() { return fWordCounter; }
uint32_t GetCurWord() { return fCurWord; }
std::string GetWordAsHexString(uint32_t word)
{
std::stringstream stream;
stream << "0x" << std::setfill('0') << std::setw(sizeof(uint32_t) * 2) << std::hex << word;
return stream.str();
}
uint32_t NextWord()
{
//mRichSupport::SwapBytes(4, fData + fOffset);
//Int_t* dataPtr = (Int_t*) (fData + fOffset);
uint32_t i = ((uint32_t*) (fData + fOffset))[0];
//swap bytes
i = (i >> 24) | ((i << 8) & 0x00FF0000) | ((i >> 8) & 0x0000FF00) | (i << 24);
//i = ((i&0xFF)<<24) | (((i>>8)&0xFF)<<16) | (((i>>16)&0xFF)<<8) | (((i>>24)&0xFF)<<0);
fOffset += 4;
fWordCounter++;
fCurWord = i;
//return (Int_t)(dataPtr[0]);
return i;
}
bool IsNextPadding()
{
uint32_t nextWord = ((uint32_t*) (fData + fOffset))[0];
if (nextWord == 0xffffffff) return true;
return false;
}
bool IsLastSubSubEvent(uint32_t subSubEventSize)
{
uint32_t i = ((uint32_t*) (fData + fOffset + 4 * subSubEventSize))[0];
i = (i >> 24) | ((i << 8) & 0x00ff0000) | ((i >> 8) & 0x0000ff00) | (i << 24);
if (i == 0x00015555) return true;
return false;
}
};
/** @brief Create the Cbm Trd Unpack AlgoBase object */
CbmRichUnpackAlgo();
......@@ -58,12 +217,11 @@ public:
* @return fParContVec
*/
virtual std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
GetParContainerRequest(std::string geoTag, std::uint32_t runId)
{
return {};
};
GetParContainerRequest(std::string geoTag, std::uint32_t runId);
protected:
double calculateTime(uint32_t epoch, uint32_t coarse, uint32_t fine);
/** @brief Finish function for this algorithm base clase */
void finish()
{
......@@ -75,12 +233,29 @@ protected:
/** @brief Function that allows special calls during Finish in the derived algos */
virtual void finishDerived() { return; }
std::string getLogHeader(CbmMcbm2018RichMicrosliceReader& reader);
Int_t getPixelUID(Int_t fpgaID, Int_t ch) const
{
// First 16 bits are used for the FPGA ID, then
// 8 bits unused and then 8 bits are used for the channel
return ((fpgaID << 16) | (ch & 0x00FF));
}
/**
* @brief Intialisation at begin of run. Special inits of the derived algos.
*
* @retval Bool_t initOk
*/
Bool_t init() { return kTRUE; }
Bool_t init();
/**
* @brief Handles the distribution of the hidden derived classes to their explicit functions.
*
* @param parset
* @return Bool_t initOk
*/
Bool_t initParSet(FairParGenericSet* parset);
/**
* @brief Handles the distribution of the hidden derived classes to their explicit functions.
......@@ -88,7 +263,27 @@ protected:
* @param parset
* @return Bool_t initOk
*/
Bool_t initParSet(FairParGenericSet* parset) { return kTRUE; }
Bool_t initParSet(CbmMcbm2018RichPar* parset);
bool isLog();
void processTrbPacket(CbmMcbm2018RichMicrosliceReader& reader);
void processMbs(CbmMcbm2018RichMicrosliceReader& reader, bool isPrev);
void processHubBlock(CbmMcbm2018RichMicrosliceReader& reader);
void processCtsSubSubEvent(CbmMcbm2018RichMicrosliceReader& reader, uint32_t subSubEventSize, uint32_t subSubEventId);
void processSubSubEvent(CbmMcbm2018RichMicrosliceReader& reader, int nofTimeWords, uint32_t subSubEventId);
void processTimeDataWord(CbmMcbm2018RichMicrosliceReader& reader, int iTdc, uint32_t epoch, uint32_t tdcWord,
uint32_t subSubEventId, std::vector<double>& raisingTime);
/**
* Write a gidi object into the output collection
*/
void writeOutputDigi(Int_t fpgaID, Int_t channel, Double_t time, Double_t tot);
/**
* @brief Set the Derived Ts Parameters
......@@ -112,11 +307,25 @@ protected:
*
* @remark The content of the µslice can only be accessed via the timeslice. Hence, we need to pass the pointer to the full timeslice
*/
bool unpack(const fles::Timeslice* ts, std::uint16_t icomp, UInt_t imslice) { return true; }
bool unpack(const fles::Timeslice* ts, std::uint16_t icomp, UInt_t imslice);