// Copyright 2019-2020 CERN and copyright holders of ALICE O2.

// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.

// All rights not expressly granted are reserved.

//

// This software is distributed under the terms of the GNU General Public

// License v3 (GPL Version 3), copied verbatim in the file "COPYING".

//

// In applying this license CERN does not waive the privileges and immunities

// granted to it by virtue of its status as an Intergovernmental Organization

// or submit itself to any jurisdiction.

#include "Framework/CCDBParamSpec.h"

#include "Framework/ConfigParamRegistry.h"

#include "Framework/ControlService.h"

#include "Framework/InputRecordWalker.h"

#include "Framework/DataRefUtils.h"

#include "Framework/Logger.h"

#include "Framework/WorkflowSpec.h"

#include "CommonConstants/Triggers.h"

#include "DetectorsRaw/RDHUtils.h"

#include "FOCALReconstruction/PadWord.h"

#include "FOCALWorkflow/RawDecoderSpec.h"

#include "ITSMFTReconstruction/GBTWord.h"

#include <iostream>

#include <sstream>

#include <set>

using namespace o2::focal::reco_workflow;

void RawDecoderSpec::init(framework::InitContext& ctx)

{

if (ctx.options().get<bool>("filterIncomplete")) {

LOG(info) << "Enabling filtering of incomplete events in the pixel data";

mFilterIncomplete = true;

}

if (ctx.options().get<bool>("displayInconsistent")) {

LOG(info) << "Display additional information in case of inconsistency between pixel links";

mDisplayInconsistent = true;

}

auto mappingfile = ctx.options().get<std::string>("pixelmapping");

PixelMapper::MappingType_t mappingtype = PixelMapper::MappingType_t::MAPPING_UNKNOWN;

auto chiptype = ctx.options().get<std::string>("pixeltype");

if (chiptype == "IB") {

LOG(info) << "Using mapping type: IB";

mappingtype = PixelMapper::MappingType_t::MAPPING_IB;

} else if (chiptype == "OB") {

LOG(info) << "Using mapping type: OB";

mappingtype = PixelMapper::MappingType_t::MAPPING_OB;

} else {

LOG(fatal) << "Unkown mapping type for pixels: " << chiptype;

}

if (mappingfile == "default") {

LOG(info) << "Using default pixel mapping for pixel type " << chiptype;

mPixelMapping = std::make_unique<PixelMapper>(mappingtype);

} else {

LOG(info) << "Using user-defined mapping: " << mappingfile;

mPixelMapping = std::make_unique<PixelMapper>(PixelMapper::MappingType_t::MAPPING_UNKNOWN);

mPixelMapping->setMappingFile(mappingfile, mappingtype);

}

}

void RawDecoderSpec::run(framework::ProcessingContext& ctx)

