modem/modem_OFDM2.hpp

/*
 * Copyright 2013, Per Zetterberg
 *
 * 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/>.
 */

/* This code should implement, more or less, the same functions as 
 * 
 * mod_OFDM2.m and demod_OFDM2.m
 *
 *
 */

#include <itpp/itcomm.h>
#include <complex>
#include <iostream>
#include <boost/format.hpp>

 
using namespace std;
using namespace itpp;

#ifndef MODEM_OFDM2_H
#define MODEM_OFDM2_H

class OFDM2 {

public:

  uint32_t rightmost_carrier; // Set in init
  uint32_t leftmost_carrier; // Set in init
  int rightmost_carrier_IEEE; // Set in init
  int leftmost_carrier_IEEE; // Set in init
  


  static const uint32_t Nfft=80;
  uint32_t pilot_carrier1; // Set in init
  uint32_t pilot_carrier2; // 
  static const uint32_t Nfft_sync=65536; // Frequency offsets with 25e6/Nfft_sync spacing.
  static const uint32_t gap=3;

  cmat a1c, a2c;
  
  double d_noise_variance_receiver;
  ivec known_symbol_pos;
  ivec interferers_known_pos;
  uint32_t Ns;//, nof_symbols_storage;
  complex<double> pilot_symbol;
  //uint32_t storage_ix;
  int first_payload_symbol_index;
  ivec ix, ix_all, ix_sub, ix_null;
  ivec closest_pilot;
  ivec closest_pilot_all;
  ivec ix_all_IEEE;
  uint32_t length_ix, length_ix_all;
  int pilot_carrier1_sub, pilot_carrier2_sub;
  int rightmost_carrier_sub, leftmost_carrier_sub;
  //cvec ConstellationStorage; //(length_ix*nof_symbols_storage);
  cvec train;
  cvec h;
  cvec pulse_shape;
  int pulse_shape_delay;
  bool do_use_pilot_carriers, do_prepend_training;
  bool per_symbol_phase_derotation;
  uint32_t Np;
  ivec d_reorder;
  double pilot_power_factor;
  cmat he; // Channel estimate of desired signal stream
  cmat hi[10]; // Channel estimate of at most 10 interfering signal streams
  cmat x; // 
  cmat x_c; // Combined signal
  cmat x_cp; // Combined with per antenna common phase-error correction.
  bool estimate_SINR; // If you want the receiver to estimate it's own SINR.
  double SINR; // Here's the result.
  int noise_estimation_start_ix, noise_estimation_stop_ix; // Defines where
                                   // in the buffer samples can be taken for
                                   // additive noise estimation.
  cvec cpe00;
  //OFDM2(bool use_pilot_carriers, bool prepend_training,uint32_t prefix_length);

  OFDM2(void);



  uint32_t Nfftr(void){return Nfft;};

  uint32_t number_of_modulation_symbols(void);

  uint32_t waveform_length(void);

  uint32_t prefix_length(void) { return Np; };
  

  uint32_t length(void) { return (Np+Nfft); };

  ivec start_of_known_symbol(void);
  
  void init_multi_antenna(uint32_t no_ant, int32_t buffer_size, ivec &interferer_pos,double noise_variance);

  void pilot_pattern(cvec &burst, cvec precoder);

  void insert_pilot(cvec &waveform, uint32_t symbol_number, uint32_t offset,
cvec precoder);

  void insert_pilot(cmat &waveform, uint32_t symbol_number, uint32_t offset,
                    int antenna_ix,double scaling);

 
  
void modulate(cvec &waveform,const cvec &symbols_in,  
               const uint32_t offset,double &rms_power,const cvec &precoder);


  void modulate_multi_antenna(cmat &waveform,
const cvec &symbols_in,  
                     const uint32_t offset,
                              vec &rms_power,const cmat &V, double scaling, 
int Nss);

  void modulate_multi_antenna(cmat &waveform,
const cmat &symbols_in,  
                     const uint32_t offset,
                              vec &rms_power,const cmat V[], double scaling, ivec stream_ix_this_node, int symbols_ix_start=0, int num_symbols=0) const;



  void estimate_channel(cvec waveform,double  &noise_variance_normalized,cvec &h, uint32_t start_sample);  

