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 O2_TPC_DCSProcessor_H_
#define O2_TPC_DCSProcessor_H_
 
#include <memory>
#include <gsl/span>
#include <algorithm>
#include <limits>
 
#include "Rtypes.h"
 
#include "DetectorsDCS/DataPointCompositeObject.h"
#include "CommonUtils/TreeStreamRedirector.h"
#include "DataFormatsTPC/DCS.h"
 
using DPCOM = o2::dcs::DataPointCompositeObject;
 
namespace o2::tpc
{
class DCSProcessor
{
 public:
  struct TimeRange {
    uint64_t first{};
    uint64_t last{};
  };
 
  void process(const gsl::span<const DPCOM> dps);
 
  float getValueF(const DPCOM& dp) const;
 
  void fillTemperature(const DPCOM& dp);
  void fillHV(const DPCOM& dp);
  void fillGas(const DPCOM& dp);
  void fillPressure(const DPCOM& dp);
  void finalizeSlot();
  void finalize();
 
  void finalizeTemperature();
  void finalizeHighVoltage();
  void finalizeGas();
  void finalizePressure();
 
  void setDebugOutputName(std::string_view name) { mDebugOutputName = name; }
 
  void setWriteDebug(const bool debug = true) { mWriteDebug = debug; }
 
  void writeDebug();
 
  void setFitInterval(dcs::TimeStampType interval) { mFitInterval = interval; }
 
  void setPressureInterval(dcs::TimeStampType interval) { mPressureInterval = interval; }
 
  void setRefPressureInterval(dcs::TimeStampType interval) { mPressureIntervalRef = interval; }
 
  auto getFitInterval() const { return mFitInterval; }
 
  auto getPressureInterval() const { return mPressureInterval; }
 
  void setRoundToInterval(const bool round = true) { mRoundToInterval = round; }
 
  void reset()
  {
    mTemperature.clear();
    mHighVoltage.clear();
    mGas.clear();
    mPressure.clear();
 
    mTimeTemperature = {};
    mTimeHighVoltage = {};
    mTimeGas = {};
  }
 
  bool hasData() const { return mHasData; }
 
  const auto& getTimeTemperature() const { return mTimeTemperature; }
  const auto& getTimeHighVoltage() const { return mTimeHighVoltage; }
  const auto& getTimeGas() const { return mTimeGas; }
  const auto& getTimePressure() const { return mTimePressure; }
 
  auto& getTemperature() { return mTemperature; }
  auto& getHighVoltage() { return mHighVoltage; }
  auto& getGas() { return mGas; }
  auto& getPressure() { return mPressure; }
 
 private:
  dcs::Temperature mTemperature; 
  dcs::HV mHighVoltage;          
  dcs::Gas mGas;                 
  dcs::Pressure mPressure;       
 
  TimeRange mTimeTemperature; 
  TimeRange mTimeHighVoltage; 
  TimeRange mTimeGas;         
  TimeRange mTimePressure;    
 
  dcs::TimeStampType mFitInterval{5 * 60 * 1000};                
  dcs::TimeStampType mPressureInterval{200 * 1000};              
  dcs::TimeStampType mPressureIntervalRef{60 * 60 * 1000};       
  bool mWriteDebug{false};                                       
  bool mRoundToInterval{false};                                  
  bool mHasData{false};                                          
  std::string mDebugOutputName{"DCS_debug.root"};                
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream; 
 
  ClassDefNV(DCSProcessor, 0);
};
 
} // namespace o2::tpc
#endif