channel.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 CHANNEL_HEADER
#define CHANNEL_HEADER

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

#include <phbib.h>
#include <phrand.h>
#include <signals.h>
#include <basicdevicefactory.h>
#include <basicdevice.h>
#include <interfaces.h>

namespace
{
const double  DELAY_THRESHOLD = 0.001;
}

namespace simthlib
{
using simth::Complex;



// Defined in delayprofile.h
class DelayProfile;

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


class Channel : public simth::Device
{
    double noise;

    simth::GaussRng *gauss;

  protected:

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

  public:

    Channel(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl, 
        double noise = 1.0);

    virtual ~Channel() {delete gauss;}

    void setNoisePower(double n = 1.0);

    //void setSNR(double snr, double power);

    void setSNR(double snr);


    double getNoisePower() const { return noise; }

    virtual void getTransfer(int relative_time, simth::FreqSignal& trans) const =0;

    virtual void transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym) =0;

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

    virtual void process();

    virtual void startOfSimulation();

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

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




inline void Channel::setNoisePower(double n)
{
  noise = n;
  gauss->setVariance(n/2.0); //divided by 2.0 because the signal power per quadrature component is 0.5!?
}


inline void Channel::setSNR(double snr)
{
  double n  = simth::db2reciprocalLinearPowerRatio(snr);  //multiplied by signal power that is one.
  setNoisePower(n);
}



class IdealChannel : public Channel
{

  public:
    IdealChannel(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl) 
      : Channel(id, s, pl, 0){}

    virtual void getTransfer(int relative_time, simth::FreqSignal& trans) const;

    virtual void transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym);
    virtual void print(std::ostream &os) const;
};

inline void IdealChannel::transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym)
{
  if(outsym == NULL) {
    throw std::runtime_error("void IdealChannel::transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym)");
  }
  double deltaTime = sym.rAttributes().deltaT();
  if(outsym->rAttributes().deltaT() != deltaTime) {
    outsym->wAttributes().setDeltaT(deltaTime);
  }
  size_t size = sym.size();
  if(outsym->size() != size) {
    outsym->resize(size);
  }

  (*outsym) = sym;
}

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



//--------------------------------------------------------------------
//
//                         AWGN - Kanal
//
//--------------------------------------------------------------------
//
// class Channel cha
//
//   Folgende Eigenschaften werden fuer jedes Objekt gespeichert:
//     Rauschleistung
//     Gaussverteilte Zufallsvariable
//
//   Folgende Funktionen sind implementiert:
//   =======================================
//
//   Konstruktoren
//     Channel(double noise)
//             noise: Rauschleistung = 2 sigma
//
//   Funktionen
//     SetNoisePower(double n): Rauschleistung festlegen
//     SetSNR(double snr, double power):
//       S/N in dB festlegen, power: Signalleistung
//     GetNoisePower(): Gibt Rauschleistung
//     transmit(symSeq &sym, symSeq* &outsym):
//       Signal (Symbolfolge sym) ueber den Kanal uebertragen
//
//--------------------------------------------------------------------
class AWGNChannel : public Channel
{
    // friend ostream&
    // operator<<(ostream &os, Sequence &seq);

  protected:

  public:
    AWGNChannel(int id, simth::DeviceSystemIntf *s, const simth::PropertyList& pl,
        double n=0) : Channel(id, s, pl, n) { }

    virtual ~AWGNChannel() {}

    virtual void getTransfer(int relative_time, simth::FreqSignal& trans) const;

    void transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym);

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


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


//--------------------------------------------------------------------
//
//                        Rayleigh - Kanal
//
//                        Basisklasse: Channel
//
//--------------------------------------------------------------------
//
// class FadingChannel cha
//
//   Folgende Eigenschaften werden fuer jedes Objekt gespeichert:
//     Rayleighverteilte Zufallsvariable
//     Folge der Uebertragungsfaktoren und deren Laenge
//     Flag, das angibt, ob der Kanal fest ist oder fuer jede Ueber-
//       tragung neu ausgewuerfelt wird
//
//   Folgende Funktionen sind implementiert:
//   =======================================
//
//   Konstruktoren
//     FadingChannel(fix_type fix, double n)
//                   fix: Flag, das angibt, ob der Kanal fest ist
//                   n:   Rauschleistung
//
//   Operatoren
//     cha[i]: Zugriff auf i-ten Uebertragungsfaktor zum Lesen
//             und Schreiben
//
//   Funktionen
//     IsFixed(): Gibt 1, wenn der Kanal fest ist, sonst 0
//     refresh(): Wuerfelt neue Uebertragungsfaktoren aus
//     transmit(symSeq &sym, symSeq* &outsym):
//       Signal (Symbolfolge sym) ueber den Kanal uebertragen
//
//--------------------------------------------------------------------
class FadingChannel : public Channel
{

  public:

    enum fix_type {
      FIXED,
      UNFIXED };


    FadingChannel(int id, simth::DeviceSystemIntf *s, 
          const simth::PropertyList& pl,
          fix_type fix=UNFIXED);

    virtual ~FadingChannel();

    int IsFixed() const { return (fixed == FIXED); }

    virtual void refresh();

    virtual void getTransfer(int relative_time, simth::FreqSignal& trans) const;

    void transmit(const simth::TimeSignal &sym, simth::TimeSignal* outsym);

    virtual void startOfSimulation();

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

  protected:

    fix_type fixed;

    double sigma;

    /* Number of (possibly fixed) transfer factors. The number of
       transfer factors is equal the number of transmitted samples.
    */
    //int length;

    simth::RayleighRng *ray;

    simth::Array<simth::Complex> transfer;


};

