mimo-channel.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          mimo-channel.h  -  MIMO channel classes
                             -------------------
    begin                : Feb 2003
    copyright            : (C) 2003 by Christian Stimming
    email                : stimming@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 MIMO_CHANNEL_H
#define MIMO_CHANNEL_H

#include <iostream>
#include <fstream>
#include <complex>

#include <simthetic/phbib.h>
#include <simthetic/phrand.h>
#include <simthetic/signals.h>
#include <simthetic/basicdevice.h>
#include <simthetic/interfaces.h>

using namespace simth;

#include "matrixseq.h"

// MIMO channels are only available if the matrix data types are
// available

namespace mimo {

const double  DELAY_THRESHOLD = 0.001;


class MIMOChannel;

std::ostream& operator<<(std::ostream &os, const MIMOChannel &cha);

class MIMOChannel : public Device
{
   private:
      double noise;

      GaussRng *gauss;

   protected:
      size_t nr_tx;
      size_t nr_rx;

      MatrixFreqSignal::storage_type transfer;


      double getGauss() const { return gauss->get_inl();}

      void addNoise(VectorTimeSignal::reference v) const;

      const bool diagonal;

      // Common sanity checks
      void assert_vector_lengths(const VectorTimeSignal &in, 
                 const VectorTimeSignal &out) const;
      // Common sanity checks
      void assert_transfer_lengths(const MatrixFreqSignal::storage_type& our, 
                   const MatrixFreqSignal& next) const;
      // Common sanity checks
      void assert_transfer_dim(const MatrixFreqSignal::storage_type& our, 
                   const MatrixFreqSignal& next) const;

   public:

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

      virtual ~MIMOChannel() {delete gauss;}

      void setNoisePower(double n);

      void setSNR(double snr);

      double getNoisePower() const { return noise; }

      virtual void getTransfer(int relative_time, 
                   MatrixFreqSignal& trans) const =0;

      virtual void transmit(const VectorTimeSignal &sym, 
                VectorTimeSignal& outsym) =0;

      virtual void updateInputLengths();
      virtual void updateOutputLengths();

      virtual void process();

      virtual void print(std::ostream &os) const ;

      virtual void startOfSimulation();

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






class PerfectMIMOChannel : public MIMOChannel
{

   public:
      PerfectMIMOChannel(int deviceID, 
             DeviceSystemIntf* system,
             const simth::PropertyList& pl) 
     : MIMOChannel(deviceID, system, pl) {}

      void getTransfer(int relative_time, MatrixFreqSignal& trans) const;

      void transmit(const VectorTimeSignal &sym, VectorTimeSignal& outsym);
      void print(std::ostream &os) const;
};


//--------------------------------------------------------------------

class AWGNMIMOChannel : public MIMOChannel
{
   public:
      AWGNMIMOChannel(int deviceID, 
              DeviceSystemIntf* system,
              const simth::PropertyList& pl) 
     : MIMOChannel(deviceID, system, pl) {}

      virtual ~AWGNMIMOChannel() {}

      //see above
      void getTransfer(int relative_time, 
               MatrixFreqSignal& trans) const;

      void transmit(const VectorTimeSignal &sym, VectorTimeSignal& outsym);

      virtual void print(std::ostream &os) const;
};


inline void AWGNMIMOChannel::print(std::ostream &os) const
{
   //save old format settings:
   std::ios::fmtflags oldSettings = os.flags();
   MIMOChannel::print(os);
   os.width(15);
   os<<std::endl<<"# channel type: AWGN cannel";
   os.setf(oldSettings);
}


//--------------------------------------------------------------------

class AntennaArray {

   public:
      virtual ~AntennaArray() {};
      virtual mimo::CVector get_steeringVector(size_t N, double alpha) const;

      virtual double get_phase(unsigned N, unsigned k, double alpha) const = 0;

      static AntennaArray *init(const simth::PropertyList& pl, 
                const char *propertyname = "array_geometry");

      static mimo::CVector unitVector(size_t n, size_t N);

};

class UniformLinearLambdaHalf : public AntennaArray
{
   public:
      virtual ~UniformLinearLambdaHalf() {};
      double get_phase(unsigned N, unsigned k, double alpha) const;
};

class UniformCircularLambdaHalf : public AntennaArray
{
   public:
      virtual ~UniformCircularLambdaHalf() {};
      double get_phase(unsigned N, unsigned k, double alpha) const;
};

class NonUniform : public AntennaArray
{
      unsigned nr;
      std::vector<double> spacings;
   public:
      NonUniform(const std::string& filename, unsigned N);
      virtual ~NonUniform() {};

      double get_phase(unsigned N, unsigned k, double alpha) const;
};

} // namespace mimo




#endif /* MIMO_CHANNEL_H */

---