equalizer.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   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 EQUALIZER_H
#define EQUALIZER_H

#include <basicdevice.h>
#include <phbib.h>
#include <signals.h>
#include "matrixseq.h"
#include "arith.h"

namespace mimo {

class Equalizer : public simth::Device
{
   private:
      void init();
   protected:
      Equalizer(int deviceID, DeviceSystemIntf* system,
        const simth::PropertyList& pl,
        size_t nr_rx_, size_t nr_tx_);
      Equalizer(int deviceID, DeviceSystemIntf* system,
        const simth::PropertyList& pl);
      const size_t nr_rx;
      const size_t nr_tx;
      const size_t iports;

      // Assert that the connection setup was correct
      void assert_connections() const;
      void assert_vector_nr_tx(const mimo::CVector &testvec,
                 const std::string& which = "output vector")
     const;
  public:
      virtual void updateInputLengths();
      virtual void updateOutputLengths();
      
      void print(std::ostream &os) const;

      static void init(const std::string& fileName, 
               Device** dev, 
               DeviceSystemIntf* sysPtr, 
               int ID,
               const std::string& regionQualifier);
};

class EqualizerZF : public Equalizer
{
   public:
      EqualizerZF(int deviceID, DeviceSystemIntf* system, 
          const simth::PropertyList& pl,
          size_t nr_rx, size_t nr_tx);

      EqualizerZF(int deviceID, DeviceSystemIntf* system, 
          const simth::PropertyList& pl)
     : Equalizer (deviceID, system, pl)
      { };
      
      void process();

      static void calcZF(const CVectorSeq& received_signal,
             const MatrixFreqSignal& channelestim,
             CVectorSeq & equalized_signal,
             CVectorSeq *softout_information);
};


class EqualizerMMSE : public Equalizer
{
   private:
      double noise;

   public:
      EqualizerMMSE(int deviceID, DeviceSystemIntf* system, 
            const simth::PropertyList& pl,
            size_t nr_rx, size_t nr_tx, const std::string& loopVar);

      EqualizerMMSE(int deviceID, DeviceSystemIntf* system, 
            const simth::PropertyList& pl);
      
      void setSNR(double snr);
      void setNoisePower(double n);

      void process();
      static void calcMMSE(const CVectorSeq& received_signal,
               const MatrixFreqSignal& channelestim,
               CVectorSeq & equalized_signal,
               double noise_power,
               CVectorSeq *softout_information);
};

class EqualizerMRC : public Equalizer
{
   public:
      EqualizerMRC(int deviceID, DeviceSystemIntf* system, 
           const simth::PropertyList& pl,
           size_t nr_rx, size_t nr_tx);
      
      EqualizerMRC(int deviceID, DeviceSystemIntf* system, 
           const simth::PropertyList& pl)
     : Equalizer (deviceID, system, pl)
      { };

      void process();
};


class EqualizerMRCSwitch : public Equalizer
{
   public:
      EqualizerMRCSwitch(int deviceID, DeviceSystemIntf* system, 
             const simth::PropertyList& pl,
             size_t nr_rx, size_t nr_tx);
      
      void process();
};

} // namespace

#endif /* EQUALIZER_H */

---