  void estimate_channel(cvec waveform,double  &noise_variance_normalized,
                      cvec &h, uint32_t start_sample, double &noise_variance);

  void demodulate(const cvec &waveform,cvec &symbols_out, uint32_t start_sample,
           const cvec &h, double &rms_signal);


  void demodulate_multi_antenna(const cmat &waveform,vec &soft_bit, uint32_t start_sample, int modulation_order,int num_symbols_to_extract);


  void extract_multi_antenna(const cmat &waveform,uint32_t start_sample,
int num_symbols_to_extract);
 

  void extract_multi_antenna(const cmat &waveform,
   uint32_t start_sample, cvec &symbols_out,int num_symbols_to_extract); 


  /* \brief This function initializes the parameters used for the IEEE802.11ac
       MU-MIMO feedback.
     \param b_phis The number of bits in the phis representation.
     \param b_psis The number of bits in the psis representation.
     \param num_ms_ant Number of mobile antennas represented in the feedback. 
     \param num_of_tx_antennas Number of transmitter side antennas represented in the feedback.
     \param Ng The number of subcarriers per subcarrier-group.
  */
  void init_compressed_feedback(int b_psis,int b_phis, uint32_t num_ms_ant, uint32_t num_of_tx_antennas, int Ng, double noise_variance_per_subcarrier,bool IA_compression);


  void change_Ng(int Ng) {d_Ng=Ng;};
  ivec scwcf(void){return scwcfs[d_Ng-1];};
  ivec scwcf_ix_all(void){return scwcf_ix_alls[d_Ng-1];};
  ivec scwcf_ix_all_high(void){return scwcf_ix_all_highs[d_Ng-1];};
  ivec scwcf_ix_all_low(void){return scwcf_ix_all_lows[d_Ng-1];};

  /* \brief This class encapsulates the compressed beamforming feedback 
     format of IEEE802.11n and IEEE802.11ac. 
     \param phis The Givens rotation angle indecies.
     \param psis The complex rotation angle indecies.
     \param SNRs The SNRs of the streams according to the 
     \param Na_phis The number of phi angles per MIMO subcarrier matrix.
     \param Na_psis The number of psi angels per MIMO subcarrier matrix.

  */
  struct compressed_feedback_IEEE80211ac {
    ivec phis;
    ivec psis;
    std::vector<int> bar_SNRs;
    std::vector<int> delta_SNRs;
    
    uint16_t Na_phis;
    uint16_t Na_psis; 
  };

  /* \brief Calculate the compressed feedback parameters according
     to 802.11ac with exclusize MIMO SNR feedback reporting.
     \param H[] This is an array of num_of_tx_antennas elements,
      where each element is an IT++ cmat matrix. This matrix
      has it's number of rows equal to the number of receiver antennas
      and it's number of columns equal to the number of subcarriers
      of the OFDM modulation. */

  compressed_feedback_IEEE80211ac compress_feedback(cmat H[]);

  /* \brief Uncompress (unpack) the feedback provided by the feedback
     input. Fill the result into the array of matrices H[].
     The so obtained channels H[] can be used for beamforming. 
 */
  void uncompress_feedback(cmat H[],const OFDM2::compressed_feedback_IEEE80211ac &feedback);


  /* \brief Synchronize against synchronization sequence (i.e. the
sequence which is pre-pended if prepend_training=true when calling init),
and simultaneosly search for frequency offset. The function is only
implemented based for using a single antenna.
    \param waveform Received samples.
    \param start_pos Estimated start position.
    \param f_offset Estimated frequency offset.
*/
  void synchronize(cvec &waveform, uint32_t &start_pos,double &f_offset);

  /* \brief Synchronize against synchronization sequence (i.e. the
sequence which is pre-pended if prepend_training=true when calling init),
and simultaneosly search for frequency offset. The function is only
implemented based for using a single antenna.
    \param waveform Received samples.
    \param start_pos Estimated start position.
*/
  void synchronize(cvec &waveform, uint32_t &start_pos);

  void init(bool use_pilot_carriers, bool prepend_training,uint32_t prefix_length,uint32_t Ns, ivec known_pos, ivec re_order);

  void change_pulse_shape(cvec new_pulse_shape, int new_pulse_shape_delay);


  void interleave_symbols(cvec &symbol, int index);

