core/simulator.hpp

//
// Copyright 2011-2013, Per Zetterberg, KTH Royal Institute of Technology
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//


#ifndef SIMULATOR_HPP
#define SIMULATOR_HPP
 
#include <fstream> 
#include <uhd/device.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <iostream>
#include <complex>
#include <uhd/types/clock_config.hpp>
#include "gps.hpp"
#include <itpp/itbase.h>

using namespace itpp;

class channel_model {
   public:
   virtual void sub_channel(uint32_t from_node_ix,uint32_t to_node_ix, 
                                 uint32_t from_antenna_ix, 
                            uint32_t to_antenna_ix, double freq_tx,
                            double freq_rx,
double time, double gain_tx, double gain_rx, 
                                 std::complex<short int> const* signal_in, std::  complex<short int>* signal_out,  uint32_t number_of_samples)=0;
  virtual void add_noise(double gain_rx, 
        std::complex<short int>* signal, 
                         uint32_t number_of_samples)=0;
};



class from_file : public channel_model {
   public:  
   from_file(std::string directory_name="/usr/local/meas_data/");
  
   virtual void sub_channel(uint32_t from_node_ix,uint32_t to_node_ix, 
                         uint32_t from_antenna_ix, uint32_t to_antenna_ix,
        double freq_tx, double freq_rx,                  
                                 double time, double gain_tx, double gain_rx, 
                  std::complex<short int> const* signal_in, std::complex<short int>* signal_out,uint32_t number_of_samples);
  
  virtual void add_noise(double gain_rx, 
                         std::complex<short int>* signal, uint32_t number_of_samples){};

  static const int unsigned max_num_nodes=10;
  std::string raw_data_dir;
  static const int unsigned max_num_ant=20;
  itpp::mat old_time[max_num_nodes][max_num_nodes];
  itpp::imat frame_ix[max_num_nodes][max_num_nodes];

};


class OFDM_channel_from_file : public channel_model {
   public:  
   OFDM_channel_from_file(std::string filename,
                          ivec num_ant,int Nfft,int Nc, 
                          ivec ix_all ,int tx_start_sample, int rx_start_sample,
                          double signal_scaling, double EVM=0, double EVM_RX=0,
                          double CPE=0);
  
  void reset(void);

  virtual void sub_channel(uint32_t from_node_ix,uint32_t to_node_ix, 
                         uint32_t from_antenna_ix, uint32_t to_antenna_ix,
        double freq_tx, double freq_rx,                  
                                 double time, double gain_tx, double gain_rx, 
                  std::complex<short int> const* signal_in, std::complex<short int>* signal_out,uint32_t number_of_samples);
  
  virtual void add_noise(double gain_rx, 
                         std::complex<short int>* signal, uint32_t number_of_samples);


  private:
  std::string d_filename;
  ivec d_num_ant;
  int d_num_nodes;
  int d_Nfft;
  int d_Nc;
  int d_tx_start_sample;
  int d_rx_start_sample;
  ivec d_ix_all;
  double d_signal_scaling;
  double d_EVM, d_CPE, d_EVM_RX;
  static const int max_num_nodes=10;
  static const int unsigned max_num_ant=20;
  int counter;
  mat rand_cpe;//(max_num_ant,max_num_nodes);

  int d_frame_ix;
  double t_old;
  void load_file(std::string filename);

  public:
  cmat H[max_num_nodes][max_num_nodes][max_num_ant];
  double scaling_noise;
};





class block_fading : public channel_model {
   public:

   block_fading(void);
  
   virtual void sub_channel(uint32_t from_node_ix,uint32_t to_node_ix, 
                         uint32_t from_antenna_ix, uint32_t to_antenna_ix,
                            double freq_tx,double freq_rx, 
                                 double time, double gain_tx, double gain_rx, 
                  std::complex<short int> const* signal_in, std::complex<short int>* signal_out,uint32_t number_of_samples);
  
  virtual void add_noise(double gain_rx, 
        std::complex<short int>* signal, uint32_t number_of_samples);

  virtual void reset(void);

  static const int unsigned max_num_ant=20;
  static const int unsigned max_num_nodes=10;
  static const int unsigned max_num_taps=10;

  itpp::cmat old_h[max_num_nodes][max_num_nodes][max_num_taps];
  itpp::mat old_time[max_num_nodes][max_num_nodes];


  // Additional parameters that can be tuned by the user
  double scaling_signal;
  double path_gain[max_num_nodes][max_num_nodes];
  double scaling_noise;
  double forgetting_factor;
  bool is_awgn;
  bool is_diagonal;
  uint32_t num_of_taps;
  unsigned int seed;
};



#endif