adaptiveDemodulator.h

Go to the documentation of this file.

/***************************************************************************
                          adaptiveDemodulator.h  -  description
                             -------------------
    begin                : Sat Oct 19 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 ADAPTIVEDEMODULATOR_H
#define ADAPTIVEDEMODULATOR_H

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

namespace simthlib {

class AdaptiveDemodulator;


std::ostream& operator<<(std::ostream &os, const AdaptiveDemodulator& demod);

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




class AdaptiveDemodulatorBase : public simth::CompatibleDevice
{
   protected:
      simth::SequenceType outputType_;
      ExtendedModList* localExtModlist;
      map_type mapping;
      int avgBitsPerSym;
      double snr;
      Interleaving *intl;
      bool csi_only_for_reliabilities;
      virtual void demodulate(const simth::ModSeq &receivedSym, 
                  simth::LlrSeq *correspondingLlrValues,
                  double noise = 0, 
                  const simth::ModSeq* trans = NULL, 
                  simth::LoadingInfoSeq* loading=NULL);

      virtual void demodulate(const simth::ModSeq &receivedSym, 
                  simth::LlvSeq *correspondingLlvValues,
                  double noise = 0, 
                  const simth::ModSeq* trans = NULL, 
                  simth::LoadingInfoSeq* loading=NULL);

      virtual int MakeMetric(Complex sym, simth::Llv* const llv, 
                 ConstellationDiagram* constellation,
                 MappingScheme* mapping, 
                 int bitsPerSym, Complex h, double noise)=0;

      virtual void llvSeq2llrSeq(const simth::LlvSeq& from, 
                 simth::LlrSeq* llrSeq)=0;

      AdaptiveDemodulatorBase(simth::SequenceType outType, 
                  map_type _mapping,
                  int _avgBitsPerSym, 
                  std::auto_ptr<Interleaving> _intl);

   public:
      AdaptiveDemodulatorBase(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl);

      virtual void updateInputLengths()=0;
      virtual void updateOutputLengths()=0;
      virtual void print(std::ostream &os) const=0;
      virtual void process()=0;
      virtual ~AdaptiveDemodulatorBase();

};


         

class AdaptiveDemodulator : public AdaptiveDemodulatorBase
{
   private:
      int MakeMetric(Complex sym, simth::Llv* const llv, ConstellationDiagram* constellation,
             MappingScheme* mapping, int bitsPerSym,Complex h, double noise);
      void llvSeq2llrSeq(const simth::LlvSeq& from, simth::LlrSeq* llrSeq);

      void init();

   public:
      AdaptiveDemodulator(simth::SequenceType outType, map_type mapping, int avgBitsPerSym, std::auto_ptr<Interleaving> intl);
      AdaptiveDemodulator(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl);
      void updateInputLengths();
      void updateOutputLengths();
      void print(std::ostream &os) const;
      void process();
      ~AdaptiveDemodulator(){};
      virtual void startOfSimulation();

};


class MultilevelAdaptiveDemodulator : public AdaptiveDemodulatorBase
{
   private:
      //SequenceType outputType_;
      //ExtendedModList* localExtModlist;
      //map_type mapping;
      int demodLevel;
      simth::checkedVector<simth::BitSeq*> decSeqList;
      simth::checkedVector<int> decSeqPos;
      simth::checkedVector<unsigned> decSeqLength;
   
      //double snr;
      //Interleaving *intl;
      //void demodulate(const ModSeq &receivedSym, LlrSeq *correspondingLlrValues,
      //      double noise = 0, const ModSeq* trans = NULL, simth::LoadingInfoSeq* loading=NULL);

      //void demodulate(const ModSeq &receivedSym, LlvSeq *correspondingLlvValues,
      //      double noise = 0, const ModSeq* trans = NULL, simth::LoadingInfoSeq* loading=NULL);

      int MakeMetric(Complex sym, simth::Llv* const llv, ConstellationDiagram* constellation,
             MappingScheme* mapping, int bitsPerSym,Complex h, double noise);
      void llvSeq2llrSeq(const simth::LlvSeq& from, simth::LlrSeq* llrSeq);

   public:
      MultilevelAdaptiveDemodulator(simth::SequenceType outType, map_type mapping, std::auto_ptr<Interleaving> intl, int operationLevel);
      void updateInputLengths();
      void updateOutputLengths();
      void print(std::ostream &os) const;
      void process();
      ~MultilevelAdaptiveDemodulator();

};

} // namespace

#endif

---