channel.h

Go to the documentation of this file.

#ifndef CHANNEL_H
#define CHANNEL_H

#include <itpp/base/math/elem_math.h>
#include <itpp/base/mat.h>
#include <itpp/base/array.h>
#include <itpp/base/random.h>
#include <itpp/signal/filter.h>

namespace itpp
{



enum CHANNEL_PROFILE {
  ITU_Vehicular_A, ITU_Vehicular_B, ITU_Pedestrian_A, ITU_Pedestrian_B,
  COST207_RA, COST207_RA6,
  COST207_TU, COST207_TU6alt, COST207_TU12, COST207_TU12alt,
  COST207_BU, COST207_BU6alt, COST207_BU12, COST207_BU12alt,
  COST207_HT, COST207_HT6alt, COST207_HT12, COST207_HT12alt,
  COST259_TUx, COST259_RAx, COST259_HTx
};

enum FADING_TYPE { Independent, Static, Correlated };

enum CORRELATED_METHOD { Rice_MEDS, IFFT, FIR };

enum RICE_METHOD { MEDS };

enum DOPPLER_SPECTRUM {
  Jakes = 0, J = 0, Classic = 0, C = 0,
  GaussI = 1, Gauss1 = 1, GI = 1, G1 = 1,
  GaussII = 2, Gauss2 = 2, GII = 2, G2 = 2
};


class Fading_Generator
{
public:
  Fading_Generator();
  virtual ~Fading_Generator() {}

  void set_LOS_power(double relative_power);
  virtual void set_LOS_doppler(double relative_doppler);
  virtual void set_time_offset(int offset);
  virtual void set_filter_length(int filter_length);
  virtual void set_norm_doppler(double norm_doppler);
  virtual void set_doppler_spectrum(DOPPLER_SPECTRUM spectrum);
  virtual void set_no_frequencies(int no_freq);
  virtual void set_rice_method(RICE_METHOD method);

  double get_LOS_power() const { return los_power; }
  virtual double get_LOS_doppler() const;
  virtual double get_time_offset() const;
  virtual int get_filter_length() const;
  virtual double get_norm_doppler() const;
  virtual DOPPLER_SPECTRUM get_doppler_spectrum() const;
  virtual int get_no_frequencies() const;
  virtual RICE_METHOD get_rice_method() const;

  virtual void shift_time_offset(int no_samples);

  virtual void init() = 0;

  virtual void generate(int no_samples, cvec &output) = 0;
  cvec generate(int no_samples);

protected:
  bool init_flag; 
  double los_power; 
  double los_diffuse; 
  double los_direct; 
};


class Independent_Fading_Generator : public Fading_Generator
{
public:
  Independent_Fading_Generator() : Fading_Generator() {}
  virtual ~Independent_Fading_Generator() {}

  virtual void init() { init_flag = true; }

  using Fading_Generator::generate;

  virtual void generate(int no_samples, cvec& output);
};


class Static_Fading_Generator : public Fading_Generator
{
public:
  Static_Fading_Generator() : Fading_Generator() {}
  virtual ~Static_Fading_Generator() {}

  virtual void init();

  using Fading_Generator::generate;

  virtual void generate(int no_samples, cvec& output);

protected:
  std::complex<double> static_sample;
};


class Correlated_Fading_Generator : public Fading_Generator
{
public:
  Correlated_Fading_Generator(double norm_doppler);
  virtual ~Correlated_Fading_Generator() {}

  virtual void set_norm_doppler(double norm_doppler);
  virtual void set_LOS_doppler(double relative_doppler);
  virtual void set_time_offset(int offset);

  virtual double get_norm_doppler() const { return n_dopp; }
  virtual double get_LOS_doppler() const { return los_dopp; }
  virtual double get_time_offset() const { return time_offset; }

  virtual void shift_time_offset(int no_samples);

  virtual void init() = 0;

  using Fading_Generator::generate;

  virtual void generate(int no_samples, cvec& output) = 0;

protected:
  double n_dopp; 
  double los_dopp; 
  double time_offset; 

  void add_LOS(int idx, std::complex<double>& sample);
};


class Rice_Fading_Generator : public Correlated_Fading_Generator
{
public:
  Rice_Fading_Generator(double norm_doppler, DOPPLER_SPECTRUM spectrum = Jakes,
                        int no_freq = 16, RICE_METHOD method = MEDS);
  virtual ~Rice_Fading_Generator() {}

