Commit 2c56fab

#ifndef ALICEO2_DCSCCDBOBJECTSTRD_H

#define ALICEO2_DCSCCDBOBJECTSTRD_H

#include "DataFormatsTRD/Constants.h"

#include "Rtypes.h"

#include <array>

namespace o2

{

namespace trd

{

struct TRDDCSMinMaxMeanInfo {

float minValue{0.f}; // min value seen by the TRD DCS processor

float maxValue{0.f}; // max value seen by the TRD DCS processor

float meanValue{0.f}; // mean value seen by the TRD DCS processor

int nPoints{0}; // number of values seen by the TRD DCS processor

void print() const;

void addPoint(float value);

ClassDefNV(TRDDCSMinMaxMeanInfo, 1);

};

} // namespace trd

} // namespace o2

#endif // ALICEO2_DCSCCDBOBJECTSTRD_H

#pragma link C++ struct o2::trd::TRDDCSMinMaxMeanInfo + ;

#include "DataFormatsTRD/DcsCcdbObjects.h"

#include <fairlogger/Logger.h>

using namespace o2::trd;

void TRDDCSMinMaxMeanInfo::print() const

{

LOG(info) << "Min value: " << minValue;

LOG(info) << "Max value: " << maxValue;

LOG(info) << "Mean value: " << meanValue;

LOG(info) << "Number of points added: " << nPoints;

}

void TRDDCSMinMaxMeanInfo::addPoint(float value)

{

if (nPoints == 0) {

minValue = value;

maxValue = value;

meanValue = value;

} else {

if (value < minValue) {

minValue = value;

}

if (value > maxValue) {

maxValue = value;

}

meanValue += (value - meanValue) / (nPoints + 1);

}

++nPoints;

}