{

LOG(info) << "Running FOCAL decoding";

resetContainers();

mTimeframeHasPadData = false;

mTimeframeHasPixelData = false;

int inputs = 0;

std::vector<char> rawbuffer;

uint16_t currentfee = 0;

o2::InteractionRecord currentIR;

std::unordered_map<int, int> numHBFFEE, numEventsFEE;

std::unordered_map<int, std::vector<int>> numEventsHBFFEE;

int numHBFPadsTF = 0, numEventsPadsTF = 0;

std::vector<int> expectFEEs;

for (const auto& rawData : framework::InputRecordWalker(ctx.inputs())) {

if (rawData.header != nullptr && rawData.payload != nullptr) {

const auto payloadSize = o2::framework::DataRefUtils::getPayloadSize(rawData);

auto header = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(rawData);

LOG(debug) << "Channel " << header->dataOrigin.str << "/" << header->dataDescription.str << "/" << header->subSpecification;

gsl::span<const char> databuffer(rawData.payload, payloadSize);

int currentpos = 0;

bool firstHBF = true;

while (currentpos < databuffer.size()) {

auto rdh = reinterpret_cast<const o2::header::RDHAny*>(databuffer.data() + currentpos);

if (mDebugMode) {

o2::raw::RDHUtils::printRDH(rdh);

}

if (o2::raw::RDHUtils::getMemorySize(rdh) > o2::raw::RDHUtils::getHeaderSize(rdh)) {

// non-0 payload size:

auto payloadsize = o2::raw::RDHUtils::getMemorySize(rdh) - o2::raw::RDHUtils::getHeaderSize(rdh);

int endpoint = static_cast<int>(o2::raw::RDHUtils::getEndPointID(rdh));

auto fee = o2::raw::RDHUtils::getFEEID(rdh);

LOG(debug) << "Next RDH: ";

LOG(debug) << "Found fee 0x" << std::hex << fee << std::dec << " (System " << (fee == 0xcafe ? "Pads" : "Pixels") << ")";

LOG(debug) << "Found trigger BC: " << o2::raw::RDHUtils::getTriggerBC(rdh);

LOG(debug) << "Found trigger Oribt: " << o2::raw::RDHUtils::getTriggerOrbit(rdh);

LOG(debug) << "Found payload size: " << payloadsize;

LOG(debug) << "Found offset to next: " << o2::raw::RDHUtils::getOffsetToNext(rdh);

LOG(debug) << "Stop bit: " << (o2::raw::RDHUtils::getStop(rdh) ? "yes" : "no");

LOG(debug) << "Number of GBT words: " << (payloadsize * sizeof(char) / (fee == 0xcafe ? sizeof(o2::focal::PadGBTWord) : sizeof(o2::itsmft::GBTWord)));

auto page_payload = databuffer.subspan(currentpos + o2::raw::RDHUtils::getHeaderSize(rdh), payloadsize);

std::copy(page_payload.begin(), page_payload.end(), std::back_inserter(rawbuffer));

}

auto trigger = o2::raw::RDHUtils::getTriggerType(rdh);

if (trigger & o2::trigger::HB) {

// HB trigger received

if (o2::raw::RDHUtils::getStop(rdh)) {

LOG(debug) << "Stop bit received - processing payload";

// Data ready

if (rawbuffer.size()) {

// Only process if we actually have payload (skip empty HBF)

if (currentfee == 0xcafe) { // Use FEE ID 0xcafe for PAD data

// Pad data

if (mUsePadData) {

LOG(debug) << "Processing PAD data";

auto nEventsPads = decodePadData(rawbuffer, currentIR);

mTimeframeHasPadData = true;

auto found = mNumEventsHBFPads.find(nEventsPads);

if (found != mNumEventsHBFPads.end()) {

found->second += 1;

} else {

mNumEventsHBFPads.insert(std::pair<int, int>{nEventsPads, 1});

}

numEventsPadsTF += nEventsPads;

numHBFPadsTF++;

}

} else { // All other FEEs are pixel FEEs

// Pixel data

if (mUsePixelData) {

auto feeID = o2::raw::RDHUtils::getFEEID(rdh);

if (firstHBF) {

auto found = std::find(expectFEEs.begin(), expectFEEs.end(), feeID);

if (found == expectFEEs.end()) {

expectFEEs.emplace_back(feeID);

}

firstHBF = false;

}

LOG(debug) << "Processing Pixel data from FEE " << feeID;

auto neventsPixels = decodePixelData(rawbuffer, currentIR, feeID);

mTimeframeHasPixelData = true;

auto found = numHBFFEE.find(feeID);

if (found != numHBFFEE.end()) {

found->second++;

} else {

numHBFFEE.insert(std::pair<int, int>{feeID, 1});

}

auto evFound = numEventsFEE.find(feeID);

if (evFound != numEventsFEE.end()) {

evFound->second += neventsPixels;

} else {

numEventsFEE.insert(std::pair<int, int>{feeID, neventsPixels});

}

auto evHBFFound = numEventsHBFFEE.find(feeID);

if (evHBFFound != numEventsHBFFEE.end()) {

evHBFFound->second.push_back(neventsPixels);

} else {

std::vector<int> evbuffer;

evbuffer.push_back(neventsPixels);

numEventsHBFFEE.insert(std::pair<int, std::vector<int>>{feeID, evbuffer});

}

}

}

} else {

LOG(debug) << "Payload size 0 - skip empty HBF";

}

rawbuffer.clear();

} else {

// Get interaction record for HBF

currentIR.bc = o2::raw::RDHUtils::getTriggerBC(rdh);

currentIR.orbit = o2::raw::RDHUtils::getTriggerOrbit(rdh);

currentfee = o2::raw::RDHUtils::getFEEID(rdh);

LOG(debug) << "New HBF " << currentIR.orbit << " / " << currentIR.bc << ", FEE 0x" << std::hex << currentfee << std::dec;

}

}

currentpos += o2::raw::RDHUtils::getOffsetToNext(rdh);

}

} else {

LOG(error) << "Input " << inputs << ": Either header or payload is nullptr";

}

inputs++;

}

int numHBFPixelsTF = 0;

if (mTimeframeHasPixelData) {

// Consistency check PixelEvents

if (!consistencyCheckPixelFEE(numHBFFEE)) {

LOG(alarm) << "Mismatch in number of HBF / TF between pixel FEEs";

if (mDisplayInconsistent) {

printCounters(numHBFFEE);

}

mNumInconsistencyPixelHBF++;

}

numHBFPixelsTF = maxCounter(numHBFFEE);

mNumHBFPixels += numHBFPixelsTF;

if (!consistencyCheckPixelFEE(numEventsFEE)) {

LOG(alarm) << "Mismatch in number of events / TF between pixel FEEs";

if (mDisplayInconsistent) {

printCounters(numEventsFEE);

}

mNumInconsistencyPixelEvent++;

}

mNumEventsPixels += maxCounter(numEventsFEE);

if (!checkEventsHBFConsistency(numEventsHBFFEE)) {

LOG(alarm) << "Mistmatch number of events / HBF between pixel FEEs";

if (mDisplayInconsistent) {

printEvents(numEventsHBFFEE);

}

mNumInconsistencyPixelEventHBF++;

}

fillPixelEventHBFCount(numEventsHBFFEE);

if (mFilterIncomplete) {

LOG(debug) << "Filtering incomplete pixel events";

for (auto& hbf : mHBFs) {

auto numErased = filterIncompletePixelsEventsHBF(hbf.second, expectFEEs);

mNumEventsPixels -= numErased;

}

}

}

LOG(info) << "Found " << mHBFs.size() << " HBFs in timeframe";

LOG(debug) << "EventBuilder: Pixels: " << (mTimeframeHasPixelData ? "yes" : "no");

LOG(debug) << "EventBuilder: Pads: " << (mTimeframeHasPadData ? "yes" : "no");

buildEvents();

LOG(info) << "Found " << mOutputTriggerRecords.size() << " events in timeframe";

sendOutput(ctx);

mNumEventsPads += numEventsPadsTF;

mNumHBFPads += numHBFPadsTF;

mNumTimeframes++;

auto foundHBFperTFPads = mNumHBFperTFPads.find(numHBFPadsTF);

if (foundHBFperTFPads != mNumHBFperTFPads.end()) {

foundHBFperTFPads->second++;

} else {

mNumHBFperTFPads.insert(std::pair<int, int>{numHBFPadsTF, 1});

}

auto foundHBFperTFPixels = mNumHBFperTFPixels.find(numHBFPixelsTF);

if (foundHBFperTFPixels != mNumHBFperTFPixels.end()) {

foundHBFperTFPixels->second++;

} else {

mNumHBFperTFPixels.insert(std::pair<int, int>{numHBFPixelsTF, 1});

}

}

