nec_radiation_pattern.h

/*
  Copyright (C) 2004-2015  Timothy C.A. Molteno
  tim@molteno.net
  
  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 2 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, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef __nec_radiation_pattern__
#define __nec_radiation_pattern__

#include "nec_results.h"
#include "math_util.h"
#include "nec_ground.h"
#include "c_plot_card.h"



enum polarization_norm  {
  POL_MAJOR_AXIZ=1,
  POL_MINOR_AXIS=2,
  POL_VERTICAL=3,
  POL_HORIZONTAL=4,
  POL_TOTAL=5
};

enum polarization_sense {
  POL_LINEAR=0,
  POL_RIGHT=1,
  POL_LEFT=2
};

class nec_context;

class nec_radiation_pattern : public nec_base_result
{
public:
  // Radiation Pattern
  nec_radiation_pattern(int in_n_theta, int in_n_phi,
          nec_float in_theta_start, nec_float in_phi_start,
          nec_float in_delta_theta, nec_float in_delta_phi,
          nec_float in_range,
          nec_ground& in_ground,
          int in_ifar, nec_float in_wavelength,
          nec_float pinr, nec_float pnlr,
          int in_rp_output_format, int in_rp_normalization, int in_rp_ipd, int in_rp_power_average,
          nec_float in_gnor,
          c_plot_card& in_plot_card);
          
  virtual void write_to_file(ostream& os)  {
    write_to_file_aux(os);
  }

  virtual enum nec_result_type get_result_type()  {
    return RESULT_RADIATION_PATTERN;
  }
          
  void analyze(nec_context* in_context);
  
  void write_gain_normalization()  {
    if (_ifar != 1) {
      nec_float norm = get_maximum_gain_db();
      printf("Max Gain: %f\n",norm);
    }
  }
  
  
  /*Added for the python wrapping : some basic access functions...*/
  
  real_matrix get_gain()  {
    return _gain;
  }
  
  real_array get_gain_vert()  {
    return _power_gain_vert;
  }
  
  real_array get_gain_horiz()  {
    return _power_gain_horiz;
  }
  
  real_array get_gain_tot()  {
    return _power_gain_tot;
  }
  
  real_array get_pol_axial_ratio()  {
    return _polarization_axial_ratio;
  }
  
  nec_float get_pol_axial_ratio(int theta_index, int phi_index) const  {
    return _polarization_axial_ratio(theta_index, phi_index);
  }
  
  real_array get_pol_tilt()  {
    return _polarization_tilt;
  }
  
  int_array get_pol_sense_index()  {
    return _polarization_sense_index;
  }
  
  int get_pol_sense(int theta_index, int phi_index) const  {
    return _polarization_sense_index(theta_index, phi_index);
  }
  
  nec_float get_etheta_magnitude(int theta_index, int phi_index)  {
    return abs(_e_theta(theta_index, phi_index));
  }
  
  nec_float get_etheta_phase(int theta_index, int phi_index)  {
    return arg_degrees(_e_theta(theta_index, phi_index));
  }
  
  complex_array get_e_theta()  {
    return _e_theta;
  }
  
  nec_float get_ephi_magnitude(int theta_index, int phi_index)  {
    return abs(_e_phi(theta_index, phi_index));
  }
  
  nec_float get_ephi_phase(int theta_index, int phi_index)  {
    return arg_degrees(_e_phi(theta_index, phi_index));
  }
  
  complex_array get_e_phi()  {
    return _e_phi;
  }
  
  complex_array get_e_r()  {
    return _e_r;
  }
  
  nec_float get_normalization_factor()  {
    return get_gain_normalization_factor(m_rp_gnor);
  }
  
  nec_float get_average_power_gain()  {
    return _average_power_gain;
  }
  
  nec_float get_average_power_solid_angle()  {
    return _average_power_solid_angle;
  }
  
  nec_ground get_ground()  {
    return m_ground;
  }
  
  nec_float get_range()  {
    return m_range;
  }
  
  nec_float get_wavelength()  {
    return _wavelength;
  }
  
  real_array get_theta_angles() const {
    real_array ret(n_theta);
    for (int32_t i=0; i<n_theta; i++)
      ret[i] = get_theta(i);
    return ret;
  }
  
  nec_float get_delta_theta()  {
    return delta_theta;
  }
  
  nec_float get_theta_start()  {
    return  m_theta_start;
  }
  
  real_array get_phi_angles() const {
    real_array ret(n_phi);
    for (int32_t i=0; i<n_phi; i++)
      ret[i] = get_phi(i);
    return ret;
  }

  nec_float get_delta_phi()  {
    return delta_phi;
  }
  
  nec_float get_phi_start()  {
    return  m_phi_start;
  }

  
  int get_ifar()  {
    return _ifar;
  }
  
  int get_rp_normalization()  {
    return m_rp_normalization;
  }
  
  int get_rp_output_format()  {
    return m_rp_output_format;
  }
  
  int get_rp_power_average()  {
    return m_rp_power_average;
  }
  
  int get_rp_ipd()  {
    return m_rp_ipd;
  }
          
  /*End of access functions added for the wrapping*/
  
                                  
  nec_float get_maximum_gain_db()  {
    return get_gain_normalization_factor(0);
  }
  
  /****************** STATISTICS ********************/


