IA1/IA1_node.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 IA1_NODE_EXAMPLE_HPP
#define IA1_NODE_EXAMPLE_HPP

#include <uhd/device.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <iostream>
#include <complex>
#include <uhd/types/clock_config.hpp>
#include <four_multi/gps.hpp>
#include <four_multi/four_multi.hpp>
#include <four_multi/modem_OFDM1.hpp>
#include <four_multi/AMC.hpp>
#include <itpp/itbase.h>
#include <itpp/itcomm.h>
#include <itpp/stat/misc_stat.h>


using namespace itpp;

class IA1_node : public four_multi_node {

   public:
   

   IA1_node(uint32_t no_ant1, uint32_t no_ant2 , uint32_t skip_ant, 
           float start_gain,  uint32_t node_ix , double frequency,
            bool use_same_antenna,std::vector<std::string> IP_addresses,
            bool simulate, int receiver_delay_samples,int seed, 
            bool run_decoder, int scenario);

   uint32_t frame_ix(void ){ return d_frame_ix;};
   int codec_ix, modulation_order; // Codec index, and modulation order used with LDPC code.

   double offset_time;
  
   ~IA1_node();
  
   double get_gain(void) {return d_gain_rx;};
   std::vector<OFDM1> ai;
  //OFDM1 ai[3];  // Maximum 3 streams per node.
   uint32_t num_streams_per_bs; 
   uint32_t num_streams_per_ms; 
   uint32_t num_antennas_in_system; 
  
   cmat waveform_rx;
   cvec waveform_tx, waveform_tx_temp; 

   vec BERraw;
   vec BER;

   vec EVM;
   vec SINR;
   double SINR_temp;
   int ber_i;
   bvec input, transmitted;
   bvec message_hat, decoded_bits, transmitted_hat;
   vec soft_bit;

   cmat H[20][8]; //Channel matrices for beamforming design at the node_ix=0.
                 // Max 20 transmitter antennas in system
                 // max 8 mobile-station.
  
   double time_between_frames;

   uint32_t MIMO_active_tx_node_tx;
   bool MIMO_closed_loop;
   bool MIMO_all_active;

   protected: 


   virtual frame_settings node_init(void) ;
   virtual frame_settings node_process(void) ;
   virtual void end_of_run(void) ;

   void calculate_beamformers(void);
   void iteration(const cmat v_old,int subcarrier_ix_start,
 int subcarrier_ix_stop,
                  int increment);


   static const int iterations = 5;
   static const uint32_t block_length=400;
   static const uint32_t noise_estimation_start=1000;
   static const uint32_t noise_estimation_length=800;
   static const uint32_t constraint_length = 3;

   double scaling_tx_signal;
   ivec demodulation_position;

   uint32_t d_frame_ix, d_no_frames, scenario;
   bool do_calculate_beamformers;
   double d_gain_rx, d_gain_tx, d_frequency;
  //cmat waveform_rx;
  // cvec waveform_tx, waveform_tx_temp; 
  //bvec input, transmitted;
  //vec soft_bit;
   ivec interleaver_sequence;
   std::string metric;
   double logmax_scale_factor;
   bool adaptive_stop;
   ivec gen;
   BERC berc;
   ivec nrof_used_iterations;
   double target_rx_base_band_rms_ampl;
   ivec reorder_all[10]; // Max 10 streams in the system.
   uint32_t num_links, num_bs, num_ms;
   uint32_t num_ant_ms, num_ant_bs;
   cmat v[10]; // Precoding matrices for the user in question. Max 10 streams.
  //cmat u[10]; // Receiver matrices for the user in question. Max 10 streams.
   cmat Vbig[10]; // Precoding matrices matrices for all streams
                   // Used by node_ix=0.. Max 10 streams.
  //cmat Ubig[10]; // Receiver matrices for all streams. Max 10 streams.
                     // Used by node_ix=0.

   cvec symbols; // Transmit signal of a stream.
  
  

   std::complex<int16_t> *feedback_buffer; // Place to store samples used for 
                                           // RX to TX feedback

   std::complex<int16_t> *feedback_buffer0; // Place to store samples used for 
                                           // RX to TX feedback

   std::complex<int16_t> *feedback_buffer1; // Place to store samples used for 
                                           // RX to TX feedback

   std::complex<int16_t> *feedback_buffer2; // Place to store samples used for 
                                           // RX to TX feedback

   std::vector<uint32_t> other_node_ixs;
   std::vector<void  *> pointers_to_data;
   std::vector<uint32_t> num_bytess;
   

   int feedback_buffer_size; // RX->TX
   int feedback_buffer_size_tx; // TX->TX

   ivec antenna_pilot_position;
   ivec antenna_pilot_position_this_bs;
   ivec known_pos_all;
   bool is_bs;

   uint32_t shift_transmit_signal_samples;
   uint32_t replicas_start;
   uint32_t replicas_spacing;
   ivec replica_positions_this_bs;
   ivec replica_positions;

   ivec stream_ix_this_node;
   imat bs_to_stream_ix;
   ivec stream_ix_to_ms_ix;
   int d_seed;
   uint32_t num_streams; // Total number of streams in the system.

   void normalize_columns(cmat &M);
   void calculate_v(void);

   void format_tx_symbols(uint32_t codec_ix, uint32_t modulation_order, int stream_ix);
   void decode_rx_symbols(uint32_t codec_ix, uint32_t modulation_order, int stream_ix);
   AMC amc; // Adaptive coding and modulation object
   int word_length; // Code-word length
   double noise_variance_norm;
   bool d_run_decoder;
   uint64_t temp_seed;
   bool use_old_rand;

   Real_Timer timer;
};



#endif