LOchain.h

Go to the documentation of this file.

#ifndef CARMA_CONTROL_LOCHAIN_H
#define CARMA_CONTROL_LOCHAIN_H

#include <vector> 
#include <string> 


namespace carma {
namespace control {


class Freq
{
public:
    enum UNITS {
        uHz,  // microHz
        mHz,  // milliHz
         Hz,
        KHz,
        MHz,
        GHz 
    } ;
    Freq();
    Freq(double val, UNITS units);
    
    Freq operator+(const Freq& rhs) const;
    Freq operator-(const Freq& rhs) const;
    Freq operator*(const Freq& rhs) const;
    Freq operator*(const double& rhs) const;
    Freq operator/(double div) const;
    
    double div(const Freq& div) const;
    
    double microhertz() const;
    
    double millihertz() const;
     
    double hertz() const;
     
    double kilohertz() const;
     
    double megahertz() const;
     
    double gigahertz() const;
private:
    double value_; // in Hz
};


class Harmonic 
{
public:
    Harmonic();
    
    virtual ~Harmonic();

    Freq getYigFreq() const;

    void setYigFreq(const Freq& yig);

    Freq getRefFreq() const;

    void setRefFreq(const Freq& ref);

    int getYigHarmonicNumber() const;

    void setYigHarmonicNumber(int harm);

    int getRefHarmonicNumber() const;

    void setRefHarmonicNumber(int harm);

    double getTuningRange() const;

    void setTuningRange(double range);

    double getTuningScore() const;

    void setTuningScore(double score);
    
    int getRank() const;

    void setRank(int rank);
    
    
private:
    Freq   yig_;
    Freq   ref_;
    int    yigHarmonicNo_;    // Yig * harm
    int    refHarmonicNo_;    // ref * harm
    // Minimum absolute fractional tuning range of yig or ref
    double tuningRange_;  
    double tuningScore_;      // Score of this tuning; range=[0,10]
    int    rank_;             // Rank among odd harms (even harms rank=0)
};


class LOchain 
{

public:
    LOchain(int mode);
  
    explicit LOchain(const Freq& freq, int mode=0);
  
    virtual ~LOchain();
    
     void  setOscillatorFreq(const Freq& freq);
    
     void  setOscillatorMultiplier(int multiplier);
    
    int  getOscillatorMultiplier();

    Freq getOscillatorFreq() const;

    Freq getLOfreq() const;

     void  updateFreq(const Freq& freq);

    Harmonic getPreferredHarmonic() const;

    Harmonic getHarmonic(int rank) const;

    int getNumberHarmonics() const;

    ::std::string toString( const Harmonic& h ) const;

    ::std::string toString( const ::std::vector< Harmonic >& h ) const;

    ::std::string toString() const;

    ::std::string toStringAll() const;

    ::std::string toStringPreferred() const;
    
private:
    LOchain(); // Default private constructor
    typedef ::std::vector<Harmonic> HarmonicVec;

    HarmonicVec getHarmonics() const;

    HarmonicVec getAllHarmonics() const;

    static HarmonicVec
    computeHarmonics( const Freq& oscFreq,
                      const Freq& oscOffsetLock,
                      const Freq& yigOffsetLock,
                      const Freq& refLow,
                      const Freq& refHigh,
                      const Freq& yigLow,
                      const Freq& yigHigh);

    static size_t
    findPreferredHarmonic(const HarmonicVec& harmonics,
                          const Freq&        oscFreq,
                          bool allowEven,
                          int mode);

    Freq   oscfreq_;
    Freq   oscOffsetLock_;
    Freq   yigOffsetLock_;
    Freq   refLow_;
    Freq   refHigh_;
    Freq   yigLow_;
    Freq   yigHigh_;
    
    size_t      preferredHarmonicIndex_;  // index to the preferred harmonic
    HarmonicVec harmonics_;
    int         multiplier_;
    int         mode_;
    int         nOdd_; // Number of odd yig harmonics
};


}  // namespace carma::control
}  // namespace carma


#endif // End of conditional include guard