multi_tau.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include "./../types.hpp"
 
#include "Lin_ACorr_RT_Teensy.hpp"
#include "accumulator.hpp"
#include "discarder.hpp"
#include "monitor_channel.hpp"
#ifdef CORR_SIMULATOR
    #include "pseudoSerial.hpp"
#endif
 
 
//Example
//MultiTauACorrRTTeensy<9, 27, 3>  multy;
 
//using Lin_Corr_t = Lin_ACorr_RT_Teensy;                //→ S        //→P                  //→m
template <unsigned int Lin_channels, index_t Series_size, unsigned int Bin_Ratio>
class MultiTauACorrRTTeensy
{
 
private:
 
    Accumulator Accumulators[Lin_channels]; 
    LinACorrRTTeensy<Series_size, false> Lin_Corrs[Lin_channels]; 
    DiscarderTeensy<Series_size, int(Series_size/Bin_Ratio), 0> Discarder; 
    
public:
    MonitorChannel<true> MeanMonitor; //< Calculates the mean of the signal
    uint32_t DataCounter = 0; 
 
 
    //1
    MultiTauACorrRTTeensy()
    {
        //Initalize the Accumulators
        for(unsigned int s = 0; s < Lin_channels; s++)
        {
            Accumulators[s].do_accumulate(tau_scaling_scheme(s));
        }
    }
 
 
    //2
    void inline push_datum(counter_t datum)  __attribute__((flatten))
    {
        DataCounter++;
 
        //Monitor Channel for mean
        MeanMonitor.push_back(datum);
 
        //Lin Corr 0 - No coarsening
        Lin_Corrs[0].push_datum(datum);
 
        //Other channels with coarsening.
        //#pragma unroll Lin_channels
        for(unsigned int i = 1; i < Lin_channels; i++)
        {
            Accumulators[i].pipe(Lin_Corrs[i], datum);
            //Lin_Corrs[i].push_datum(datum);
        }
    }
 
 
    //3
    void push_data(const counter_t *container, const index_t size) __attribute__((flatten))
    {
        for(unsigned int i = 0; i < size; i++)
        {
            this->push_datum(container[i]);
        }
    }
 
 
    //4
    void ch_out() const __attribute__((flatten))
    {
        Lin_Corrs[0].ch_out(); //Output without discarding
        //Output with discarding for all subsequent correlators
        for(unsigned int s = 1; s < Lin_channels; s++)
        {
            Discarder.output(Lin_Corrs[s]);
        }
    }
 
 
    //5
    index_t time_scaling_factor() const __attribute__((always_inline))
    {
        return (Series_size - Bin_Ratio);
    }
 
 
    //6
    index_t tau_scaling_scheme(unsigned int s) const __attribute__((always_inline))
    {
        return index_t(pow(Bin_Ratio, s));
    }
 
};