void RawDecoderSpec::endOfStream(o2::framework::EndOfStreamContext& ec)

{

std::cout << "Number of timeframes: " << mNumTimeframes << std::endl;

std::cout << "Number of pad HBFs: " << mNumHBFPads << std::endl;

std::cout << "Number of pixel HBFs: " << mNumHBFPixels << std::endl;

for (auto& [hbfs, tfs] : mNumHBFperTFPads) {

std::cout << "Pads - Number of TFs with " << hbfs << " HBFs: " << tfs << std::endl;

}

for (auto& [hbfs, tfs] : mNumHBFperTFPixels) {

std::cout << "Pixels - Number of TFs with " << hbfs << " HBFs: " << tfs << std::endl;

}

std::cout << "Number of pad events: " << mNumEventsPads << std::endl;

std::cout << "Number of pixel events: " << mNumEventsPixels << std::endl;

for (auto& [nevents, nHBF] : mNumEventsHBFPads) {

std::cout << "Number of HBFs with " << nevents << " pad events: " << nHBF << std::endl;

}

for (auto& [nevents, nHBF] : mNumEventsHBFPixels) {

std::cout << "Number of HBFs with " << nevents << " pixel events: " << nHBF << std::endl;

}

std::cout << "Number of inconsistencies between pixel FEEs: " << mNumInconsistencyPixelHBF << " HBFs, " << mNumInconsistencyPixelEvent << " events, " << mNumInconsistencyPixelEventHBF << " events / HBF" << std::endl;

}

