IA1/IA1_node.cpp

// 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/>.
//

#include "IA1_node.hpp"
#include <itpp/itcomm.h>
#include <itpp/stat/misc_stat.h>



IA1_node::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_in)
  : four_multi_node(20000,no_ant1,no_ant2,false,use_same_antenna,node_ix,IP_addresses,simulate,skip_ant)
{

   
   bool use_pilot_carriers=false;
   uint32_t cyclic_prefix_length=12;
   uint32_t no_ant=no_ant1+no_ant2;  
   int noise_estimation_start_ix;
   uint32_t num_payload_symbols_before_pilots=10;
   uint32_t num_payload_symbols_after_pilots=10;
   uint32_t num_symbols=num_payload_symbols_before_pilots+num_payload_symbols_after_pilots+1;
   ivec known_pos;
   scenario=scenario_in; // 1=pure IA, 2=CoMP, 3=MIMO, 4=SIMO
   use_udp=true;

   use_old_rand=false;
   do_calculate_beamformers=true;
   offset_time=0.0; 
   scaling_tx_signal=50000;
   if ((scenario_in<3) && use_udp) { 
      time_between_frames=0.06;
   } else {
     time_between_frames=0.1;
   };
   shift_transmit_signal_samples=2000;
   noise_estimation_start_ix=1001;
   replicas_start=5000;
   replicas_spacing=3000;
   d_seed=seed;
   codec_ix=3;
   modulation_order=16;


   d_gain_rx=start_gain;
   d_node_ix=node_ix;
   d_frame_ix=0;
   d_frequency=frequency;
   d_gain_tx=20;
   d_frame_ix=0;
   d_no_frames=5;
   
   ai.resize(3);


   if (scenario==1) {
     num_links=3;   // Node 0,1,2 =BS 3,4,5 =MS
     num_streams=3;
     num_bs=3;
     num_ms=3;
     num_streams_per_bs=1;
     num_streams_per_ms=1;
     num_antennas_in_system=6;
     replica_positions_this_bs.set_length(num_streams_per_bs);
     replica_positions_this_bs(0)=replicas_start+(d_node_ix %  num_links)*replicas_spacing;
     replica_positions.set_length(num_streams);
     for (uint32_t i1=0;i1<num_streams;i1++) {
       replica_positions(i1)=replicas_start+i1*replicas_spacing;
     };

     stream_ix_this_node.set_length(1);
     stream_ix_this_node(0)=d_node_ix %  num_links;

     num_ant_ms=2;
     num_ant_bs=2;

     bs_to_stream_ix="0 ; 1 ; 2";
     stream_ix_to_ms_ix="0,1,2";

     if (node_ix<num_links)
       is_bs=true;
     else
       is_bs=false;



   };
   if (scenario==2) {

     num_ant_ms=2;
     num_ant_bs=6;

     num_bs=1;
     num_ms=3;
     num_links=3; // Node 0 =BS 1,2,3 =MS
     num_streams=3;
     num_streams_per_bs=3;
     num_streams_per_ms=1;
     num_antennas_in_system=6;
     if (node_ix==0) {
       is_bs=true;
       bs_to_stream_ix="0 1 2";
       stream_ix_to_ms_ix="0,1,2";
       stream_ix_this_node="0 1 2";
     } else {
       stream_ix_this_node.set_length(1);
       stream_ix_this_node(0)=d_node_ix-1;
       is_bs=false;
     };
     replica_positions_this_bs.set_length(num_streams_per_bs);
     for (uint32_t i1=0;i1<num_streams_per_bs;i1++) {
       replica_positions_this_bs(i1)=replicas_start+i1*replicas_spacing;
     };
     replica_positions.set_length(num_streams);
     for (uint32_t i1=0;i1<num_streams;i1++) {
       replica_positions(i1)=replicas_start+i1*replicas_spacing;
     };


   };
   if (scenario==3) { // Node 0,1,2 =BS 3,4,5 =MS, MIMO
     num_bs=3;
     num_ms=3;

     num_ant_ms=2;
     num_ant_bs=2;

     num_links=3;
     num_streams=2;
     num_streams_per_bs=2;
     num_streams_per_ms=2;
     num_antennas_in_system=6;
     replica_positions_this_bs.set_length(num_streams_per_bs);
     replica_positions_this_bs(0)=replicas_start;
     replica_positions_this_bs(1)=replicas_start+replicas_spacing;
     stream_ix_this_node="0 1";
     bs_to_stream_ix="0 1;0 1;0 1";
     do_calculate_beamformers=false;

     MIMO_active_tx_node_tx=0;
     MIMO_closed_loop=false;
     MIMO_all_active=false;
     stream_ix_to_ms_ix="0,0";

     if (node_ix<num_links)
       is_bs=true;
     else
       is_bs=false;
   };
   if (scenario==4) { // SIMO

     num_ant_ms=2;
     num_ant_bs=2;

     num_bs=3;
     num_ms=3;
     num_links=1;
     num_streams=1;
     num_streams_per_bs=1;
     num_streams_per_ms=1;
     num_antennas_in_system=6;
     replica_positions_this_bs.set_length(num_streams_per_bs);
     replica_positions_this_bs(0)=replicas_start+(d_node_ix %  num_links)*replicas_spacing;
     stream_ix_this_node.set_length(1);
     stream_ix_this_node(0)=d_node_ix %  num_links;
     do_calculate_beamformers=false;
     bs_to_stream_ix="0;0;0";  

     if (node_ix<num_bs)
       is_bs=true;
     else
       is_bs=false;

   };

   if (!is_bs) {
     demodulation_position.set_size(num_streams_per_ms);
     for (uint32_t i1=0;i1<num_streams_per_ms;i1++) {
       demodulation_position(i1)=shift_transmit_signal_samples;
       //demodulation_position(i1)=replica_positions(stream_ix_this_node(i1));
       demodulation_position(i1)+=receiver_delay_samples;
       
     };
   };
   
   antenna_pilot_position.set_length(num_antennas_in_system);
   antenna_pilot_position_this_bs.set_length(no_ant);


   for (uint32_t i1=0;i1<num_antennas_in_system;i1++) {
     antenna_pilot_position(i1)=num_payload_symbols_before_pilots+
     num_streams+i1;
   };


   if (scenario!=2) {
     for (uint32_t i1=0;i1<no_ant;i1++) {
       antenna_pilot_position_this_bs[i1]=antenna_pilot_position[(node_ix % num_links)*no_ant+i1];
     };
   } else
     antenna_pilot_position_this_bs=antenna_pilot_position;



   known_pos_all.set_length(num_streams);
   for (uint32_t i1=0;i1<num_streams;i1++) {
     reorder_all[i1].set_length(num_symbols);
     known_pos_all(i1)=num_payload_symbols_before_pilots+i1;
     for (uint32_t i2=0;i2<num_payload_symbols_before_pilots;i2++) {
       (reorder_all[i1])(i2)=i2;
     };
     reorder_all[i1](num_payload_symbols_before_pilots)=num_payload_symbols_before_pilots+i1;
     for (uint32_t i2=0;i2<num_payload_symbols_after_pilots;i2++) {
       (reorder_all[i1])(i2+num_payload_symbols_before_pilots+1)=
         num_payload_symbols_before_pilots+num_streams+num_antennas_in_system+i2;
     };
   };
   known_pos.set_length(1);
   known_pos(0)=num_payload_symbols_before_pilots;

   if (scenario==2) {
     if (node_ix==0) {
       for (uint32_t i1=0;i1<num_streams_per_bs;i1++) {
         
         ai[i1].init(use_pilot_carriers,false,cyclic_prefix_length,num_symbols,
                     known_pos,reorder_all[i1]);

         ai[i1].estimate_SINR=run_decoder;
       };
     }
     else {

        ai[0].init(use_pilot_carriers,false,cyclic_prefix_length,num_symbols,
                     known_pos,reorder_all[node_ix-1]);
        ai[0].estimate_SINR=run_decoder;
        ai[0].noise_estimation_start_ix=noise_estimation_start_ix;
        ai[0].noise_estimation_stop_ix=shift_transmit_signal_samples-10;

   };

   };
   if (scenario==3) {
     for (uint32_t i1=0;i1<num_streams_per_ms;i1++) {
       ai[i1].init(use_pilot_carriers,false,cyclic_prefix_length,num_symbols,
                   known_pos,reorder_all[i1]);
       ai[i1].estimate_SINR=run_decoder;
       ai[i1].noise_estimation_start_ix=noise_estimation_start_ix;
       ai[i1].noise_estimation_stop_ix=shift_transmit_signal_samples-10;

     };                                  
   };
   if ((scenario==1) | (scenario==4)) {
     ai[0].init(use_pilot_carriers,false,cyclic_prefix_length,num_symbols,
                  known_pos,reorder_all[node_ix % num_links]);
     ai[0].estimate_SINR=run_decoder;
     ai[0].noise_estimation_start_ix=noise_estimation_start_ix;
     ai[0].noise_estimation_stop_ix=shift_transmit_signal_samples-10;
   };
   

   if (!is_bs) {
     for (int i1=0;i1<stream_ix_this_node.length();i1++) {
       ivec interferer_pos(num_streams-1);
       int i10=0;
       for (int i2=0;i2<(int) num_streams;i2++) {
         if (stream_ix_this_node(i1)!=i2) {
           interferer_pos(i10)=known_pos_all(i2);
           i10++;
         };
       };
       ai[i1].init_multi_antenna(no_ant, d_buffer_length, interferer_pos);
     };
   };
   if (node_ix==0) {
      for (uint32_t i1=0;i1<num_antennas_in_system;i1++) {
        for (uint32_t i2=0;i2<num_ms;i2++) {
          H[i1][i2].set_size(num_ant_ms,ai[0].length_ix_all);
        };
      };

      for (uint32_t i1=0;i1<num_streams;i1++) { 
        Vbig[i1].set_size(no_ant,ai[0].length_ix_all); 
        //Ubig[i1].set_size(no_ant,ai[0].length_ix_all);
        Vbig[i1]=randn_c(no_ant,ai[0].length_ix_all); 
        normalize_columns(Vbig[i1]);
        
      };
   };
           
   //int bits_per_symbol=log2(qam_order);

   word_length=(ai[0].length_ix)*5*2*4;
   amc.init(word_length,true);
   amc.only_raw_bits=true;
   if (run_decoder) {
     amc.only_raw_bits=false;
     d_run_decoder=run_decoder;
   };
   transmitted.set_length(word_length);
   transmitted_hat.set_length(word_length);
   message_hat.set_length(amc.codec_message_size(amc.no_of_codecs()-1));
   decoded_bits.set_length(amc.codec_message_size(amc.no_of_codecs()-1));
   input.set_length(amc.codec_message_size(amc.no_of_codecs()-1));

   //soft_bit.set_length((ai[0].Ns-1)*ai[0].length_ix*bits_per_symbol);

   waveform_rx.set_size(no_ant,d_buffer_length);
   waveform_tx.set_length(d_buffer_length);
   waveform_tx_temp.set_length(d_buffer_length);
   waveform_rx.zeros();
   waveform_tx.zeros();
   waveform_tx_temp.zeros();

   BERraw.set_length(100);
   BER.set_length(100);
   EVM.set_length(100);
   SINR.set_length(100);

   ber_i=0;


   symbols.set_length((ai[0].Ns-1)*ai[0].length_ix);
   
}

