adaptiveModulator.h

Go to the documentation of this file.

/***************************************************************************
                          adaptiveModulator.h  -  description
                             -------------------
    begin                : Tue Oct 1 2002
    copyright            : (C) 2002 by Mattias Lampe
    email                : lampe@tuhh.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef ADAMOD_HEADER
#define ADAMOD_HEADER

#include <iostream>
#include <fstream>
#include <complex>
#include <vector>
#include <cmath>
#include <simthetic/signals.h>
#include <simthetic/misc.h>
#include <simthetic/phbib.h>
#include <simthetic/basicdevicefactory.h>
#include <simthetic/basicdevice.h>
#include <simthetic/interfaces.h>
#include "modulator.h"
#include "channel.h"
#include "interleaver.h"
#include "multiplexer.h"

namespace simthlib {

// Note: The declarations of LoadingInfo and LoadingInfoSeq have
// been moved to simthetic/signals.h because otherwise these types
// are not usable outside this library.

enum loadingAlgorithm {
  DUMMY,     
  CCB,       
  SOFT_CCB,  
  SPLIT_CCB, 
  MULTILEVEL_LOADING,
  MULTILEVEL_NET_LOADING,
  MULTILEVEL_MSE_NET_LOADING
};
loadingAlgorithm string2loadingAlgorithm(const std::string&);

void initAdaptiveModulator(const std::string fileName, simth::Device** dev, simth::DeviceSystemIntf* sysPtr, int ID,
           const std::string& regionQualifier = "");


class AdaptiveModulator;
std::ostream& operator<<(std::ostream &os, const AdaptiveModulator& mod);




class ModInfo
{
  public:
    simth::ModType type;
    std::string name;
    std::string alternativeName;
    int bitsPerSymbol;
    //map_type mapping;
    diff_type absDiff;
};





class ModList
{
  public:
    static int getNumBitsPerSym(simth::ModType modScheme);
    static std::string getName(simth::ModType modScheme);
    //static map_type getMapType(simth::ModType modScheme);
    static diff_type getDiffType(simth::ModType modScheme);
    static simth::ModType getModScheme(std::string name);
    static const ModInfo *getModInfo(std::string name);
    static const ModInfo *getModInfo(simth::ModType type);


  protected:
    static int numSchemes;
    static ModInfo info[];

};




class ExtendedModScheme
{

  public:
    const ModInfo *scheme;
    ConstellationDiagram *constellation;
    MappingScheme *mapping;


    ExtendedModScheme(const ModInfo *scheme, 
              std::auto_ptr<ConstellationDiagram> c_diagr,
              std::auto_ptr<MappingScheme> mapp);
    ExtendedModScheme(const ModInfo *scheme);
    ~ExtendedModScheme();

};





class ExtendedModList
{
      friend class LoadingScheme;
      friend class MultilevelAdaptiveModulator;
   public:
      typedef simth::checkedVector<ExtendedModScheme*> schemes_lt;
      typedef std::map<simth::ModType, ExtendedModScheme*> schemes_mapt;
      typedef std::map<int, ExtendedModScheme*> bit_map_t;

   private:
      // The actual list
      schemes_lt schemes;

      // For faster lookup
      schemes_mapt schemes_map;
      // For faster lookup
      bit_map_t bit_map;

      int numSchemes;

      // internal adding to the list(s)
      void addScheme(ExtendedModScheme *e);

   public:
      ExtendedModList();

      bool hasScheme(simth::ModType t) const;
      void addScheme(const ModInfo *scheme, 
             std::auto_ptr<ConstellationDiagram> c_diagr,
             std::auto_ptr<MappingScheme> mapp);
      void addScheme(const ModInfo *scheme);
      ExtendedModScheme *getSchemeForBitsPerSym(int bitsPerSym);
      ~ExtendedModList();

};


enum adaptCriterion{
  EQUALIZER_CRITERION,
  EXP_CRITERION,
  CUSTOM_CRITERION,
  MIN_CRITERION
};



class LoadingScheme
{
  private:
    int numCarr;
    int avgBitsPerSym;
    int numGroups;//for SplitCCB
    bool schemeValid;
    bool powerScaling;
    ExtendedModList *modlist;
    simth::checkedVector<ExtendedModScheme*> schemeOnCarr;
    simth::checkedVector<double> carrierAmplification;
    simth::checkedVector<double> softLoadingInfo; /*  unquantized number of bits assigned to each carrier */

    simth::checkedVector<int> possibleBitsPerSym;
    void updateDummy(int bitsPerSym, simth::FreqSignal* transfer);
    void updateCCB(int bitsPerSym, simth::FreqSignal* transfer);
    void updateSoftCCB(int bitsPerSym, simth::FreqSignal* transfer);
    void updateSplitCCB(int bitsPerSym, simth::FreqSignal* transfer, int numGroups=1);
    void updateMultilevel(int bitsPerSym, simth::FreqSignal* transfer);
  
  public:
    int usedCarr;

    LoadingScheme(int numCarr, ExtendedModList *modlist);

    void update(int bitsPerSym, simth::FreqSignal* transfer, loadingAlgorithm algorithm,int numGroups=1);

    bool isValid() const { return schemeValid; };

    double getAmplification(int carrIndex){return carrierAmplification[carrIndex];};
    ExtendedModScheme *getModScheme(int carrierIndex);
    double getSoftLoadingInfo(int carrierIndex);
    void setPowerScaling(bool scaleIt){powerScaling=scaleIt;};
    void updateMultilevelNet(double netBitsPerSym, simth::FreqSignal* transfer, simth::checkedVector<double> codeRates);
    void updateMultilevelMseNet(double netBitsPerSym, simth::FreqSignal* transfer, simth::checkedVector<double> codeRates, simth::checkedVector<double> levelWeights, double snr=0,double twiddle=1.0, double twiddle2=1.0,adaptCriterion criterion=EXP_CRITERION);
    ~LoadingScheme();
};                                           




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