void RawDecoderSpec::sendOutput(framework::ProcessingContext& ctx)

{

ctx.outputs().snapshot(framework::Output{o2::header::gDataOriginFOC, "PADLAYERS", mOutputSubspec}, mOutputPadLayers);

ctx.outputs().snapshot(framework::Output{o2::header::gDataOriginFOC, "PIXELHITS", mOutputSubspec}, mOutputPixelHits);

ctx.outputs().snapshot(framework::Output{o2::header::gDataOriginFOC, "PIXELCHIPS", mOutputSubspec}, mOutputPixelChips);

ctx.outputs().snapshot(framework::Output{o2::header::gDataOriginFOC, "TRIGGERS", mOutputSubspec}, mOutputTriggerRecords);

}

void RawDecoderSpec::resetContainers()

{

mHBFs.clear();

mOutputPadLayers.clear();

mOutputPixelChips.clear();

mOutputPixelHits.clear();

mOutputTriggerRecords.clear();

}

int RawDecoderSpec::decodePadData(const gsl::span<const char> padWords, o2::InteractionRecord& hbIR)

{

LOG(debug) << "Decoding pad data for Orbit " << hbIR.orbit << ", BC " << hbIR.bc;

constexpr std::size_t EVENTSIZEPADGBT = 1180,

EVENTSIZECHAR = EVENTSIZEPADGBT * sizeof(PadGBTWord) / sizeof(char);

auto nevents = padWords.size() / (EVENTSIZECHAR);

for (int ievent = 0; ievent < nevents; ievent++) {

decodePadEvent(padWords.subspan(EVENTSIZECHAR * ievent, EVENTSIZECHAR), hbIR);

}

return nevents;

}

void RawDecoderSpec::decodePadEvent(const gsl::span<const char> padWords, o2::InteractionRecord& hbIR)

{

gsl::span<const PadGBTWord> padWordsGBT(reinterpret_cast<const PadGBTWord*>(padWords.data()), padWords.size() / sizeof(PadGBTWord));

mPadDecoder.reset();

mPadDecoder.decodeEvent(padWordsGBT);

std::map<o2::InteractionRecord, HBFData>::iterator foundHBF = mHBFs.find(hbIR);

if (foundHBF == mHBFs.end()) {

// New event, create new entry

HBFData nexthbf;

auto res = mHBFs.insert({hbIR, nexthbf});

foundHBF = res.first;

}

foundHBF->second.mPadEvents.push_back(createPadLayerEvent(mPadDecoder.getData()));

}

int RawDecoderSpec::decodePixelData(const gsl::span<const char> pixelWords, o2::InteractionRecord& hbIR, int feeID)