IA1_node::~IA1_node(void) {
};

frame_settings IA1_node::node_init(void) {

  ber_i=0;
  d_frame_ix=0;
  feedback_buffer_size=num_antennas_in_system*num_ant_ms*
    sizeof(std::complex<int16_t>)*ai[0].Nfftr();

  feedback_buffer_size_tx=num_ant_bs*
    sizeof(std::complex<int16_t>)*ai[0].length_ix_all*num_streams_per_bs;



  if (feedback_buffer_size>feedback_buffer_size_tx) {
    feedback_buffer=(std::complex<int16_t> *) malloc(feedback_buffer_size);
    feedback_buffer0=(std::complex<int16_t> *) malloc(feedback_buffer_size);
    feedback_buffer1=(std::complex<int16_t> *) malloc(feedback_buffer_size);
    feedback_buffer2=(std::complex<int16_t> *) malloc(feedback_buffer_size);

  } else {
    feedback_buffer=(std::complex<int16_t> *) malloc(feedback_buffer_size_tx);
    feedback_buffer0=(std::complex<int16_t> *) malloc(feedback_buffer_size);
    feedback_buffer1=(std::complex<int16_t> *) malloc(feedback_buffer_size);
    feedback_buffer2=(std::complex<int16_t> *) malloc(feedback_buffer_size);
  };

  if (other_node_ixs.size()==0) {
    other_node_ixs.push_back(0); // Changed later on
    other_node_ixs.push_back(1);
    other_node_ixs.push_back(2);
    pointers_to_data.push_back(feedback_buffer0);
    pointers_to_data.push_back(feedback_buffer1);
    pointers_to_data.push_back(feedback_buffer2);
    num_bytess.push_back(feedback_buffer_size);
    num_bytess.push_back(feedback_buffer_size);
    num_bytess.push_back(feedback_buffer_size);
  };


  if ((scenario==3) && (!MIMO_closed_loop)) {
    do_calculate_beamformers=false;
    if (MIMO_all_active) {
      if ((d_node_ix==0) | (d_node_ix==3))
        stream_ix_this_node="0 1";
      if ((d_node_ix==1) | (d_node_ix==4))
        stream_ix_this_node="2 3";
      if ((d_node_ix==2) | (d_node_ix==5))
        stream_ix_this_node="4 5";
    };
  };
   


  if (is_bs) {


   // Initialize pre-coding matrices
   if (is_bs) {
     for (uint32_t i1=0;i1<num_streams_per_bs;i1++) {
       v[i1].set_size(d_no_ant,ai[i1].length_ix_all);
       v[i1].zeros();
       if ((d_node_ix==0) & (i1==0)) {
         v[i1].set_row(0,ones_c(ai[i1].length_ix_all));
         //Vbig[i1]=v[i1];
       };
     };
   };



    return node_process(); // TX
  } else { //RX
    frame_settings frame;
    std::vector<double> gain_rx_vec(1);
    std::vector<double> gain_tx_vec(1);
    std::vector<double> freq_vec(1);

    
    gain_rx_vec[0]=d_gain_rx;
    gain_tx_vec[0]=d_gain_tx;
    freq_vec[0]=d_frequency;
    frame.what=RX;
    frame.gain_rx=gain_rx_vec;
    frame.gain_tx=gain_tx_vec;
    frame.frequency=freq_vec;
    frame.time=offset_time;


    return frame;
  };

};


