DCSProcessor.h

Go to the documentation of this file.

// 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.
 
#ifndef DETECTOR_TRDDCSPROCESSOR_H_
#define DETECTOR_TRDDCSPROCESSOR_H_
 
#include "Framework/Logger.h"
#include "DetectorsDCS/DataPointCompositeObject.h"
#include "DetectorsDCS/DataPointIdentifier.h"
#include "DetectorsDCS/DataPointValue.h"
#include "DetectorsDCS/DeliveryType.h"
#include "CCDB/CcdbObjectInfo.h"
#include "CommonUtils/MemFileHelper.h"
#include "DataFormatsTRD/DcsCcdbObjects.h"
#include "DataFormatsTRD/Constants.h"
 
#include "CCDB/CcdbApi.h"
#include <Rtypes.h>
#include <unordered_map>
#include <string>
#include <bitset>
#include <gsl/gsl>
 
 
namespace o2
{
namespace trd
{
 
using DPID = o2::dcs::DataPointIdentifier;
using DPVAL = o2::dcs::DataPointValue;
using DPCOM = o2::dcs::DataPointCompositeObject;
 
class DCSProcessor
{
 
 public:
  using TFType = uint64_t;
  using CcdbObjectInfo = o2::ccdb::CcdbObjectInfo;
 
  DCSProcessor() = default;
  ~DCSProcessor() = default;
 
  // initialization based on configured DP IDs
  void init(const std::vector<DPID>& pids);
 
  // processing methods
  int process(const gsl::span<const DPCOM> dps);
  int processDP(const DPCOM& dpcom);
  int processFlags(uint64_t flag, const char* pid);
 
  // these functions prepare the CCDB objects
  bool updateGasDPsCCDB();
  bool updateVoltagesDPsCCDB();
  bool updateCurrentsDPsCCDB();
  bool updateEnvDPsCCDB();
  bool updateFedChamberStatusDPsCCDB();
  bool updateFedCFGtagDPsCCDB();
 
  // signal that the CCDB object for the voltages should be updated due to change exceeding threshold
  bool shouldUpdateVoltages() const { return mShouldUpdateVoltages; }
  // LB: Only update ChamberStatus/CFGtag if both conditions are met (complete DPs and new run)
  bool shouldUpdateFedChamberStatus() const { return mFedChamberStatusCompleteDPs && mFirstRunEntryForFedChamberStatusUpdate; }
  bool shouldUpdateFedCFGtag() const { return mFedCFGtagCompleteDPs && mFirstRunEntryForFedCFGtagUpdate; }
  // LB: Env DPs have no alias pattern, processor uses this function to identify if alias is Env
  bool isAliasFromEnvDP(const char* dpalias) const
  {
    std::vector<std::string> envaliases = {"CavernTemperature", "temperature_P2_external", "AtmosPressure", "UXC2Humidity"};
    for (const auto& envalias : envaliases) {
      if (std::strstr(dpalias, envalias.c_str()) != nullptr) {
        return true;
      }
    }
    return false;
  }
 
  // 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& getccdbFedChamberStatusDPsInfo() { return mCcdbFedChamberStatusDPsInfo; }
  CcdbObjectInfo& getccdbFedCFGtagDPsInfo() { return mCcdbFedCFGtagDPsInfo; }
 
  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::array<int, constants::MAXCHAMBER>& getTRDFedChamberStatusDPsInfo() const { return mTRDDCSFedChamberStatus; }
  const std::array<string, constants::MAXCHAMBER>& getTRDFedCFGtagDPsInfo() const { return mTRDDCSFedCFGtag; }
 
  // settings
  void setCurrentTS(TFType tf) { mCurrentTS = tf; }
  void setVerbosity(int v) { mVerbosity = v; }
  void setMaxCounterAlarmFed(int alarmfed) { mFedAlarmCounterMax = alarmfed; }
  void setFedMinimunDPsForUpdate(int minupdatefed) { mFedMinimunDPsForUpdate = minupdatefed; }
  void setUVariationTriggerForUpdate(float utrigger) { mUVariationTriggerForUpdate = utrigger; }
 
  // reset methods
  void clearGasDPsInfo();
  void clearVoltagesDPsInfo();
  void clearCurrentsDPsInfo();
  void clearEnvDPsInfo();
  void clearRunDPsInfo();
  void clearFedChamberStatusDPsInfo();
  void clearFedCFGtagDPsInfo();
 
  // helper functions
  int getChamberIdFromAlias(const char* alias) const;
 
 private:
  // the CCDB objects
  std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSGas;      
  std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSCurrents; 
  std::unordered_map<DPID, float> mTRDDCSVoltages;                
  std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSEnv;      
  std::array<int, constants::MAXCHAMBER> mTRDDCSFedChamberStatus; 
  std::array<string, constants::MAXCHAMBER> mTRDDCSFedCFGtag;     
 
  // helper variables
  std::unordered_map<DPID, bool> mPids;                 
  std::unordered_map<DPID, uint64_t> mLastDPTimeStamps; 
  CcdbObjectInfo mCcdbGasDPsInfo;
  CcdbObjectInfo mCcdbVoltagesDPsInfo;
  CcdbObjectInfo mCcdbCurrentsDPsInfo;
  CcdbObjectInfo mCcdbEnvDPsInfo;
  CcdbObjectInfo mCcdbFedChamberStatusDPsInfo;
  CcdbObjectInfo mCcdbFedCFGtagDPsInfo;
 
  TFType mGasStartTS;      
  TFType mVoltagesStartTS; 
  TFType mCurrentsStartTS; 
  TFType mEnvStartTS;
  TFType mFedChamberStatusStartTS;
  TFType mFedCFGtagStartTS;
  TFType mCurrentTS{0}; 
  bool mGasStartTSset{false};
  bool mVoltagesStartTSSet{false};
  bool mCurrentsStartTSSet{false};
  bool mEnvStartTSSet{false};
  bool mFedChamberStatusStartTSSet{false};
  bool mFedCFGtagStartTSSet{false};
  std::bitset<constants::MAXCHAMBER> mVoltageSet{};
  bool mShouldUpdateVoltages{false};
  // LB: FedChamberStatus and FedCFGtag logic
  bool mFedChamberStatusCompleteDPs{false};
  bool mFedCFGtagCompleteDPs{false};
  bool mFirstRunEntryForFedChamberStatusUpdate{false};
  bool mFirstRunEntryForFedCFGtagUpdate{false};
  int mCurrentRunNumber{-1};
  int mFedChamberStatusAlarmCounter{0};
  int mFedCFGtagAlarmCounter{0};
 
  // settings
  int mVerbosity{0};
  int mFedAlarmCounterMax{1};
  int mFedMinimunDPsForUpdate{522};
  float mUVariationTriggerForUpdate{1.0};
 
  ClassDefNV(DCSProcessor, 0);
};
 
} // namespace trd
} // namespace o2
 
#endif