{

LOG(debug) << "Decoding pixel data for Orbit " << hbIR.orbit << ", BC " << hbIR.bc;

gsl::span<const o2::itsmft::GBTWord> pixelpayload(reinterpret_cast<const o2::itsmft::GBTWord*>(pixelWords.data()), pixelWords.size() / sizeof(o2::itsmft::GBTWord));

LOG(debug) << pixelWords.size() << " Bytes -> " << pixelpayload.size() << " GBT words";

mPixelDecoder.reset();

mPixelDecoder.decodeEvent(pixelpayload);

std::map<o2::InteractionRecord, HBFData>::iterator foundHBF = mHBFs.end();

int nevents = 0;

for (auto& [trigger, chipdata] : mPixelDecoder.getChipData()) {

LOG(debug) << "Found trigger orbit " << trigger.orbit << ", BC " << trigger.bc;

if (trigger.orbit != hbIR.orbit) {

LOG(debug) << "FEE 0x" << std::hex << feeID << std::dec << ": Discarding spurious trigger with Orbit " << trigger.orbit << " (HB " << hbIR.orbit << ")";

continue;

}

int nhits = 0;

// set fee for all chips

for (auto& chip : chipdata) {

nhits += chip.mHits.size();

}

// std::cout << "FEE 0x" << std::hex << feeID << std::dec << " (fee " << fee << ", branch " << branch << ", layer " << layer << "): Found " << chipdata.size() << " chips with " << nhits << " hits (total) for Orbit " << trigger.orbit << ", BC " << trigger.bc << std::endl;

// for (const auto& chip : chipdata) {

// std::cout << "Chip " << static_cast<int>(chip.mChipID) << ", lane " << static_cast<int>(chip.mLaneID) << ": " << chip.mHits.size() << " hits ... (Dataframe "

// << (chip.isDataframe() ? "yes" : "no") << ", Emptyframe " << (chip.isEmptyframe() ? "yes" : "no") << ", Busy on " << (chip.isBusyOn() ? "yes" : "no") << ", Busy off " << (chip.isBusyOff() ? "yes" : "no") << ")" << std::endl;

// }

if (foundHBF == mHBFs.end()) {

// take HBF from the first trigger as BC in RDH for pixel data is unreliable

foundHBF = mHBFs.find(hbIR);

if (foundHBF == mHBFs.end()) {

// New event, create new entry

HBFData nexthbf;

auto res = mHBFs.insert({hbIR, nexthbf});

foundHBF = res.first;

}

}

// check if the trigger already exists

auto triggerfound = std::find(foundHBF->second.mPixelTriggers.begin(), foundHBF->second.mPixelTriggers.end(), trigger);

if (triggerfound != foundHBF->second.mPixelTriggers.end()) {

//

auto index = triggerfound - foundHBF->second.mPixelTriggers.begin();

for (const auto& chip : chipdata) {

try {

auto chipPosition = mPixelMapping->getPosition(feeID, chip);

fillChipToLayer(foundHBF->second.mPixelEvent[index][chipPosition.mLayer], chip, feeID);

} catch (PixelMapper::InvalidChipException& e) {

LOG(warning) << e;

}

}

foundHBF->second.mFEEs[index].push_back(feeID);

} else {

// new trigger

std::array<PixelLayerEvent, constants::PIXELS_NLAYERS> nextevent;

foundHBF->second.mPixelEvent.push_back(nextevent);

foundHBF->second.mPixelTriggers.push_back(trigger);

auto& current = foundHBF->second.mPixelEvent.back();

for (const auto& chip : chipdata) {

try {

auto chipPosition = mPixelMapping->getPosition(feeID, chip);

fillChipToLayer(current[chipPosition.mLayer], chip, feeID);

} catch (PixelMapper::InvalidChipException& e) {

LOG(warning) << e;

}

}

foundHBF->second.mFEEs.push_back({feeID});

}

nevents++;

}

return nevents;

}

std::array<o2::focal::PadLayerEvent, o2::focal::constants::PADS_NLAYERS> RawDecoderSpec::createPadLayerEvent(const o2::focal::PadData& data) const

{

std::array<PadLayerEvent, constants::PADS_NLAYERS> result;

std::array<uint8_t, 8> triggertimes;

for (std::size_t ilayer = 0; ilayer < constants::PADS_NLAYERS; ilayer++) {

auto& asic = data.getDataForASIC(ilayer).getASIC();

int bc[2];

for (std::size_t ihalf = 0; ihalf < constants::PADLAYER_MODULE_NHALVES; ihalf++) {

auto header = asic.getHeader(ihalf);

bc[ihalf] = header.mBCID;

auto calib = asic.getCalib(ihalf);

auto cmn = asic.getCMN(ihalf);

result[ilayer].setHeader(ihalf, header.getHeader(), header.getBCID(), header.getWadd(), header.getFourbit(), header.getTrailer());

result[ilayer].setCalib(ihalf, calib.getADC(), calib.getTOA(), calib.getTOT());

result[ilayer].setCMN(ihalf, cmn.getADC(), cmn.getTOA(), cmn.getTOT());

}

for (std::size_t ichannel = 0; ichannel < constants::PADLAYER_MODULE_NCHANNELS; ichannel++) {

auto channel = asic.getChannel(ichannel);

result[ilayer].setChannel(ichannel, channel.getADC(), channel.getTOA(), channel.getTOT());

}

auto triggers = data.getDataForASIC(ilayer).getTriggerWords();

for (std::size_t window = 0; window < constants::PADLAYER_WINDOW_LENGTH; window++) {

std::fill(triggertimes.begin(), triggertimes.end(), 0);

triggertimes[0] = triggers[window].mTrigger0;

triggertimes[1] = triggers[window].mTrigger1;

triggertimes[2] = triggers[window].mTrigger2;

triggertimes[3] = triggers[window].mTrigger3;

triggertimes[4] = triggers[window].mTrigger4;

triggertimes[5] = triggers[window].mTrigger5;

triggertimes[6] = triggers[window].mTrigger6;

triggertimes[7] = triggers[window].mTrigger7;

result[ilayer].setTrigger(window, triggers[window].mHeader0, triggers[window].mHeader1, triggertimes);

}

}

return result;

}