void IA1_node::end_of_run(){
  free(feedback_buffer);
  free(feedback_buffer0);
  free(feedback_buffer1);
  free(feedback_buffer2);

  BER=BER.mid(0,ber_i);
  BERraw=BERraw.mid(0,ber_i);
  EVM=EVM.mid(0,ber_i);
  SINR=SINR.mid(0,ber_i);
};

frame_settings IA1_node::node_process(void) {


  frame_settings frame;
  std::vector<double> gain_rx_vec(1);
  std::vector<double> gain_tx_vec(1);
  std::vector<double> freq_vec(1);


  gain_rx_vec[0]=d_gain_rx;
  gain_tx_vec[0]=d_gain_tx;
  freq_vec[0]=d_frequency;

  frame.frequency=freq_vec;
  frame.gain_rx=gain_rx_vec;
  frame.gain_tx=gain_tx_vec;

  d_frame_ix++;


  if (!is_bs) { /****** RX ***********/

    std::cout << "Processing in the receiver \n";


        // Feedback raw signal samples during common pilots
        if (true) { // Need only be done ones

            std::complex<int16_t> *p1;
            int c=0;
            for (uint32_t i2=0;i2<num_antennas_in_system;i2++) {
              

              int s=(ai[0].Nfftr()+ai[0].Np)*antenna_pilot_position(i2)+
                demodulation_position(0); 

              for (uint32_t i3=0;i3<d_no_ant;i3++) {
                
                p1=(std::complex<int16_t> *) d_rx_buffers[i3];          
                int d=ai[0].Nfftr()*sizeof(std::complex<int16_t>);              
                memcpy(&feedback_buffer[c*ai[0].Nfftr()],&p1[s],d);             
                c++;
                
              };     
            };


            if (do_calculate_beamformers) {
               x2_tx(0,feedback_buffer,feedback_buffer_size);
            } else {
               x2_tx(0,feedback_buffer,10);
            };
        };


      frame.time=d_frame_ix*time_between_frames+offset_time;

      /* Data is available in d_rx_buffers[0] */

      for (uint32_t i2=0;i2<d_no_ant;i2++) {
        std::complex<int16_t> *p1;
        p1=(std::complex<int16_t> *) d_rx_buffers[i2];
        for (uint32_t i1=0;i1<d_buffer_length;i1++) 
          waveform_rx(i2,i1)=p1[i1];
      };


      for (uint32_t i1=0;i1<num_streams_per_ms;i1++) {


        ai[i1].extract_multi_antenna(waveform_rx,demodulation_position(i1),symbols);

        noise_variance_norm=amc.noise_variance(symbols,modulation_order);       
        ai[i1].de_interleave_symbols(symbols,stream_ix_this_node(i1)+d_frame_ix);


        SINR_temp=ai[i1].SINR;
        decode_rx_symbols(codec_ix,modulation_order,stream_ix_this_node(i1));




        //itpp::it_file d1;
        //d1.open("d1.it");
        //d1<< itpp::Name("w_rx") << waveform_rx;
        //d1.close();


                
      };
      #if 0
      if ((d_frame_ix==2) & (d_node_ix>3)){
        cout << "d_node_ix=" << d_node_ix << endl;
        itpp::it_file d1;
        d1.open("d1.it");
        d1<< itpp::Name("waveform_rx") << waveform_rx;
        d1<< itpp::Name("symbols") << symbols;
        d1<< itpp::Name("h") << ai[0].h ;
        //d1<< itpp::Name("part_waveform_rx") << 
        //  waveform_rx.get_row(1).mid(ai[0].start_of_known_symbol()(0)+
        //                           demodulation_position(0),ai[0].Nfftr());

        //d1<< itpp::Name("Const") << ai[0].ConstellationStorage ;
        d1.close();
        exit(1);
      };
      #endif

      frame.what=RX;

      if (d_frame_ix==(d_no_frames)) 
        frame.what=END;



      return frame;


  };

  if (is_bs) { // ***** TX ******



    frame.time=(d_frame_ix-1)*time_between_frames+offset_time;
    std::cout << "Processing in the transmitter \n";  
    double rms_power=-10; // Disable calculation of rms_power

    
    if ((d_node_ix==0) & (d_frame_ix>1)){

      
      // Receive data from feedback buffer
      // node_ix=0 is the boss!

      cvec waveform_temp(ai[0].Nfftr());
      double nvn, nv;
      cvec h(ai[0].length_ix_all);


      
      other_node_ixs[0]=num_bs;
      other_node_ixs[1]=num_bs+1;
      other_node_ixs[2]=num_bs+2;

      std::vector<uint32_t> num_bytess_short(3);
      num_bytess_short[0]=10;
      num_bytess_short[1]=10;
      num_bytess_short[2]=10;


      if (do_calculate_beamformers) {
        x2_rx(other_node_ixs ,pointers_to_data,num_bytess);
      } else {
        x2_rx(other_node_ixs ,pointers_to_data,num_bytess_short);
      };
      std::complex<int16_t> *fe;

      for (uint32_t i1=0;i1<num_ms;i1++) {
          fe=(std::complex<short int>*) pointers_to_data[i1];
          std::cout << "i1=" << i1 << "\n";
          int i40=0;
          for (uint32_t i2=0;i2<num_antennas_in_system;i2++) {
            for (uint32_t i3=0;i3<num_ant_ms;i3++) {        
              for (uint32_t i4=0;i4<ai[0].Nfftr();i4++) {
                waveform_temp(i4)=fe[i40+i4];
              }; // i4
              i40+=ai[0].Nfftr();
              ai[0].estimate_channel(waveform_temp,nvn,h,0,nv);
              H[i2][i1].set_row(i3,h);
            }; // i3
          }; // i2        
      }; //i1
      
      
      // Calculate beamformers for all streams

      timer.reset();
      timer.start();
      if (do_calculate_beamformers) {
        calculate_beamformers();
      };
      timer.stop();
      //std::cout << "timer.get_time()=" << timer.get_time() << std::endl;
      
      if (!do_calculate_beamformers)  {
        
        for (uint32_t i1=0;i1<num_streams;i1++) {
          for (uint32_t i2=0;i2<ai[0].length_ix_all;i2++) {
            for (int i3=0;i3<Vbig[i1].rows();i3++) {
        
              if (scenario==3) {                
                if (((int) i3)==i1) {
                  Vbig[i1](i3,i2)=1;
                } else {
                  Vbig[i1](i3,i2)=0;
                }; // if
              } else { // scenario==4
                if (((int) i3)==(d_frame_ix % num_ant_bs)) {
                     Vbig[i1](i3,i2)=1;
                  } else {
                     Vbig[i1](i3,i2)=0;
                }; // if                
              };   
            }; // i3
          }; // i2
        }; // i1
      };

      
      if (d_simulate) {
          stringstream filename;
          stringstream variable_name;
          filename << "Vbig" << d_frame_ix-1 << "_" << scenario << ".it";
          itpp::it_file d1;
          d1.open(filename.str());
          
          
          d1<< itpp::Name("Vbig0") << Vbig[0];
          if (scenario!=4) 
          d1<< itpp::Name("Vbig1") << Vbig[1];
          if ((scenario!=3) && (scenario!=4)) 
            d1<< itpp::Name("Vbig2") << Vbig[2];
          d1.close();
      };
      

    };


    if (d_node_ix==0) {

      // Transmit precoders to the other TX:s
      //std::cout << "Transmit precoders to the other TX:s \n";
      
      if (d_frame_ix>1) {       
        for (uint32_t i1=1;i1<num_bs;i1++) {
          int i30=0;
          for (uint32_t i4=0;i4<num_streams_per_bs;i4++) {
            for (uint32_t i2=0;i2<d_no_ant;i2++) {
              for (uint32_t i3=0;i3<ai[0].length_ix_all;i3++) {         
                feedback_buffer[i3+i30]=10000*(Vbig[bs_to_stream_ix(i1,i4)]
                                               (i2,i3));
                
              };
              i30+=ai[0].length_ix_all;
            };
          };
          x2_tx(i1,feedback_buffer,feedback_buffer_size_tx);
        };      
        v[0]=Vbig[0];
        if (scenario==2) {
          v[1]=Vbig[1];
          v[2]=Vbig[2];
        };
        if (scenario==3) {
          v[1]=Vbig[1];
        };
      };
      //std::cout << "Done transmit precoders to the other TX:s \n";

      
     } else { 

      if (d_frame_ix>1) {

        // Receive precoders from node_ix=0
        
        x2_rx(0,feedback_buffer,feedback_buffer_size_tx);
      
        int i30=0;
        complex<double> temp;
        for (uint32_t i4=0;i4<num_streams_per_bs;i4++) {
          for (uint32_t i2=0;i2<d_no_ant;i2++) {        
            for (uint32_t i3=0;i3<ai[0].length_ix_all;i3++) {
              temp=feedback_buffer[i3+i30];
              temp=temp*1e-4;
              v[i4](i2,i3)=temp;
            };
            i30+=ai[0].length_ix_all;
          };
        };
      };
    };

   
    if (scenario==4) {
      (v[0]).zeros();
    };
    

    if ((scenario==3) && (!(d_node_ix==MIMO_active_tx_node_tx)) && (!MIMO_all_active)) {
      (v[0]).zeros();
      (v[1]).zeros();
    };


    // Format data to be transmitted in the next burst
    //timer.reset();
    //timer.start();


    
    for (uint32_t i2=0;i2<d_no_ant;i2++) {
      


      waveform_tx.zeros();
      ai[0].insert_pilot(waveform_tx,antenna_pilot_position_this_bs[i2], 
                   shift_transmit_signal_samples,
                                          ones_c(ai[0].length_ix_all));
      

      // Payload data
      for (uint32_t i1=0;i1<num_streams_per_bs;i1++) {

        
        format_tx_symbols(codec_ix,modulation_order,stream_ix_this_node(i1));
        ai[i1].interleave_symbols(symbols,stream_ix_this_node(i1)+d_frame_ix);

        
        waveform_tx_temp.zeros();
        ai[i1].modulate(waveform_tx_temp,symbols,shift_transmit_signal_samples,
                        rms_power,v[i1].get_row(i2));
        waveform_tx+=waveform_tx_temp;

        // Create replica
        waveform_tx.replace_mid(replica_positions_this_bs(i1),
                 waveform_tx_temp.mid(shift_transmit_signal_samples,replicas_spacing));
        

       ai[0].insert_pilot(waveform_tx,antenna_pilot_position_this_bs(i2), 
                   replica_positions_this_bs(i1),
                                          ones_c(ai[0].length_ix_all));



      };
      

      

      waveform_tx=scaling_tx_signal*waveform_tx;

     std::complex<int16_t> *p1;
      p1=(std::complex<int16_t> *) d_tx_buffers[i2];
      for (uint32_t i1=0;i1<d_buffer_length;i1++) {
        p1[i1]=waveform_tx(i1);
      };      

      //timer.stop();
      //std::cout << "Time formatting data timer.get_time()=" << timer.get_time() << std::endl;



    };


    //cout << "w=" << waveform_tx.mid(0,200) << endl;
    frame.what=TX;

    if (d_frame_ix==(d_no_frames+1)) 
      frame.what=END;

  };
  
      
  return frame;
  

}


