trellisdecoding.h

Go to the documentation of this file.

/***************************************************************************
                          trellisdecoding.h  -  description
                             -------------------
    begin                : Mit Aug 6 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 TRELLISDECODING_H
#define TRELLISDECODING_H

#include <iostream>
#include <iomanip>
#include <complex>
#include <stdexcept>
#include <algorithm>
#include <memory>


//#include "ofdmlimits.h"
#include "signals.h"
#include "misc.h"
#include "phbib.h"
#include "modulator.h"
#include "demodulator.h"
#include "trellis.h"




namespace simthlib{


//--------------------------------------------------------------------
//
//                       Trellis - Diagramm
//
//--------------------------------------------------------------------
//
// class Trellis tre
//
//   tre ist ein Trellisdiagramm, das einen Automaten mit Speicher m,
//   Eingaben i und Ausgaben o beschreibt, wobei
//       m' = f(m, i)
//       o  = g(m, i)
//   Eine Eingabesequenz <i> erzeugt eine Ausgabesequenz <o>. Dabei
//   wird als Anfangszustand des Automaten NICHT immer der
//   Nullzustand angenommen, sondern die angehaengten Nullen werden
//   durch eine Beeinflussung der Metrik beruecksichtigt. Wenn eine
//   Ausgangssequenz bzw. eine zugehoerige
//   Metrik gegeben ist, dann kann mit Hilfe des Viterbi - Algorithmus
//   die Eingangssequenz geschaetzt werden.
//
//   Folgende Eigenschaften werden fuer jedes Objekt gespeichert:
//     Speicherlaenge
//     Zahl der Speicherzustaende
//     Zahl der Eingangsbits
//     Zahl der Eingangszustaende
//     Zahl der Ausgangsbits
//     Zahl der Ausgangszustaende
//     Zahl der an die Daten angehaengten Nullbits
//     Zahl der an die Daten angehaengten Nullzustaende
//     Zahl der verschiedenen Modulationssymbole
//     Zahl der Zeitschritte, die bei einer Sequenzschaetzung
//       betrachtet werden
//     Laenge des Trellisdiagramms in Zeitschritten
//     Gesamtmetriken fuer alle Pfade
//     Pfade
//
//   Folgende Funktionen sind implementiert:
//   =======================================
//
//   Konstruktoren
//     Trellis(states, inbits, length)
//             states: (maximale) Zahl der Zustaende
//             inbits: Zahl der Eingangsbits pro Zeitschritt
//             length: Laenge des Trellisdiagramms in Zeitschritten
//
//   Operatoren
//     llv[i]: Zugriff auf i-ten Vektor mit Metrikinkrementen
//     cout << llv: Ausgabe der Metrik
//
//   Funktionen
//     getNumInbits()  Gibt die Zahl der Eingangsbits
//     getNumInput()   Gibt die Zahl der Eingangszustaende
//     getNumOutbits() Gibt die Zahl der Ausgangsbits
//     getNumOutput()  Gibt die Zahl der Ausgangszustaende
//     SeqEstimate(llvSeq &metr, bitSeq* &bs):
//       Fuehrt eine Sequenzschaetzung mit dem Viterbi - Algorithmus
//       durch und liefert die geschaetzten Eingangsbits als
//       Bitsequenz
//
//   Pure Virtuelle Funktionen:
//   =====================
//
//     getNextState(int state, int input, size_t step)=0;
//       Liefert den Folgezustand zum Zustand state bei der Eingabe
//       von input im Zeitschritt step
//     getNextOut(int state, int input, size_t step)=0;
//       Liefert die zugehoerige Ausgabe
//     getPrevState(int state, int index, size_t step)=0;
//       Liefert den Vorgaengerzustand zum Zustand state, in den im
//       Zeitschritt step der Zweig index fuehrt
//     getPrevOut(int state, int index, size_t step)=0;
//       Liefert die zugehoerige Ausgabe
//     getPrevIn(int state, int index, size_t step)=0;
//       Liefert die zugehoerige Eingabe
//
//   Alle virtuellen Funktionen muessen in den konkreten Trellis-
//   diagrammen zu einem bestimmten Automaten definiert werden
//
//--------------------------------------------------------------------


class TrellisDecodingAlgorithm
{

  public:

    TrellisDecodingAlgorithm(std::auto_ptr<Trellis> usedTrellis);
    virtual ~TrellisDecodingAlgorithm();

    virtual void decode(const simth::LlvSeq &metr, simth::BitSeq* decodedData, const simth::LlrSeq* apri = NULL) = 0;

    const Trellis* trellis() {return usedTrellis_;}

  protected:

    Trellis* usedTrellis() {return usedTrellis_;}

    size_t getPathLength() const {return pathLength_;}
    void setPathLength(int newPathLength);

    // Allow derived classes to use this directly because it is called
    // a *lot* of times during the Viterbi
    Trellis* usedTrellis_;

  private:

    size_t pathLength_;

};


inline void TrellisDecodingAlgorithm::setPathLength(int newPathLength)
{
  if(DEBUG){
    if(newPathLength<=0){
      throw std::runtime_error("inline void TrellisDecodingAlgorithm::setPathLength(int newPathLength) : newPathLength <= 0");
    }
  }
  pathLength_ = newPathLength;

}


namespace trellisdecoding{

enum DecodingAlgorithmMode{ DA_VITERBI }; 


std::auto_ptr<TrellisDecodingAlgorithm> makeDecodingAlgorithm(DecodingAlgorithmMode mode, int mem,
                                                      int inSymbols, int outSymbols);

std::auto_ptr<TrellisDecodingAlgorithm> makeDecodingAlgorithm(DecodingAlgorithmMode mode, int inSymbolsPerStep,
                                                      const simth::checkedVector<int>& polynomials);

std::auto_ptr<TrellisDecodingAlgorithm> makeDecodingAlgorithm(DecodingAlgorithmMode mode, int inSymbolsPerStep,
              const simth::checkedVector<int>& polynomials, int recursivePolynomial, bool systematic);

std::auto_ptr<TrellisDecodingAlgorithm> makeDecodingAlgorithm(DecodingAlgorithmMode mode, int inSymbolsPerStep,
              int bitsPerSymbol, ConvCodeTrellis::StartingMode startingMode, map_type mappMode, const simth::checkedVector<int>& polynomials,
              int recursivePolynomial, bool systematic);


}
}
      
#endif

---