private:
  nec_float mean(const real_matrix& pattern) const  {
    nec_float sum = 0.0;
    long rows = pattern.rows();
    long cols = pattern.cols();
    for (long i=0;i<rows;i++) {
      for (long j=0;j<cols;j++) {
        sum += pattern(i,j) * _averaging_scales(i,j);
      }
    }
    long len = rows*cols;
    return sum/(len*2.0 / pi());
  }

  nec_float sd(const real_matrix& pattern, nec_float _mean) const  {
    nec_float sum = 0.0;
    long rows = pattern.rows();
    long cols = pattern.cols();
    
    for (long i=0;i<rows;i++) {
      for (long j=0;j<cols;j++) {
        nec_float diff = pattern(i,j) - _mean;
        sum += diff*diff * _averaging_scales(i,j);
      }
    }
    long len = rows*cols;
    return std::sqrt(sum/(len*2.0 / pi()));
  }


public:
  nec_float get_gain_max() const  {
    return _power_gain_tot.maxCoeff();
  }

  nec_float get_gain_min() const  {
    return _power_gain_tot.minCoeff();
  }

  nec_float get_gain_mean() const  {
    return mean(_power_gain_tot);
  }
  
  nec_float get_gain_sd() const  {
    nec_float _mean = get_gain_mean();
    return sd(_power_gain_tot, _mean);
  }
  
  /********************** RHCP ********************************/
  nec_float get_gain_rhcp_max() const  {
    return _power_gain_rhcp.maxCoeff();
  }

  nec_float get_gain_rhcp_min() const  {
    return _power_gain_rhcp.minCoeff();
  }

  nec_float get_gain_rhcp_mean() const  {
    return mean(_power_gain_rhcp);
  }
  
  nec_float get_gain_rhcp_sd() const  {
    nec_float _mean = get_gain_rhcp_mean();
    return sd(_power_gain_rhcp, _mean);
  }
  
  /********************** LHCP ********************************/
  nec_float get_gain_lhcp_max() const  {
    return _power_gain_lhcp.maxCoeff();
  }

  nec_float get_gain_lhcp_min() const  {
    return _power_gain_lhcp.minCoeff();
  }

  nec_float get_gain_lhcp_mean() const  {
    return mean(_power_gain_lhcp);
  }
  
  nec_float get_gain_lhcp_sd() const  {
    nec_float _mean = get_gain_lhcp_mean();
    return sd(_power_gain_lhcp, _mean);
  }

  /* End of Statistics functions for the C interface */



  nec_float get_theta(int theta_index) const  {
    return (m_theta_start + delta_theta*theta_index);
  }

  int get_ntheta() const  {
    return (n_theta);
  }

  nec_float get_phi(int phi_index) const  {
    return (m_phi_start + delta_phi*phi_index);
  }

  int get_nphi() const  {
    return (n_phi);
  }

  nec_float get_power_gain(int theta_index, int phi_index) const  {
    return _gain(theta_index, phi_index);
  }

  nec_float get_power_gain_vert(int theta_index, int phi_index) const  {
    return _power_gain_vert(theta_index, phi_index);
  }

  nec_float get_power_gain_horiz(int theta_index, int phi_index) const  {
    return _power_gain_horiz(theta_index, phi_index);
  }

  nec_float get_power_gain_tot(int theta_index, int phi_index) const  {
    return _power_gain_tot(theta_index, phi_index);
  }

  nec_float get_power_gain_rhcp(int theta_index, int phi_index) const  {
    nec_float a = get_pol_axial_ratio(theta_index, phi_index);
    nec_float dbi = get_power_gain_tot(theta_index, phi_index);
    if (get_pol_sense(theta_index, phi_index) == POL_RIGHT)
      a = -a;

    nec_float f = (1-2*a+a*a)/(2*(1+a*a));
    return dbi + 10*log10(f);
  }

  nec_float get_power_gain_lhcp(int theta_index, int phi_index) const  {
    nec_float a = get_pol_axial_ratio(theta_index, phi_index);
    nec_float dbi = get_power_gain_tot(theta_index, phi_index);
    if (get_pol_sense(theta_index, phi_index) == POL_RIGHT)
      a = -a;

    nec_float f = (1+2*a+a*a)/(2*(1+a*a));
    return dbi + 10*log10(f);
  }

private:

  int get_index(int theta_index, int phi_index) const;
  
  bool m_analysis_done;
  
  int n_theta, n_phi;
  
  nec_float m_theta_start, delta_theta;
  nec_float m_phi_start, delta_phi;
  
  int _ifar;
  
  nec_float m_range;
  
  nec_float _wavelength;
  nec_float _pinr;
  nec_float _pnlr;
  
  nec_float _average_power_gain;
  nec_float _average_power_solid_angle;
  nec_float _maximum_gain;

  int m_rp_normalization;
  int m_rp_output_format;
  int m_rp_power_average;
  int m_rp_ipd;
  
  nec_float m_rp_gnor;
  
  real_matrix  _gain;
  real_matrix  _power_gain_lhcp;
  real_matrix  _power_gain_rhcp;
  real_matrix  _power_gain_vert;
  real_matrix  _power_gain_horiz;
  real_matrix  _power_gain_tot;
  real_matrix  _polarization_axial_ratio;
  real_matrix  _polarization_tilt;
  real_matrix  _averaging_scales;
  int_matrix   _polarization_sense_index;
                          
  complex_matrix  _e_theta;
  complex_matrix  _e_phi;
  complex_matrix  _e_r;
  
  void write_to_file_aux(ostream& os);
  
  nec_float get_gain_normalization_factor(nec_float gnor);
  
  void write_normalized_gain(ostream& os);
  
  nec_ground m_ground;
  c_plot_card m_plot_card;
};

#endif /* __nec_radiation_pattern__ */