void IA1_node::normalize_columns(cmat &M) {
  double n;
  for (int i1=0; i1<M.cols();i1++) {
    
    n=norm(M.get_col(i1),2);
    M.set_col(i1,M.get_col(i1)/n);

  };
};



void IA1_node::format_tx_symbols(uint32_t codec_ix, uint32_t modulation_order,int stream_ix) 
{

  
  int l=amc.codec_message_size(codec_ix);

  if (use_old_rand) {
    RNG_reset(100+10000*stream_ix+d_seed);
    input.set_subvector(0,randb(l));
  } else {
    temp_seed=100+10000*stream_ix+d_seed;
    amc.randb_thread_safe(0,l,input,&temp_seed) ;
  };

  amc.modulate(modulation_order,codec_ix,input.mid(0,l),
               transmitted,symbols,0) ;    



  if (modulation_order>15) {
      if (use_old_rand) {
        RNG_reset(110+10000*stream_ix+d_seed);
        input.set_subvector(0,randb(l));
      } else {
        temp_seed=110+10000*stream_ix+d_seed;
        amc.randb_thread_safe(0,l,input,&temp_seed) ;
      };

      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
           transmitted,symbols, word_length/(log2(modulation_order))) ;
  };

  if (modulation_order>63) {
      if (use_old_rand) {
        RNG_reset(120+10000*stream_ix+d_seed);
        input.set_subvector(0,randb(l));
      } else {
        temp_seed=120+10000*stream_ix+d_seed;
        amc.randb_thread_safe(0,l,input,&temp_seed) ;
      };

      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,2*word_length/(log2(modulation_order)));
    
  };
  if (modulation_order>255) {

      if (use_old_rand) {
        RNG_reset(130+10000*stream_ix+d_seed);
        input.set_subvector(0,randb(l));
      } else {
        temp_seed=130+10000*stream_ix+d_seed;
        amc.randb_thread_safe(0,l,input,&temp_seed) ;
      };
      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,3*word_length/(log2(modulation_order)));
    
  };

};