  virtual void set_doppler_spectrum(DOPPLER_SPECTRUM spectrum);
  virtual void set_no_frequencies(int no_freq);
  virtual void set_rice_method(RICE_METHOD method);

  virtual DOPPLER_SPECTRUM get_doppler_spectrum() const { return dopp_spectrum; }
  virtual int get_no_frequencies() const { return Ni; }
  virtual RICE_METHOD get_rice_method() const { return rice_method; }

  virtual void init();

  using Correlated_Fading_Generator::generate;

  virtual void generate(int no_samples, cvec &output);

protected:
  DOPPLER_SPECTRUM dopp_spectrum; 

  int Ni;
  RICE_METHOD rice_method;
  vec f1, f2, c1, c2, th1, th2;
  double f01, f02;

  void init_MEDS();
};


class FIR_Fading_Generator : public Correlated_Fading_Generator
{
public:
  FIR_Fading_Generator(double norm_doppler, int filter_length = 500);
  virtual ~FIR_Fading_Generator() {}

  virtual void set_filter_length(int filter_length);
  virtual int get_filter_length() const { return fir_length; }

  virtual void init();

  using Correlated_Fading_Generator::generate;

  virtual void generate(int no_samples, cvec &output);

protected:
  int fir_length; 
  int upsample_rate; 

  MA_Filter<std::complex<double>, double, std::complex<double> > fir_filter;
  cvec left_overs; 

  vec Jakes_filter(double norm_dopp, int order = 100);
};


class IFFT_Fading_Generator : public Correlated_Fading_Generator
{
public:
  IFFT_Fading_Generator(double norm_doppler) :
      Correlated_Fading_Generator(norm_doppler) {}
  virtual ~IFFT_Fading_Generator() {}

  virtual void init() { init_flag = true; }

  using Correlated_Fading_Generator::generate;

  virtual void generate(int no_samples, cvec &output);

protected:
  void generate_Jakes(int no_samples, cvec &output);
};


class Channel_Specification
{
public:
  Channel_Specification(const vec &avg_power_dB = "0", const vec &delay_prof = "0");
  Channel_Specification(const CHANNEL_PROFILE profile);
  virtual ~Channel_Specification() {}

  void set_channel_profile(const vec &avg_power_dB, const vec &delay_prof);
  void set_channel_profile(const CHANNEL_PROFILE profile);

  void set_doppler_spectrum(DOPPLER_SPECTRUM *tap_spectrum);
  void set_doppler_spectrum(int tap_number, DOPPLER_SPECTRUM tap_spectrum);

  void set_LOS(int tap_number, double relative_power, double relative_doppler = 0.7);
  void set_LOS(const vec& relative_power, const vec& relative_doppler = "");

  void get_channel_profile(vec &avg_power_dB, vec &delay_prof) const;
  vec get_avg_power_dB() const { return a_prof_dB; }
  vec get_delay_prof() const { return d_prof; }
  Array<DOPPLER_SPECTRUM> get_doppler_spectrum() const { return tap_doppler_spectrum; }
  DOPPLER_SPECTRUM get_doppler_spectrum(int index) const;
  vec get_LOS_power() const { return los_power; }
  vec get_LOS_doppler() const { return los_dopp; }
  double get_LOS_power(int tap_number) const { return los_power(tap_number); }
  double get_LOS_doppler(int tap_number) const { return los_dopp(tap_number); }

  int taps() const { return N_taps; }

  double calc_mean_excess_delay() const;
  double calc_rms_delay_spread() const;

protected:
  vec a_prof_dB; 
  vec d_prof; 
  Array<DOPPLER_SPECTRUM> tap_doppler_spectrum; 
  int N_taps; 
  vec los_power; 
  vec los_dopp; 
};


class TDL_Channel
{
public:
  TDL_Channel(const vec &avg_power_dB = "0", const ivec &delay_prof = "0");
  TDL_Channel(const Channel_Specification &channel_spec, double sampling_time);
  virtual ~TDL_Channel();

  void set_channel_profile(const vec &avg_power_dB, const ivec &delay_prof);
  void set_channel_profile_uniform(int no_taps);
  void set_channel_profile_exponential(int no_taps);
  void set_channel_profile(const Channel_Specification &channel_spec, double sampling_time);