void RawDecoderSpec::fillChipToLayer(o2::focal::PixelLayerEvent& pixellayer, const o2::focal::PixelChip& chipData, int feeID)

{

int nhitsBefore = 0;

int nchipsBefore = pixellayer.getChips().size();

for (auto& chip : pixellayer.getChips()) {

nhitsBefore += chip.mHits.size();

}

pixellayer.addChip(feeID, chipData.mLaneID, chipData.mChipID, chipData.mStatusCode, chipData.mHits);

int nhitsAfter = 0;

int nchipsAfter = pixellayer.getChips().size();

for (auto& chip : pixellayer.getChips()) {

nhitsAfter += chip.mHits.size();

}

// std::cout << "Adding to pixel layer: Chips before " << nchipsBefore << " / after " << nchipsAfter << ", hits before " << nhitsBefore << " / after " << nhitsAfter << std::endl;

}

void RawDecoderSpec::fillEventPixeHitContainer(std::vector<PixelHit>& eventHits, std::vector<PixelChipRecord>& eventChips, const PixelLayerEvent& pixelLayer, int layerIndex)

{

for (auto& chip : pixelLayer.getChips()) {

auto starthits = eventHits.size();

auto& chipHits = chip.mHits;

std::copy(chipHits.begin(), chipHits.end(), std::back_inserter(eventHits));

eventChips.emplace_back(layerIndex, chip.mFeeID, chip.mLaneID, chip.mChipID, chip.mStatusCode, starthits, chipHits.size());

}

}

void RawDecoderSpec::buildEvents()