void IA1_node::decode_rx_symbols(uint32_t codec_ix, uint32_t modulation_order, int stream_ix)
{ 


  cout << "(" << d_node_ix << "," << stream_ix << ")" << endl;
    
  int l=amc.codec_message_size(codec_ix);

  if (use_old_rand) {
    RNG_reset(100+10000*stream_ix+d_seed);
    input.set_subvector(0,randb(l));
  } else {
     temp_seed=100+10000*stream_ix+d_seed;
     amc.randb_thread_safe(0,l,input,&temp_seed) ;
  };

  amc.encode(codec_ix,input.mid(0,l),transmitted) ;
  amc.demodulate(symbols.mid(0,word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);


  if (d_run_decoder) {
     EVM[ber_i]=amc.evm(modulation_order,transmitted,symbols,0);
     SINR[ber_i]=SINR_temp;
  };

  berc.clear();
  berc.count(transmitted,transmitted_hat);  
  BERraw[ber_i]=berc.get_errorrate();
  SINR[ber_i]=SINR_temp;
  berc.clear();
  berc.count(input.mid(0,l),message_hat.mid(0,l));  
  BER[ber_i]=berc.get_errorrate();
  ber_i++;
  
  


  if (modulation_order>15) {

    if (use_old_rand) {
      RNG_reset(110+10000*stream_ix+d_seed);
      input.set_subvector(0,randb(l));
    } else {
      temp_seed=110+10000*stream_ix+d_seed;
      amc.randb_thread_safe(0,l,input,&temp_seed) ;
    };
    amc.encode(codec_ix,input.mid(0,l),transmitted) ;

    amc.demodulate(symbols.mid(word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
    
    
    if (d_run_decoder) {
      EVM[ber_i]=amc.evm(modulation_order,transmitted,symbols,
                word_length/(log2(modulation_order)));
      SINR[ber_i]=SINR_temp;
    };
      
    berc.clear();
    berc.count(transmitted,transmitted_hat);  
    BERraw[ber_i]=berc.get_errorrate();
    //cout << "BER(raw)=" << BERraw[ber_i] << endl;
    berc.clear();
    berc.count(input.mid(0,l),message_hat.mid(0,l));  
    BER[ber_i]=berc.get_errorrate();
    //cout << "BER=" << BER[ber_i] << endl;
    ber_i++;

  };

  if (modulation_order>63) {

    if (use_old_rand) {
      RNG_reset(120+10000*stream_ix+d_seed);
      input.set_subvector(0,randb(l));
    } else {
     temp_seed=120+10000*stream_ix+d_seed;
     amc.randb_thread_safe(0,l,input,&temp_seed) ;

    };
    amc.encode(codec_ix,input.mid(0,l),transmitted) ;

    amc.demodulate(symbols.mid(2*word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);


    if (d_run_decoder) {
      EVM[ber_i]=amc.evm(modulation_order,transmitted,symbols,
                         2*word_length/(log2(modulation_order)));
      SINR[ber_i]=SINR_temp;
    };
      
    berc.clear();
    berc.count(transmitted,transmitted_hat);  
    BERraw[ber_i]=berc.get_errorrate();
    //cout << "BER(raw)=" << BER[0] << endl;
    berc.clear();
    berc.count(input.mid(0,l),message_hat.mid(0,l));  
    BER[ber_i]=berc.get_errorrate();
    //cout << "BER=" << BER[0] << endl;
    ber_i++;

  };
  if (modulation_order>255) {

    if (use_old_rand) {
      RNG_reset(130+10000*stream_ix+d_seed);
      input.set_subvector(0,randb(l));
    } else {
     temp_seed=130+10000*stream_ix+d_seed;
     amc.randb_thread_safe(0,l,input,&temp_seed) ;
    };

    amc.encode(codec_ix,input.mid(0,l),transmitted) ;
    amc.demodulate(symbols.mid(3*word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);

    if (d_run_decoder) {
     EVM[ber_i]=amc.evm(modulation_order,transmitted,symbols,
                        3*word_length/(log2(modulation_order)));
     SINR[ber_i]=SINR_temp;
    };

    berc.clear();
    berc.count(transmitted,transmitted_hat);  
    BERraw[ber_i]=berc.get_errorrate();
    //cout << "BER(raw)=" << BER[0] << endl;
    berc.clear();
    berc.count(input.mid(0,l),message_hat.mid(0,l));  
    BER[ber_i]=berc.get_errorrate();
    //cout << "BER=" << BER[0] << endl;
    ber_i++;

  };
  
};