  void set_correlated_method(CORRELATED_METHOD method);
  void set_fading_type(FADING_TYPE fading_type);

  void set_norm_doppler(double norm_doppler);

  void set_LOS(const vec& relative_power, const vec& relative_doppler = "");
  void set_LOS_power(const vec& relative_power);
  void set_LOS_doppler(const vec& relative_doppler);

  void set_doppler_spectrum(const DOPPLER_SPECTRUM *tap_spectrum);
  void set_doppler_spectrum(int tap_number, DOPPLER_SPECTRUM tap_spectrum);
  void set_no_frequencies(int no_freq);

  void set_time_offset(int offset);
  void shift_time_offset(int no_samples);

  void set_filter_length(int filter_length);


  int taps() const { return N_taps; }

  void get_channel_profile(vec &avg_power_dB, ivec &delay_prof) const;
  vec get_avg_power_dB() const;
  ivec get_delay_prof() const { return d_prof; }

  CORRELATED_METHOD get_correlated_method() const { return method; }
  FADING_TYPE get_fading_type() const { return fading_type; }

  double get_norm_doppler() const { return n_dopp; }

  vec get_LOS_power() const { return los_power; }
  vec get_LOS_doppler() const { return los_dopp; }
  double get_LOS_power(int tap_number) const { return los_power(tap_number); }
  double get_LOS_doppler(int tap_number) const { return los_dopp(tap_number); }

  int get_no_frequencies() const { return nrof_freq; }

  double get_time_offset() const;

  double calc_mean_excess_delay() const;
  double calc_rms_delay_spread() const;

  void init();

  void generate(int no_samples, Array<cvec> &channel_coeff);
  void generate(int no_samples, cmat &channel_coeff);

  void filter_known_channel(const cvec &input, cvec &output, const Array<cvec> &channel_coeff);
  void filter_known_channel(const cvec &input, cvec &output, const cmat &channel_coeff);

  void filter(const cvec &input, cvec &output, Array<cvec> &channel_coeff);
  void filter(const cvec &input, cvec &output, cmat &channel_coeff);
  cvec filter(const cvec &input, Array<cvec> &channel_coeff);
  cvec filter(const cvec &input, cmat &channel_coeff);
  void filter(const cvec &input, cvec &output);
  cvec filter(const cvec &input);

  void operator()(const cvec &input, cvec &output, Array<cvec> &channel_coeff);
  void operator()(const cvec &input, cvec &output, cmat &channel_coeff);
  cvec operator()(const cvec &input, Array<cvec> &channel_coeff);
  cvec operator()(const cvec &input, cmat &channel_coeff);
  cvec operator()(const cvec &input);

  void calc_impulse_response(const Array<cvec> &channel_coeff, Array<cvec> &impulse_response);

  void calc_frequency_response(const Array<cvec> &channel_coeff, Array<cvec> &frequency_response, const int fft_size);
  void calc_frequency_response(const cmat &channel_coeff, cmat &frequency_response, const int fft_size);
  double get_sampling_time() const { return discrete_Ts; }

protected:
  bool init_flag; 
  vec a_prof; 
  ivec d_prof; 
  vec los_power; 
  vec los_dopp; 
  int N_taps; 
  double n_dopp; 
  FADING_TYPE fading_type; 
  CORRELATED_METHOD method; 
  Array<DOPPLER_SPECTRUM> tap_doppler_spectrum; 
  Array<Fading_Generator *> fading_gen; 
  int filter_length; 
  int nrof_freq; 
  double discrete_Ts; 

  void discretize(const vec &delay_profile);
};



class BSC
{
public:
  BSC(double in_p = 0.0) : u(0.0, 1.0) { p = in_p; };
  void set_prob(double in_p) { p = in_p; };
  double get_prob() const { return p; };
  bvec operator()(const bvec &input);
private:
  Uniform_RNG u;
  double p;
};



class AWGN_Channel
{
public:
  AWGN_Channel(double noisevar = 0.0): sigma(std::sqrt(noisevar)) {}
  void set_noise(double noisevar) { sigma = std::sqrt(noisevar); }
  double get_noise() const { return sqr(sigma); }
  cvec operator()(const cvec &input);
  vec operator()(const vec &input);
private:
  Complex_Normal_RNG rng_cn;
  Normal_RNG rng_n;
  double sigma;
};


} // namespace itpp

#endif // #ifndef CHANNEL_H

---