{

LOG(debug) << "Start building events" << std::endl;

for (const auto& [hbir, hbf] : mHBFs) {

if (mTimeframeHasPadData && mTimeframeHasPixelData) {

LOG(debug) << "Processing HBF with IR: " << hbir.orbit << " / " << hbir.bc << std::endl;

// check consistency in number of events between triggers, pixels and pads

// in case all events are in the stream

if ((hbf.mPadEvents.size() != hbf.mPixelEvent.size()) || (hbf.mPadEvents.size() != hbf.mPixelTriggers.size()) || (hbf.mPixelEvent.size() != hbf.mPixelTriggers.size())) {

LOG(error) << "Inconsistent number of events in HBF for pads (" << hbf.mPadEvents.size() << ") and pixels (" << hbf.mPixelEvent.size() << ") - " << hbf.mPixelTriggers.size() << " triggers";

continue;

}

LOG(debug) << "HBF: " << hbf.mPixelTriggers.size() << " triggers, " << hbf.mPadEvents.size() << " pad events, " << hbf.mPixelEvent.size() << " pixel events" << std::endl;

for (std::size_t itrg = 0; itrg < hbf.mPixelTriggers.size(); itrg++) {

auto startPads = mOutputPadLayers.size(),

startHits = mOutputPixelHits.size(),

startChips = mOutputPixelChips.size();

for (std::size_t ilayer = 0; ilayer < constants::PADS_NLAYERS; ilayer++) {

mOutputPadLayers.push_back(hbf.mPadEvents[itrg][ilayer]);

}

std::vector<PixelHit> eventHits;

std::vector<PixelChipRecord> eventPixels;

for (std::size_t ilayer = 0; ilayer < constants::PIXELS_NLAYERS; ilayer++) {

fillEventPixeHitContainer(eventHits, eventPixels, hbf.mPixelEvent[itrg][ilayer], ilayer);

}

std::copy(eventHits.begin(), eventHits.end(), std::back_inserter(mOutputPixelHits));

std::copy(eventPixels.begin(), eventPixels.end(), std::back_inserter(mOutputPixelChips));

// std::cout << "Orbit " << hbf.mPixelTriggers[itrg].orbit << ", BC " << hbf.mPixelTriggers[itrg].bc << ": " << eventPixels.size() << " chips with " << eventHits.size() << " hits ..." << std::endl;

mOutputTriggerRecords.emplace_back(hbf.mPixelTriggers[itrg], startPads, constants::PADS_NLAYERS, startChips, eventPixels.size(), startHits, eventHits.size());

}

} else if (mTimeframeHasPixelData) {

// only pixel data available, merge pixel layers and interaction record

if (!(hbf.mPixelEvent.size() == hbf.mPixelTriggers.size())) {

LOG(error) << "Inconsistent number of pixel events (" << hbf.mPixelEvent.size() << ") and triggers (" << hbf.mPixelTriggers.size() << ") in HBF";

continue;

}

for (std::size_t itrg = 0; itrg < hbf.mPixelTriggers.size(); itrg++) {

auto startPads = mOutputPadLayers.size(),

startHits = mOutputPixelHits.size(),

startChips = mOutputPixelChips.size();

std::vector<PixelHit> eventHits;

std::vector<PixelChipRecord> eventPixels;

for (std::size_t ilayer = 0; ilayer < constants::PIXELS_NLAYERS; ilayer++) {

fillEventPixeHitContainer(eventHits, eventPixels, hbf.mPixelEvent[itrg][ilayer], ilayer);

}

std::copy(eventHits.begin(), eventHits.end(), std::back_inserter(mOutputPixelHits));

std::copy(eventPixels.begin(), eventPixels.end(), std::back_inserter(mOutputPixelChips));

mOutputTriggerRecords.emplace_back(hbf.mPixelTriggers[itrg], startPads, 0, startChips, eventPixels.size(), startHits, eventHits.size());

}

} else if (mTimeframeHasPadData) {

// only pad data available, set pad layers and use IR of the HBF

for (std::size_t itrg = 0; itrg < hbf.mPadEvents.size(); itrg++) {

auto startPads = mOutputPadLayers.size(),

startHits = mOutputPixelHits.size(),

startChips = mOutputPixelChips.size();

o2::InteractionRecord fakeBC;

fakeBC.orbit = hbir.orbit;

fakeBC.bc = hbir.bc + itrg;

for (std::size_t ilayer = 0; ilayer < constants::PADS_NLAYERS; ilayer++) {

mOutputPadLayers.push_back(hbf.mPadEvents[itrg][ilayer]);

}

mOutputTriggerRecords.emplace_back(hbir, startPads, constants::PADS_NLAYERS, startChips, 0, startHits, 0);

}

}

}

}

int RawDecoderSpec::filterIncompletePixelsEventsHBF(HBFData& data, const std::vector<int>& expectFEEs)

{

auto same = [](const std::vector<int>& lhs, const std::vector<int>& rhs) -> bool {

bool missing = false;

for (auto entry : lhs) {

if (std::find(rhs.begin(), rhs.end(), entry) == rhs.end()) {

missing = true;

break;

}

}

if (!missing) {

for (auto entry : rhs) {

if (std::find(lhs.begin(), lhs.end(), entry) == lhs.end()) {

missing = true;

break;

}

}

}

return missing;

};

std::vector<int> indexIncomplete;

for (auto index = 0; index < data.mFEEs.size(); index++) {

if (data.mFEEs[index].size() != expectFEEs.size()) {

indexIncomplete.emplace_back(index);

continue;

}

if (!same(data.mFEEs[index], expectFEEs)) {

indexIncomplete.emplace_back(index);

}

}

if (indexIncomplete.size()) {

std::sort(indexIncomplete.begin(), indexIncomplete.end(), std::less<>());

// start removing from the end, since erase will impact the indexing

for (auto indexIter = indexIncomplete.rbegin(); indexIter != indexIncomplete.rend(); indexIter++) {

auto iterPixelEvent = data.mPixelEvent.begin() + *indexIter;

auto iterTrigger = data.mPixelTriggers.begin() + *indexIter;

auto iterFEEs = data.mFEEs.begin() + *indexIter;

data.mPixelEvent.erase(iterPixelEvent);

data.mPixelTriggers.erase(iterTrigger);

data.mFEEs.erase(iterFEEs);

}

}

return indexIncomplete.size();

}