To process the DCS data points for the TRD the list of aliases as for example "trd_gaschromatographXe" has to be available in the CCDB. This can be achieved with the macro `Detectors/TRD/calibration/macros/makeTRDCCDBEntryForDCS.C`. The full list of aliases is available in jira (https://alice.its.cern.ch/jira/browse/TRD-109).

With the list of aliases defined one can run the `o2-calibration-trd-dcs-sim-workflow` which provides DCS DPs for all possible aliases and sends them on via DPL. Attaching the `o2-calibration-trd-dcs-workflow` will include the processing of these data points. For testing purposes this is sufficient. In case also the CCDB should be populated the `o2-calibration-ccdb-populator-workflow` has to be appended. Via the `--ccdb-path` flag this can also be configured to write to a local CCDB for testing.

So, in order to test the workflow independent of the actual CCDB using a local instance one can do:

root $O2_ROOT/share/macro/makeTRDCCDBEntryForDCS.C+

o2-calibration-trd-dcs-sim-workflow -b --delta-fraction 0.5 --max-timeframes 10 | o2-calibration-trd-dcs-workflow -b --ccdb-path http://localhost:8080 --use-ccdb-to-configure --processor-verbosity 1 | o2-calibration-ccdb-populator-workflow -b --ccdb-path http://localhost:8080

#include "DataFormatsTRD/DcsCcdbObjects.h"

#include "DataFormatsTRD/Constants.h"

#include <bitset>

// initialization based on configured DP IDs

// processing methods

// these functions prepare the CCDB objects

bool updateGasDPsCCDB();

bool updateVoltagesDPsCCDB();

bool updateCurrentsDPsCCDB();

bool updateEnvDPsCCDB();

bool updateRunDPsCCDB();

// signal that the CCDB object for the voltages should be updated due to change exceeding threshold

bool shouldUpdateVoltages() const { return mShouldUpdateVoltages; }

bool shouldUpdateRun() const { return mShouldUpdateRun; }

// allow access to the CCDB objects from DPL processor

CcdbObjectInfo& getccdbGasDPsInfo() { return mCcdbGasDPsInfo; }

CcdbObjectInfo& getccdbVoltagesDPsInfo() { return mCcdbVoltagesDPsInfo; }

CcdbObjectInfo& getccdbCurrentsDPsInfo() { return mCcdbCurrentsDPsInfo; }

CcdbObjectInfo& getccdbEnvDPsInfo() { return mCcdbEnvDPsInfo; }

CcdbObjectInfo& getccdbRunDPsInfo() { return mCcdbRunDPsInfo; }

const std::unordered_map<DPID, TRDDCSMinMaxMeanInfo>& getTRDGasDPsInfo() const { return mTRDDCSGas; }

const std::unordered_map<DPID, float>& getTRDVoltagesDPsInfo() const { return mTRDDCSVoltages; }

const std::unordered_map<DPID, TRDDCSMinMaxMeanInfo>& getTRDCurrentsDPsInfo() const { return mTRDDCSCurrents; }

const std::unordered_map<DPID, TRDDCSMinMaxMeanInfo>& getTRDEnvDPsInfo() const { return mTRDDCSEnv; }

const std::unordered_map<DPID, int>& getTRDRunDPsInfo() const { return mTRDDCSRun; }

// settings

void setCurrentTS(TFType tf) { mCurrentTS = tf; }

void setVerbosity(int v) { mVerbosity = v; }

// reset methods

void clearGasDPsInfo();

void clearVoltagesDPsInfo();

void clearCurrentsDPsInfo();

void clearEnvDPsInfo();

void clearRunDPsInfo();

// helper functions

int getChamberIdFromAlias(const char* alias) const;

// the CCDB objects

std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSGas; ///< gas DPs (CO2, O2, H20 and from the chromatograph CO2, N2, Xe)

std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSCurrents; ///< anode and drift currents

std::unordered_map<DPID, float> mTRDDCSVoltages; ///< anode and drift voltages

std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSEnv; ///< environment parameters (temperatures, pressures)

std::unordered_map<DPID, int> mTRDDCSRun; ///< run number and run type

// TODO

// Possibly add CFG tag and chamber status here?

// Or send errors to the InfoLogger in case CFG tag mismatches are detected for chamber which have the same FSM state?

// For this I need more information on the chamber status - which status indicates all good and included in data taking?

// not TODO

// I don't think the FED ENV temperature is needed at analysis level at any point in time so I am leaving it out for now

// helper variables

std::unordered_map<DPID, bool> mPids; ///< flag for each DP whether it has been processed at least once

std::unordered_map<DPID, uint64_t> mLastDPTimeStamps; ///< for each DP keep here the time stamp of the DP processed last

CcdbObjectInfo mCcdbGasDPsInfo;

CcdbObjectInfo mCcdbVoltagesDPsInfo;

CcdbObjectInfo mCcdbCurrentsDPsInfo;

CcdbObjectInfo mCcdbEnvDPsInfo;

CcdbObjectInfo mCcdbRunDPsInfo;

TFType mGasStartTS; ///< the time stamp of the first TF which was processesd for the current GAS CCDB object

TFType mVoltagesStartTS; ///< the time stamp of the first TF which was processesd for the current voltages CCDB object

TFType mCurrentsStartTS; ///< the time stamp of the first TF which was processesd for the current voltages CCDB object

TFType mEnvStartTS;

TFType mRunStartTS;

TFType mRunEndTS;

TFType mCurrentTS{0}; ///< the time stamp of the TF currently being processed

bool mGasStartTSset{false};

bool mVoltagesStartTSSet{false};

bool mCurrentsStartTSSet{false};

bool mEnvStartTSSet{false};

bool mRunStartTSSet{false};

std::bitset<constants::MAXCHAMBER> mVoltageSet{};

bool mShouldUpdateVoltages{false};

bool mShouldUpdateRun{false};

// settings

int mVerbosity{0};

std::vector<std::string> aliasesInt;

std::vector<std::string> aliasesString;

aliasesFloat.insert(aliasesFloat.end(), {"trd_hvAnodeImon[00..539]", "trd_hvAnodeUmon[00..539]", "trd_hvDriftImon[00..539]", "trd_hvDriftUmon[00..539]"});

aliasesFloat.insert(aliasesFloat.end(), {"trd_aliEnvTempCavern", "trd_aliEnvTempP2"});

aliasesFloat.insert(aliasesFloat.end(), {"trd_aliEnvPressure00", "trd_aliEnvPressure01", "trd_aliEnvPressure02"});

aliasesInt.insert(aliasesInt.end(), {"trd_runNo", "trd_runType"});

// aliasesFloat.insert(aliasesFloat.end(), {"trd_cavernHumidity", "trd_fedEnvTemp[00..539]"});

// aliasesInt.insert(aliasesInt.end(), {"trd_fedChamberStatus[00..539]"});

// aliasesString.insert(aliasesString.end(), {"trd_fedCFGtag[00..539]"});

for (const auto& ali : o2::dcs::expandAliases(aliasesFloat)) {

DPID::FILL(dpidTmp, ali, o2::dcs::DeliveryType::DPVAL_DOUBLE);

for (const auto& ali : o2::dcs::expandAliases(aliasesInt)) {

DPID::FILL(dpidTmp, ali, o2::dcs::DeliveryType::DPVAL_INT);

dpid2DataDesc[dpidTmp] = "TRDDATAPOINTS";

}

for (const auto& ali : o2::dcs::expandAliases(aliasesString)) {

DPID::FILL(dpidTmp, ali, o2::dcs::DeliveryType::DPVAL_STRING);