  void de_interleave_symbols(cvec &symbol, int index);

  void pz_init_fft(ivec ix_all){
    double a;
    Wfft.set_size(Nfft,Nfft);
    Wifft.set_size(Nfft,Nfft);

    for (uint32_t i1=0;i1<Nfft;i1++) {
      for (uint32_t i2=0;i2<Nfft;i2++) {
        a=-2*pi;
        a=a*i1;
        a=a*i2;
        a=a/Nfft;
        Wfft(i1,i2)=polar(1.0,a);
        a=2*pi;
        a=a*i2;
        a=a*i1;
        a=a/Nfft;
        Wifft(i1,i2)=polar((1.0/Nfft),a);
      };
    };  
    
    Wifft_sub=Wifft.get_cols(ix_all);
    Wifft_sub_filtered.set_size(Nfft+Np+pulse_shape.length()-1,
                                Wifft_sub.cols());

    cvec temp1(Nfft);
    cvec temp2(Nfft+Np+pulse_shape.length()-1);
    temp2.zeros();
    cvec temp3(Nfft+Np+pulse_shape.length()-1);

    for (int i1=0;i1<Wifft_sub.cols();i1++) {

      temp1=Wifft_sub.get_col(i1);
      for (int i2=0;i2<(int) Nfft;i2++) 
        temp2(i2+Np)=temp1(i2);

      for (int i2=0;i2<(int) Np;i2++) 
        temp2(i2)=temp1(i2+Nfft-Np);

      temp3=filter(pulse_shape,1,temp2);
      //std::cout << "temp3=" << temp3 << std::endl;
      //exit(1);

      Wifft_sub_filtered.set_col(i1,temp3);

    };
    length_Wifft_sub_filtered=Wifft_sub_filtered.rows();
    //std::cout << "\n \n \n";
    //std::cout << "wf=" << Wifft_sub_filtered.get_col(0) << "\n";
    //std::cout << "\n \n \n";
    //std::cout << "w=" << Wifft_sub.get_col(0) << "\n";
    //exit(1);


  };

  void pz_fft(const cvec &in,cvec &out) { out=Wfft*in; };



  void pz_ifft(const cvec &in,cvec &out) { out=Wifft*in; };

  cmat Wfft;
  cmat Wifft;
  cmat Wifft_sub;
  cmat Wifft_sub_filtered;
  int length_Wifft_sub_filtered;

  imat symbol_interleave_matrix;
  imat symbol_de_interleave_matrix;

  static const int max_Ng=18;
  
  #if 0
  ivec scwcf_ix_all;
  ivec scwcf_ix_all_high;
  ivec scwcf_ix_all_low;
  ivec scwcf;
  ivec scwds;
  #endif

  ivec scwcfs[max_Ng];
  ivec scwdss[max_Ng];
  ivec scwcf_lows[max_Ng];
  ivec scwcf_highs[max_Ng];

  ivec scwcf_ix_all_lows[max_Ng];
  ivec scwcf_ix_all_highs[max_Ng];
  ivec scwcf_ix_alls[max_Ng];
  ivec scwcf_ds_lows[max_Ng];
  ivec scwcf_ds_highs[max_Ng];
  ivec scwcf_has_dss[max_Ng];

  int d_num_delta_SNRs[max_Ng];

  private:
  
  // Store parameters related to IEEE802.11ac MU MIMO feedback
  int d_b_psis, d_b_phis;
  int d_num_ms_ant;
  int d_num_tx_antennas;
  int d_Ng;
  //vec psis_codebook;
  //vec phis_codebook;
  int n_psis_codebook;
  int n_phis_codebook;
  double psis_res, phis_res;
  #if 0
  ivec scwcf_low;
  ivec scwcf_high;
  ivec scwcf_has_ds;
  ivec scwcf_ds_low;
  ivec scwcf_ds_high;
  int d_num_delta_SNR;
  #endif
  double d_noise_variance_per_subcarrier;
  bool d_IA_compression;
  cvec pilot_pattern_vec;

  cvec time_domain_pilot;
  cvec time_domain_filtered_pilot;


  void unpackV(ivec &psis_sc,ivec &phis_sc, cmat &V);

  void packV(ivec &psis_sc,ivec &phis_sc, const cmat &V);

};

#endif