bool RawDecoderSpec::consistencyCheckPixelFEE(const std::unordered_map<int, int>& counters) const

{

bool initialized = false;

bool discrepancy = false;

int current = -1;

for (auto& [fee, value] : counters) {

if (!initialized) {

current = value;

initialized = true;

}

if (value != current) {

discrepancy = true;

break;

}

}

return !discrepancy;

}

bool RawDecoderSpec::checkEventsHBFConsistency(const std::unordered_map<int, std::vector<int>>& counters) const

{

bool initialized = false;

bool discrepancy = false;

std::vector<int> current;

for (auto& [fee, events] : counters) {

if (!initialized) {

current = events;

initialized = true;

}

if (events != current) {

discrepancy = true;

}

}

return !discrepancy;

}

int RawDecoderSpec::maxCounter(const std::unordered_map<int, int>& counters) const

{

int maxCounter = 0;

for (auto& [fee, counter] : counters) {

if (counter > maxCounter) {

maxCounter = counter;

}

}

return maxCounter;

}

void RawDecoderSpec::printCounters(const std::unordered_map<int, int>& counters) const

{

for (auto& [fee, counter] : counters) {

LOG(info) << " FEE 0x" << std::hex << fee << std::dec << ": " << counter << " counts ...";

}

}

void RawDecoderSpec::printEvents(const std::unordered_map<int, std::vector<int>>& counters) const

{

for (auto& [fee, events] : counters) {

std::stringstream stringbuilder;

bool first = true;

for (auto ev : events) {

if (first) {

first = false;

} else {

stringbuilder << ", ";

}

stringbuilder << ev;

}

LOG(info) << " FEE 0x" << std::hex << fee << std::dec << ": " << stringbuilder.str() << " events ...";

}

}

void RawDecoderSpec::fillPixelEventHBFCount(const std::unordered_map<int, std::vector<int>>& counters)

{

// take FEE with the max number of events - expecting other FEEs might miss events

int maxFEE = 0;

int current = -1;

for (auto& [fee, events] : counters) {

int sum = 0;

for (auto ev : events) {

sum += ev;

}

if (sum > current) {

maxFEE = fee;

current = sum;

}

}

auto en = counters.find(maxFEE);

if (en != counters.end()) {

for (auto nEventsPixels : en->second) {

auto found = mNumEventsHBFPixels.find(nEventsPixels);

if (found != mNumEventsHBFPixels.end()) {

found->second += 1;

} else {

mNumEventsHBFPixels.insert(std::pair<int, int>{nEventsPixels, 1});

}

}

}

}

o2::framework::DataProcessorSpec o2::focal::reco_workflow::getRawDecoderSpec(bool askDISTSTF, uint32_t outputSubspec, bool usePadData, bool usePixelData, bool debugMode)

{

constexpr auto originFOC = o2::header::gDataOriginFOC;

std::vector<o2::framework::OutputSpec> outputs;

outputs.emplace_back(originFOC, "PADLAYERS", outputSubspec, o2::framework::Lifetime::Timeframe);

outputs.emplace_back(originFOC, "PIXELHITS", outputSubspec, o2::framework::Lifetime::Timeframe);

outputs.emplace_back(originFOC, "PIXELCHIPS", outputSubspec, o2::framework::Lifetime::Timeframe);

outputs.emplace_back(originFOC, "TRIGGERS", outputSubspec, o2::framework::Lifetime::Timeframe);

std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originFOC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Timeframe}};

if (askDISTSTF) {

inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);

}

return o2::framework::DataProcessorSpec{"FOCALRawDecoderSpec",

inputs,

outputs,

o2::framework::adaptFromTask<o2::focal::reco_workflow::RawDecoderSpec>(outputSubspec, usePadData, usePixelData, debugMode),

o2::framework::Options{

{"filterIncomplete", o2::framework::VariantType::Bool, false, {"Filter incomplete pixel events"}},

{"displayInconsistent", o2::framework::VariantType::Bool, false, {"Display information about inconsistent timeframes"}},

{"pixeltype", o2::framework::VariantType::String, "OB", {"Pixel mapping type"}},

{"pixelmapping", o2::framework::VariantType::String, "default", {"File with pixel mapping"}}}};

}