class CmplFadingChannel : public FadingChannel
{
private:
    simth::GaussRng real;
    simth::GaussRng imag;

public:
    CmplFadingChannel(int id, simth::DeviceSystemIntf *s, 
              const simth::PropertyList& pl,
              fix_type fix=UNFIXED);

    virtual ~CmplFadingChannel();

    void refresh();
};






//--------------------------------------------------------------------
class WssusChannel : public Channel
{
  public:

    // static const int std_num_paths;

  private:

    double rice_factor;

    int num_paths;

    double *phase;

    double *dopp_freq;

    int *delay;

    double *delta_phi;

    double delta_t;

    simth::Array<simth::Complex> prevsym;

    bool firstSequence;

    int roundTimeToSamples(double value) const;

    //channel normalization:
    enum Normalization_Mode {
      STD,
      TIME,
      FREQ};
    Normalization_Mode normMode;
    double normFactor;
    void resetNormalizeFactor();
    double freqDist;
    int numFreqs;

    // sequence to store the (ideal) estimated transfer factors in
    // order avoid (unnecessary) multiple estimations in
    // getTransfer(..)
    mutable simth::FreqSignal::storage_type cacheTransfer;
    mutable int cacheTime;
    mutable bool isTransferCacheValid;


    //-----------------------------for test
    int interval[6];
    simth::Array<simth::Complex> savesym;





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

  protected:

    virtual double maxDelay() const = 0;

    virtual double diceNewDelay() const = 0;
    virtual double diceNewPhase() const = 0;

    virtual double diceNewDopplerFreq() const = 0;


  public:
    WssusChannel(int id, simth::DeviceSystemIntf *s, 
         const simth::PropertyList& pl,
         double n=1.0);

    virtual ~WssusChannel();


    void refresh();

    virtual void getTransfer(int relative_time, simth::FreqSignal& trans) const;

    void transmit(const simth::TimeSignal &insym, simth::TimeSignal* outsym);

    void setRiceFactor(double rf);

    void setRiceFactor_dB(double rf);


    virtual void setCohTime(double tc)=0;

    virtual void setCohBandw(double bc)=0;

    double GetDeltaT() {return delta_t;}

    void adjustDeltaT(double newDeltaT);

    void setTimeNormalization();

    void setFreqNormalization(double freqDist, int numFreqs);

    /* void setNewMode(){newMode_=true;} */

    /* bool newMode(){ return newMode_;} */

    virtual void startOfSimulation();


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

};


inline int WssusChannel::roundTimeToSamples(double value) const
{
  if(DEBUG) {
    int returnValue = int(value / delta_t + 0.5);
    if(returnValue < 0) {
      std::cerr<<std::endl<<"delta_t: "<<delta_t<<" value: "<<value<<std::endl;
      throw std::out_of_range("inline int WssusChannel::roundTimeToSamples(double value) : error 1"
                              " (deltaT to small !?)");
    }
    return returnValue;
  }
  return int(value / delta_t + 0.5);
}





class WssusChannelJakesUniform : public WssusChannel
{
  private:
    simth::UniformRng* uniformPhaseRng;
    simth::JakesRng* jakesDoppFreqRng;
  protected:
    virtual double diceNewPhase() const;
    virtual double diceNewDopplerFreq() const;
  public:
    WssusChannelJakesUniform(int id, simth::DeviceSystemIntf *s, 
                 const simth::PropertyList& pl,
                 double max_doppler);
    virtual ~WssusChannelJakesUniform();
    // sets the coherence time of the channel
    virtual void setCohTime(double tc);

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

};


class WssusChannelDelayProfile : public WssusChannelJakesUniform
{
  private:

    DelayProfile* delayProfile;

  protected:

    virtual double maxDelay() const;

    virtual double diceNewDelay() const;


    void resetDelayProfile(std::auto_ptr<DelayProfile> newProfile);

  public:
    WssusChannelDelayProfile(int id, simth::DeviceSystemIntf *s, 
                 const simth::PropertyList& pl,
                             double max_doppler,
                 std::auto_ptr<DelayProfile> profile);

    ~WssusChannelDelayProfile( );

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


class WssusChannelExpDelay : public WssusChannelDelayProfile
{

  public:
    WssusChannelExpDelay(int id, simth::DeviceSystemIntf *s, 
             const simth::PropertyList& pl,
             double max_doppler, double delayAttenuation,
                         double max_delay);

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

    // sets the coherence bandwidth of the channel
    virtual void setCohBandw(double bc);

};


class WssusChannelBU : public WssusChannelDelayProfile
{

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

    // sets the coherence bandwidth of the channel
    virtual void setCohBandw(double bc);
};


class WssusChannelHt : public WssusChannelDelayProfile
{
  public:

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

    // sets the coherence bandwidth of the channel
    virtual void setCohBandw(double bc);
};


class WssusChannelScattering : public WssusChannelExpDelay
{
  public:
    WssusChannelScattering(int id, simth::DeviceSystemIntf *s, 
               const simth::PropertyList& pl);
};


class WssusChannelFreqTimeCorr : public WssusChannelExpDelay
{
  public:
    WssusChannelFreqTimeCorr(int id, simth::DeviceSystemIntf *s, 
                 const simth::PropertyList& pl);
};

class WssusChannelRA : public WssusChannelExpDelay
{
  public:
    WssusChannelRA(int id, simth::DeviceSystemIntf *s, 
           const simth::PropertyList& pl);
};

class WssusChannelTu : public WssusChannelExpDelay
{
  public:
    WssusChannelTu(int id, simth::DeviceSystemIntf *s, 
           const simth::PropertyList& pl);
};







}

#endif

---