class AdaptiveModulatorBase: public simth::CompatibleDevice
{
  protected:
    int numCarr;
    int carrIndex;
    double carrDist;
    int oversampling;
    double guardTime;
    // double delta_t;
    // int samplesPerOFDMSym;
    simth::FreqSignal *transfer;
    LoadingScheme *loading;
    loadingAlgorithm algorithm;
    int avgBitsPerSym;
    const Channel *channel;
    Interleaving *intl;
    bool powerScaling;
    int numGroups;//for SPLIT_CCB loading
    int indexLength(int bitseqLength) const;
    
    // Update the internal transfer function with the given sequence.
    void updateTransferFunc(const simth::FreqSignal& helpTrans);

  public:
    AdaptiveModulatorBase(int numCarr, int oversampling, double carrDist,
                          double guardTime,int avgBitsPerSym,loadingAlgorithm algorithm,
                          ExtendedModList *modlist, Channel *channel, 
              std::auto_ptr<Interleaving> interl);
    AdaptiveModulatorBase(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl);
    virtual void updateInputLengths()=0;
    virtual void updateOutputLengths()=0;
    void print(std::ostream &os) const;
    virtual void refresh();
    void reset(){refresh();}
    virtual void process()=0;
    void setPowerScaling(bool scaleIt){powerScaling=scaleIt;loading->setPowerScaling(scaleIt);};
    void setNumGroups(int numGroups_){numGroups=numGroups_;};
    virtual ~AdaptiveModulatorBase()=0;

    static std::auto_ptr<Interleaving> 
    createInterleaving(int interLength, int interRows, int interCols, int interPlanes);

 private:
    void init();
};




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

class AdaptiveModulator: public AdaptiveModulatorBase
{
  private:
    void modulate(const simth::BitSeq &newBitSeq, simth::ModSeq* complSym, simth::LoadingInfoSeq* loadingSeq);

    // Common tasks for all constructors
    void init();

  public:
    AdaptiveModulator(int numCarr, int oversampling, double carrDist,
                      double guardTime,int avgBitsPerSym,loadingAlgorithm algorithm,
                      ExtendedModList *modlist, Channel *channel, std::auto_ptr<Interleaving> interl);
    AdaptiveModulator(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl);
    ~AdaptiveModulator();
    void updateInputLengths();
    void updateOutputLengths();
    void process();
    void acceptNewData(int interfaceId);
    void startOfSimulation();
};





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

class MultilevelAdaptiveModulator: public AdaptiveModulatorBase
{
  private:
    unsigned int numLevels;
    int multiplexerBlockNumber;
    int demultiplexerBlockNumber;
    AdaptiveMultiplexerT<simth::BitSeq>* multiplexer;
    AdaptiveMultiplexerT<simth::BitSeq>* demultiplexer;
    void modulate(std::vector<simth::BitSeq*> newBitSeqArr, simth::ModSeq* complSym, simth::LoadingInfoSeq* loadingSeq);
    simth::checkedVector<int> levelInputLengths;
    simth::checkedVector<double> codeRates;
    simth::checkedVector<unsigned int> bitsTransmittedInLevel;
    double netBitsPerSym;
    double twiddleFactor;
    double twiddleFactor2;
    simth::checkedVector<double> levelWeights;
    double currentSnr;
    std::ofstream rateFile;
    std::string rateFileName;
    adaptCriterion criterion; 
    
  public:
    MultilevelAdaptiveModulator(int numCarr, int oversampling, double carrDist,
                double guardTime,int avgBitsPerSym,loadingAlgorithm algorithm,
                ExtendedModList *modlist, Channel *channel, std::auto_ptr<Interleaving> interl);
    MultilevelAdaptiveModulator(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl);
    void updateInputLengths();
    void updateOutputLengths();
    void process();
    void refresh();
    void startOfSimulation();
    void endOfSimulation();
    void setMultiplexerNumber(int blockNumber){multiplexerBlockNumber=blockNumber;};
    void setDemultiplexerNumber(int blockNumber){demultiplexerBlockNumber=blockNumber;};
    void setCodeRates(simth::checkedVector<double> rates){codeRates=rates;};
    void setNetBitsPerSym(double netBits){netBitsPerSym=netBits;};
    void setTwiddleFactors(double twiddle, double twiddle2){twiddleFactor=twiddle;twiddleFactor2=twiddle2;};
    void setCriterion(adaptCriterion crit){criterion=crit;};
    void setLevelWeights(simth::checkedVector<double> weights){levelWeights=weights;}; 
    void logCodeRate(double newSnr);
    void setRateFileName(std::string name){rateFileName=name;};
    ~MultilevelAdaptiveModulator();
};

} // namespace

#endif

---