detectors.h

#ifndef _ABSTRACTDETECTOR_H_
#define _ABSTRACTDETECTOR_H_

#include <complex>
#include <utility>
#include <memory>
#include <string>

#include <cereal/cereal.hpp>
#include <cereal/access.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/types/complex.hpp>

#include "detectorbank.h"
#include "detectortypes.h"

class AbstractDetector {
    
public:
    AbstractDetector(parameter_t f, parameter_t mu, 
                     parameter_t d, parameter_t sr, 
                     parameter_t detBw, parameter_t gain);
                    
    virtual ~AbstractDetector();

    void processAudio(discriminator_t* target,
                      const inputSample_t* start, std::size_t count);

    bool searchNormalize(parameter_t searchStart,
                         parameter_t searchEnd,
                         const parameter_t toneDuration,
                         const parameter_t forcing_amplitude);
    
    bool amplitudeNormalize(const parameter_t forcing_amplitude);
    
    void scaleAmplitude();
    
    void generateTone(inputSample_t* tone, 
                      const std::size_t duration,
                      const parameter_t frequency);
    
    // ACCESS FUNCTIONS
    
    parameter_t getW(void) const { return w; };
    
    virtual void reset() = 0;
    
protected:
    virtual void process(discriminator_t* target,
                         const inputSample_t* start, std::size_t count) = 0;
                         
     
    static const parameter_t getLyapunov(const parameter_t bw, const parameter_t amp);

    // DetectorBank is responsible for detector serialisation
    template <class Archive> friend void DetectorBank::save(Archive&) const;
    template <class Archive> friend void DetectorBank::load(Archive&);
    friend class cereal::access;
    template <class Archive> void save(Archive& archive) const
    {
        archive.setNextName("AbstractDetector");
        archive.startNode();
        archive(cereal::make_nvp("w_adjusted", w),
                CEREAL_NVP(aScale),
                CEREAL_NVP(iScale)
                );
        archive.finishNode();
    }
    template <class Archive> void load(Archive& archive)
    {
        //std::cout << "Starting to load an AbstractDetector\n";
        archive.startNode();
        archive(cereal::make_nvp("w_adjusted", w),
                CEREAL_NVP(aScale),
                CEREAL_NVP(iScale)
        );

        archive.finishNode();
    }
    
    parameter_t w;               
    parameter_t const mu;        
    parameter_t const d;         
    parameter_t const sr;        
    parameter_t const detBw;     
    parameter_t const gain;      
    discriminator_t aScale;      
    parameter_t iScale;          
    parameter_t b;               
    discriminator_t scale;       
    bool nrml { false };         
    static constexpr int maxNormIterations { 100 };
    static constexpr double normConverged { 1.0028922878693671 };
    
    void makeScaleVectors();
    
    void getScaleValue(const parameter_t fr);
    
    std::vector<parameter_t> detScaleFreqs;
    std::vector<discriminator_t> detScaleFactors;
    static const std::array<std::vector<parameter_t>, 8> scaleFreqs;
    static const std::array<std::vector<discriminator_t>, 8> scaleFactors;
};

class CDDetector : public AbstractDetector {
public:
    CDDetector(const parameter_t f, const parameter_t mu, 
               const parameter_t d, const parameter_t sr, 
               const parameter_t detBw, const parameter_t gain);
    virtual ~CDDetector();
    virtual void reset();
    virtual void process(discriminator_t* target,
                         const inputSample_t* start,
                         const std::size_t count) override;
                         
private:
    std::complex<parameter_t> zp;        
    std::complex<parameter_t> zpp;       
    inputSample_t xp;                    
};

class RK4Detector : public AbstractDetector {
public:
    RK4Detector(const parameter_t f, const parameter_t mu, 
                const parameter_t d, const parameter_t sr, 
                const parameter_t detBw, const parameter_t gain);
    virtual ~RK4Detector();
    virtual void reset();
    virtual void process(discriminator_t* target,
                         const inputSample_t* start,
                         const std::size_t count) override;
private:
    std::complex<parameter_t> zp;        
    std::complex<parameter_t> zpp;       
    inputSample_t xp;                    
    inputSample_t xpp;                   
};

#endif