// 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 <string>

#include "CommonDataFormat/InteractionRecord.h"

#include "DataFormatsTRD/TriggerRecord.h"

#include "DataFormatsTRD/Tracklet64.h"

#include "DataFormatsTRD/Digit.h"

#include "TRDReconstruction/EventRecord.h"

#include "DataFormatsTRD/Constants.h"

#include "Framework/Output.h"

#include "Framework/ProcessingContext.h"

#include "Framework/ControlService.h"

#include "Framework/ConfigParamRegistry.h"

#include "Framework/RawDeviceService.h"

#include "Framework/DeviceSpec.h"

#include "Framework/DataSpecUtils.h"

#include "Framework/InputRecordWalker.h"

#include "DataFormatsTRD/Constants.h"

#include "DetectorsBase/TFIDInfoHelper.h"

#include <cassert>

#include <array>

#include <string>

#include <bitset>

#include <vector>

#include <gsl/span>

#include <typeinfo>

namespace o2::trd

{

void EventRecord::sortData(bool sortDigits)

{

auto ordering = [](const auto& lhs, const auto& rhs) {

return (lhs.getDetector() < rhs.getDetector()) ||

(lhs.getDetector() == rhs.getDetector() && lhs.getPadRow() < rhs.getPadRow()) ||

(lhs.getDetector() == rhs.getDetector() && lhs.getPadRow() == rhs.getPadRow() && lhs.getPadCol() < rhs.getPadCol());

};

std::sort(mTracklets.begin(), mTracklets.end(), ordering);

if (sortDigits) {

// after this digits are not strictly ordered by MCM anymore because of shared digits!

// not needed for noise runs

std::sort(mDigits.begin(), mDigits.end(), ordering);

}

}

void EventRecordContainer::sendData(o2::framework::ProcessingContext& pc, bool generatestats, bool sortDigits, bool sendLinkStats)

{

//at this point we know the total number of tracklets and digits and triggers.

auto dataReadStart = std::chrono::high_resolution_clock::now();

size_t digitcount = 0;

size_t trackletcount = 0;

std::vector<Tracklet64> tracklets;

std::vector<Digit> digits;

std::vector<TriggerRecord> triggers;

std::vector<DataCountersPerTrigger> counters;

for (auto& event : mEventRecords) {

event.sortData(sortDigits);

tracklets.insert(tracklets.end(), event.getTracklets().begin(), event.getTracklets().end());

digits.insert(digits.end(), event.getDigits().begin(), event.getDigits().end());

triggers.emplace_back(event.getBCData(), digitcount, event.getDigits().size(), trackletcount, event.getTracklets().size());

digitcount += event.getDigits().size();

trackletcount += event.getTracklets().size();

counters.push_back(event.getCounters());

}

pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTRD, "DIGITS", 0}, digits);

pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTRD, "TRACKLETS", 0}, tracklets);

pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTRD, "TRKTRGRD", 0}, triggers);

if (generatestats) {

accumulateStats();

o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mTFStats.mTFIDInfo);

pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTRD, "RAWSTATS", 0}, mTFStats);

}

if (sendLinkStats) {

pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTRD, "LINKSTATS", 0}, counters);

}

std::chrono::duration<double, std::micro> dataReadTime = std::chrono::high_resolution_clock::now() - dataReadStart;

LOG(debug) << "Preparing for sending and sending data took " << std::chrono::duration_cast<std::chrono::milliseconds>(dataReadTime).count() << "ms";

}

void EventRecordContainer::accumulateStats()

{

mTFStats.mNTriggersTotal = mEventRecords.size();

for (const auto& event : mEventRecords) {

mTFStats.mTrackletsFound += event.getTracklets().size();

mTFStats.mDigitsFound += event.getDigits().size();

mTFStats.mTimeTakenForTracklets += event.getTrackletTime();

mTFStats.mTimeTakenForDigits += event.getDigitTime();

mTFStats.mTimeTaken += event.getTotalTime();

if (event.getIsCalibTrigger()) {

++mTFStats.mNTriggersCalib;

}

}

}

void EventRecordContainer::setCurrentEventRecord(const InteractionRecord& ir)

{

// check if we already have an EventRecord for given interaction

bool foundEventRecord = false;

for (int idx = 0; idx < (int)mEventRecords.size(); ++idx) {

if (mEventRecords.at(idx).getBCData() == ir) {

mCurrEventRecord = idx;

foundEventRecord = true;

}

}

if (!foundEventRecord) {

// we add a new EventRecord

mEventRecords.emplace_back(ir);

mCurrEventRecord = mEventRecords.size() - 1;

}

}

void EventRecordContainer::reset()

{

mEventRecords.clear();

mTFStats.clear();

}

} // namespace o2::trd