monitor_channel.hpp

Go to the documentation of this file.

#pragma once
#include <cstdint>
#include <cmath>
#include "./../types.hpp"
 
template <bool MeanChannel=true>
class MonitorChannel;
 
template<>
class MonitorChannel<true>
{
using AccumulateType = float;
public:
 
    volatile AccumulateType Accumulate = 0.0; 
    volatile uint32_t Count = 0; 
 
    template<typename DataType>
    void push_back(DataType data)// __attribute__((always_inline))
    {
        Accumulate += (float_t)data;
        Count++; 
        //Expected Compiler optimization for integers → ++.
    }
 
    float_t mean() const __attribute__((always_inline))
    {
        
        return float_t(this->Accumulate)/ float_t(this->Count);
    }
 
    AccumulateType accumulate() const __attribute__((always_inline))
    {
        return Accumulate;
    }
 
    void reset()
    {
        Accumulate = 0.0;
        Count = 0;
    }
 
};
 
template <>
class MonitorChannel<false>
{
public:
    using AccumulateType = uint32_t;
    volatile uint32_t Count = 0; 
 
    void push_back() __attribute__((always_inline))
    {
        Count++;
    }
 
    float_t mean() const __attribute__((always_inline))
    {
        return 1.0;
    }
 
    AccumulateType accumulate() const __attribute__((always_inline))
    {
        return Count;
    }
 
    void reset()
    {
        Count = 0;
    }
};
 
 
class ZeroLagMonitor
{
public:
    float_t Second_Moment = 0;
 
    void push_back(counter_t datum) __attribute__((always_inline))
    {
        Second_Moment += datum * datum;
    }
 
    float_t get_output() __attribute__((always_inline))
    {
        return Second_Moment;
    }
};
 
 
 
 
class RTCoarseGrainer
{
public:
    float Accumulate = 0.0; 
    float Out = 0.0; 
    uint32_t UpdateCntr = 0; 
    const uint32_t CGFactor; 
    float Error = 0.0; 
 
    constexpr RTCoarseGrainer(float coarsing_interval, float minimum_resolution): 
                              CGFactor(uint32_t(std::floor(coarsing_interval / minimum_resolution))), Error(coarsing_interval - CGFactor)
    {}
 
    constexpr RTCoarseGrainer(float coarsing_interval): CGFactor(uint32_t(std::floor(coarsing_interval))), Error(coarsing_interval - CGFactor)
    {}
 
    template <typename DataType>
    void push_back(const DataType datum)
    {
        Accumulate += (datum);
        UpdateCntr++;
        if(UpdateCntr >= CGFactor)
        {
            Out = Accumulate;
            Accumulate = 0.0;
            UpdateCntr = 0;
        }
    }
 
    float inline output() const
    {
        return Out;
    }
 
    float inline error() const
    {
        return Error;
    }
};