mimo-pcs-decoder.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          mimo-pcs-decoder.h  -  description
                             -------------------
    begin                : August 2004
    copyright            : (C) 2004 by Volker Ohlen
    email                : volker.ohlen@freenet.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 MIMO_PCS_DECODER_H
#define MIMO_PCS_DECODER_H

// Mimolib includes
#include "mimo-decoder.h"
#include "modulationschemes.h"
#include "adaptiveModulator.h"

namespace mimo
{

class PCSDecoder : public mimo::Decoder
{
   protected:

      unsigned nr_param;
      bool diff_extr;
      bool int_hard_dec;
      unsigned bits_per_symbol;
      unsigned num_carrier;
      std::string mod_type;
      bool easy_alg;
      bool quality;
      double sum_qlty;
      double sum_qlty_max;
      double sum_diff_mat_qlty;
      unsigned qlty_counter;
      simthlib::ExtendedModList* localExtModList;


      /*
         Here the adaptive internal hard decision is performed. By means of the values
     n and i the right position inside the loading info sequence is found which exists globally.
     Function is called from R_iterate.
      */
      Complex give_me_a_hard_dec(const Complex& rivalue,
                 unsigned n, unsigned i);

      /*
     Computes the received symbol values from R of the QR decomposition,
     using internal hard decision remapping if wanted.
      */
      CVector R_iterate (CMatrix R, CVector e, unsigned n);

      /* Builds the appropriate constellation diagram used for
         internal hard decision. */
      bool what_modulation(const std::string& mod_type);

      /* Sorts the elements of a given vector from greatest to
         smallest value */
      Vector vecsort(Vector vec);

      /* Makes the diagonal elements of R positiv, while changing the
         remaining elements respectively */
      CMatrix make_R_diag_pos(CMatrix R);

      /* Checks whether R is singular. If this is the case, the
         matrix inversion needed for the llr values cannot be
         performed. */
      bool is_R_singular(const CMatrix& R);

   public:

      /* Gives R the right triangular shape, since LaGenQRFactComplex does not
         return the proper shape */
      static CMatrix build_nice_shaped_R (const CMatrix& R);

      /* Returns the diagonal elements of a matrix in vector form
         (absolute values if wanted). */
      static Vector absdiag(const CMatrix& mat, bool betrag);


      PCSDecoder (int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl);
      ~PCSDecoder();

      void endOfSimulation();

      int getDataLength(int codedLength) const;

      int getCodeLength(int rawLength) const;

      void process();


      void Decode(const CVectorSeq& input_vectors,
          const MatrixFreqSignal& chanest,
          simth::ModSeq& output_symbols,
          simth::ModSeq* output_softout);

   private:
      CMatrixSeq::storage_type* U_old;
      simthlib::ConstellationDiagram* ConstDiag;
      simth::LoadingInfoSeq* loading;


}; // class

} // namespace

#endif 

---