modulationschemes.h

Go to the documentation of this file.

/***************************************************************************
                          mappingschemes.h  -  description
                             -------------------
    begin                : Mon May 26 2003
    copyright            : (C) 2003 by Peter Haase
    email                : p.haase@tuhh.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MODULATIONSCHEMES_H
#define MODULATIONSCHEMES_H


#include <complex>
#include <vector>
#include <simthetic/phbib.h>
#include <simtheticlib/modulationmodes.h>


namespace simthlib
{

class ConstellationDiagram
{
  private:


    const unsigned bitsPerSymbol;     //Bits pro Symbol
    const unsigned modulationValency; //Modulationswertigkeit

    // The complex states in the constellation diagram
    std::vector<simth::Complex> complStates;

  protected:

    virtual void setComplSymbols(unsigned symbolIndex,
                 const simth::Complex& newValue);


    virtual void initComplSymbols()=0;


  public:

    ConstellationDiagram(unsigned bitsPerSymb);

    virtual ~ConstellationDiagram(){};

    unsigned getBitsPerSymbol() const {return bitsPerSymbol;}


    inline const simth::Complex& getComplSymbol(unsigned symbolIndex) const;


    unsigned getNumStates() const {return modulationValency;}

    void scaleConstellation(const simth::Complex& scaleFactor);

    const simth::Complex& hardDecision(const simth::Complex& r) const;

    virtual void print(std::ostream &os, bool gnuplotFormat = false) const;

};


inline const simth::Complex& ConstellationDiagram::getComplSymbol(unsigned modIndex) const
{
  if(DEBUG) {
    if ( modIndex >= modulationValency ) {
      throw std::out_of_range("Complex ConstellationDiagram::getComplSymbol(int modIndex)  modIndex = "
                              +simth::i2string(modIndex));
    }
  }
  return complStates[modIndex];
}


// ////////////////////////////////////////////////////////////

class QamConstellationDiagram : public ConstellationDiagram
{

  private:
    unsigned bitsPerRealPart;
    unsigned bitsPerImPart;

  public:
    QamConstellationDiagram(unsigned bitsPerSymbol);

    virtual void initComplSymbols();

    static unsigned getRealBits(unsigned bitsPerSymbol);

    static unsigned getImBits(unsigned bitsPerSymbol);

};

class PhaseAmplitudeConstellationDiagram : public ConstellationDiagram
{

    struct PolarComplex
    {
      double  ampl;
      double  phase;
    };

    //phase difference between two symbols
    double deltaPhase_;

    //die komplexen Zustaende im Ortsdiagramm
    std::vector<PhaseAmplitudeConstellationDiagram::PolarComplex> polarStates;


    int bitsPerAmpl_;
    int bitsPerPhase_;

    int numAmplitudes_;
    int numPhases_;

  protected:

    virtual void setComplSymbols(int symbolIndex,simth::Complex newValue);

    void setDeltaPhase(double newDeltaPhase);

  public:

    PhaseAmplitudeConstellationDiagram(int bitsPerAmpl, int bitsPerPhase);


    /* Returns the number of bits classifying the amplitude

    */
    int bitsPerAmpl() const {return bitsPerAmpl_;}
    int numAmplitudes() const {return numAmplitudes_;}


    /* Returns the number of bits classifying the phases.

    */
    int bitsPerPhase() const {return bitsPerPhase_;}
    int numPhases() const {return numPhases_;}

    virtual double deltaPhase( ) const {return deltaPhase_;}

    double getPhase(unsigned symbolIndex) const;

    double getAmplitude(unsigned symbolIndex) const;

    int getSymbolIndex(int amplIndex, int phaseIndex) const {return (amplIndex<<bitsPerPhase())+phaseIndex;}

    int getAmplIndex(int symbolIndex) const {return symbolIndex>>bitsPerPhase();}

    int getPhaseIndex(int symbolIndex) const {return symbolIndex||(1<<bitsPerPhase())-1;}

};



inline double PhaseAmplitudeConstellationDiagram::getPhase(unsigned modIndex) const
{
  if(DEBUG) {
    if( (modIndex >= getNumStates() )) {
      throw std::out_of_range("Complex PhaseAmplitudeConstellationDiagram::getComplSymbol(int modIndex)  modIndex = "
                              +simth::i2string(modIndex));
    }
  }
  return (polarStates[modIndex]).phase;
}

inline double PhaseAmplitudeConstellationDiagram::getAmplitude(unsigned modIndex) const
{
  if(DEBUG) {
    if( (modIndex >= getNumStates() )) {
      throw std::out_of_range("Complex PhaseAmplitudeConstellationDiagram::getComplSymbol(int modIndex)  modIndex = "
                              +simth::i2string(modIndex));
    }
  }
  return (polarStates[modIndex]).ampl;
}



class PskConstellationDiagram : public PhaseAmplitudeConstellationDiagram
{
    virtual void initComplSymbols();

  public:

    PskConstellationDiagram(int bitsPerSymbol);

};


class ApskConstellationDiagram : public PhaseAmplitudeConstellationDiagram
{
    virtual void initComplSymbols();

    //amplitude factor
    double a;
    //amplitude addend
    double addend;

    //factor to normalize the signal power:
    double normalizeFactor;

    int getPhaseIndex(int symbolIndex) const;
    int getAmplitudeIndex(int symbolIndex) const;

  public:

    ApskConstellationDiagram(int bitsPerSymbol, detect_type mode);

    ApskConstellationDiagram(int bitsPerSymbol, double amplFactor, double amplAddend=0.0);

    ApskConstellationDiagram(int bitsPerAmpl, int bitsPerPhase, double amplFactor, double amplAddend=0.0);


    double getAmplFactor() const {return a;}
    double getAmplAddend() const {return addend;}

    static int computeAmplitudeBits(int bitsPerSymbol);

    static int computePhaseBits(int bitsPerSymbol);

    static double computeAmplitudeFactor(int bitsPerState, detect_type mode);

    static double computeAmplitudeAddend(int bitsPerState, detect_type mode);


};






} // namespace

#endif

---