nec2++  1.7.0
nec_results.h
1 /*
2  Copyright (C) 2004-2008, 2015 Timothy C.A. Molteno
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 2 of the License, or
7  (at your option) any later version.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 #ifndef __nec_results__
19 #define __nec_results__
20 
21 #include <vector>
22 #include <ostream>
23 #include <iostream>
24 #include <iomanip>
25 #include <string>
26 
27 #include "math_util.h"
28 using namespace std;
29 
30 enum RESULT_FORMAT {
31  RESULT_FORMAT_NEC = 1,
32  RESULT_FORMAT_XML = 2,
33  RESULT_FORMAT_CSV = 3
34 };
35 
36 
41 class output_helper
42 {
43 private:
44  ostream& os;
45  enum RESULT_FORMAT m_format;
46  bool m_in_section;
47 
48 public:
49 
50  output_helper(ostream& in_os, enum RESULT_FORMAT in_format)
51  : os(in_os), m_format(in_format), m_in_section(false)
52  {
53  }
54 
55  ~output_helper()
56  {
57  section_end();
58  }
59 
60 
61  inline void separator()
62  {
63  switch (m_format)
64  {
65  case RESULT_FORMAT_CSV:
66  os << ",";
67  break;
68 
69  case RESULT_FORMAT_NEC:
70  default:
71  os << " ";
72  break;
73  }
74  }
75 
76  inline void start_record()
77  {
78  switch (m_format)
79  {
80  case RESULT_FORMAT_XML:
81  os << "<record>";
82  break;
83 
84  default:
85  break;
86  }
87  }
88 
89  inline void end_record()
90  {
91  switch (m_format)
92  {
93  case RESULT_FORMAT_XML:
94  os << "</record>" << endl;
95  break;
96 
97  default:
98  os << endl;
99  break;
100  }
101  }
102 
103  inline void padding(const char* s)
104  {
105  switch (m_format)
106  {
107  case RESULT_FORMAT_NEC:
108  os << s;
109  break;
110 
111  default:
112  break;
113  }
114  }
115 
116  void center_text(const std::string& text, const string& border)
117  {
118  size_t len = text.length() + 2*(border.length() + 1);
119  size_t offset = 40 - len/2;
120  for (size_t i=0;i<offset;i++)
121  os << " ";
122  os << border << " " << text << " " << border << endl;
123  }
124 
125  inline void section_start(const std::string& section_name)
126  {
127  if (m_in_section)
128  section_end();
129 
130  switch (m_format)
131  {
132  case RESULT_FORMAT_NEC:
133  os << endl << endl << endl;
134  center_text(section_name, "-----");
135  break;
136 
137  case RESULT_FORMAT_XML:
138  os << "<section name=\"" << section_name << "\">" << endl;
139  break;
140 
141  default:
142  os << endl << endl << endl;
143  break;
144  }
145  m_in_section = true;
146  }
147 
148  inline void section_end()
149  {
150  m_in_section = false;
151 
152  switch (m_format)
153  {
154  case RESULT_FORMAT_NEC:
155  os << endl << endl << endl;
156  break;
157 
158  case RESULT_FORMAT_XML:
159  os << "</section>" << endl;
160  break;
161 
162  default:
163  os << endl << endl << endl;
164  break;
165  }
166  }
167 
168  inline void int_out(int w, int i)
169  {
170  os << setw(w) << i;
171  }
172 
173  inline void string_out(int w, const std::string& s)
174  {
175  os << right << setw(w) << s;
176  }
177  inline void string_out(int w, const char* s)
178  {
179  os << right << setw(w) << s;
180  }
181 
182  inline void real_out(int w, int p, nec_float f, bool sci = true)
183  {
184  ios::fmtflags flags = ios::showpoint | ios::uppercase | ios::right;
185  if (sci)
186  flags |= ios::scientific;
187  else
188  flags |= ios::fixed;
189 
190  os.unsetf(ios::adjustfield | ios::basefield | ios::floatfield);
191  os.setf(flags);
192  os.precision(p);
193  os.width(w);
194  os << f;
195  }
196 
197  inline void complex_out(int w, int p, nec_complex c, bool sci = true)
198  {
199  real_out(w,p,real(c),sci);
200  separator();
201  real_out(w,p,imag(c),sci);
202  }
203 
204  inline void polar_out(int w, int p, nec_complex c, bool sci = true)
205  {
206  real_out(w,p,abs(c),sci);
207  separator();
208  real_out(w,p,arg_degrees(c),sci);
209  }
210 
211 };
212 
213 
216 enum nec_result_type {
217  RESULT_NORMALIZED_RECEIVING_PATTERN = 1,
218  RESULT_STRUCTURE_EXCITATION = 2,
219  RESULT_ANTENNA_INPUT = 3,
220  RESULT_RADIATION_PATTERN = 4,
221  RESULT_NEAR_FIELD_PATTERN = 5,
222  RESULT_STRUCTURE_CURRENTS = 6
223 };
224 
230 class nec_base_result {
231 private:
232  bool _write_file;
233  nec_float _frequency;
234 
235 protected:
236  enum RESULT_FORMAT _result_format;
237 
238 public:
239  virtual void write_to_file(ostream& os) = 0;
240  virtual enum nec_result_type get_result_type() = 0;
241 
242  nec_base_result()
243  : _write_file(true), _result_format(RESULT_FORMAT_NEC)
244  {
245  }
246 
247  virtual ~nec_base_result() {
248  }
249 
250  inline bool write_file() const {
251  return _write_file;
252  }
253 
254  inline void set_write_file(bool f) {
255  _write_file = f;
256  }
257 
258  inline void set_frequency(nec_float f) {
259  _frequency = f;
260  }
261 
262  nec_float get_frequency() {
263  return _frequency;
264  }
265 
266  inline void set_result_format(enum RESULT_FORMAT f) {
267  _result_format = f;
268  }
269 };
270 
271 
274 class nec_norm_rx_pattern : public nec_base_result
275 {
276  // Receiving Pattern
277  nec_float _eta, _axial_ratio;
278  int _segment_number;
279  string _type;
280 
281  long n_theta;
282  long n_phi;
283  nec_float _theta0, _theta_step;
284  nec_float _phi0, _phi_step;
285 
286  real_array _mag;
287 
288 public:
289  nec_norm_rx_pattern(
290  int in_n_theta, int in_n_phi,
291  real_matrix& in_mag,
292  nec_float theta0, nec_float theta_step,
293  nec_float phi0, nec_float phi_step,
294  nec_float in_eta,
295  nec_float in_axial_ratio,
296  int in_segment_number,
297  string in_type)
298  {
299  n_theta = in_n_theta;
300  n_phi = in_n_phi;
301 
302  _mag = in_mag;
303  _mag.resize(n_theta, n_phi);
304 
305  _theta0 = theta0;
306  _theta_step = theta_step;
307 
308  _phi0 = phi0;
309  _phi_step = phi_step;
310 
311  _eta = in_eta;
312  _axial_ratio = in_axial_ratio;
313  _segment_number = in_segment_number;
314  _type = in_type;
315 
316  _mag.resize(n_theta, n_phi);
317  }
318 
319  virtual ~nec_norm_rx_pattern() {
320  }
321 
322  virtual enum nec_result_type get_result_type() {
323  return RESULT_NORMALIZED_RECEIVING_PATTERN;
324  }
325 
326  void set_input(int theta_index, int phi_index, nec_float mag) {
327  _mag(theta_index,phi_index) = mag;
328  }
329 
330 
331  /*Added for the python wrapping : some basic access functions...*/
332 
333  int get_n_theta() {
334  return n_theta;
335  }
336 
337  int get_n_phi() {
338  return n_phi;
339  }
340 
341  nec_float get_theta_start() {
342  return _theta0;
343  }
344 
345  nec_float get_phi_start() {
346  return _phi0;
347  }
348 
349  nec_float get_delta_theta() {
350  return _theta_step;
351  }
352 
353  nec_float get_delta_phi() {
354  return _phi_step;
355  }
356 
357  nec_float get_eta() {
358  return _eta;
359  }
360 
361  nec_float get_axial_ratio() {
362  return _axial_ratio;
363  }
364 
365  int get_segment_number() {
366  return _segment_number;
367  }
368 
369  string get_type() {
370  return _type;
371  }
372 
373  real_array get_mag() {
374  return _mag;
375  }
376 
377  /*End of access functions added for the wrapping*/
378 
379  nec_float get_mag(int theta_index, int phi_index) {
380  return _mag(theta_index, phi_index);
381  }
382 
383  nec_float get_norm_factor() {
384  return _mag.maxCoeff();
385  }
386 
387  virtual void write_to_file(ostream& os) {
388  if (n_theta == 0)
389  return;
390  if (n_phi == 0)
391  return;
392 
393  nec_float norm_factor = get_norm_factor();
394 
395  output_helper oh(os,_result_format);
396 
397  oh.section_start("NORMALIZED RECEIVING PATTERN");
398  os << " NORMALIZATION FACTOR: ";oh.real_out(11,4,norm_factor);os << endl;
399  os << " ETA: ";oh.real_out(7,2,_eta,false); os << " DEGREES" << endl;
400  os << " TYPE: " << _type << endl;
401  os << " AXIAL RATIO: "; oh.real_out(6,3,_axial_ratio,false); os << endl;
402  os << " SEGMENT No: ";oh.int_out( 5, _segment_number); os << endl << endl;
403  os << " THETA PHI ---- PATTERN ----" << endl;
404  os << " (DEG) (DEG) DB MAGNITUDE" << endl;
405 
406  nec_float theta = _theta0;
407 
408  for (int t=0; t<n_theta; t++) {
409  nec_float phi = _phi0;
410 
411  for (int p=0; p<n_phi;p++) {
412  nec_float magnitude = _mag(t,p) / norm_factor;
413  nec_float gain = db20(magnitude);
414 
415  oh.start_record();
416  oh.padding(" ");
417  oh.real_out(7,2, theta, false); oh.separator();
418  oh.real_out(7,2, phi, false); oh.separator();
419  oh.padding(" "); oh.real_out(7,2, gain, false); oh.separator();
420  oh.padding(" "); oh.real_out(11,4, magnitude);
421  oh.end_record();
422 
423  phi += _phi_step;
424  }
425  theta += _theta_step;
426  }
427  }
428 };
429 
430 /* No more used...*/
431 
432 class structure_excitation_data
433 {
434 private:
435  int m_segment_number, m_segment_tag;
436  nec_complex m_voltage, m_current;
437  nec_float m_power;
438 
439 public:
440  structure_excitation_data(int segment_number, int segment_tag, nec_complex voltage, nec_complex current, nec_float power)
441  {
442  m_segment_number = segment_number;
443  m_segment_tag = segment_tag;
444  m_voltage = voltage;
445  m_current = current;
446  m_power = power;
447  }
448 
449  void write(output_helper& oh)
450  {
451  nec_complex admittance = m_current / m_voltage;
452  nec_complex impedance = m_voltage / m_current;
453 
454 /* o.nec_printf(" %4d %5d %11.4E %11.4E %11.4E %11.4E %11.4E %11.4E %11.4E %11.4E %11.4E",
455  segment_tag, m_segment_number, real(m_voltage), imag(m_voltage), real(m_current), imag(m_current),
456  real(impedance), imag(impedance), real(admittance), imag(admittance), m_power);
457 */
458  oh.start_record();
459  oh.int_out(4, m_segment_tag); oh.separator();
460  oh.int_out(5, m_segment_number); oh.separator();
461  oh.complex_out(11,4, m_voltage); oh.separator();
462  oh.complex_out(11,4, m_current); oh.separator();
463  oh.complex_out(11,4, impedance); oh.separator();
464  oh.complex_out(11,4, admittance); oh.separator();
465  oh.real_out(11,4, m_power);
466  oh.end_record();
467  }
468 };
469 
470 
471 
474 class nec_structure_excitation : public nec_base_result
475 {
476 private:
477  vector<int> _tag, _segment;
478  vector<nec_complex> _voltage, _current, _impedance, _admittance;
479  vector<nec_float> _power;
480  long n_items;
481  nec_complex voli, curi;
482 
483 public:
484 
485  nec_structure_excitation()
486  {
487  n_items = 0;
488  }
489 
490  virtual ~nec_structure_excitation() { }
491 
492 
493  virtual enum nec_result_type get_result_type()
494  {
495  return RESULT_STRUCTURE_EXCITATION;
496  }
497 
498  /*The two methods bellow have been modified to get rid of "nec_structure_excitation_data" */
499 
500  /*void add(int segment_number, int segment_tag, nec_complex voltage, nec_complex current, nec_float power)
501  {
502  structure_excitation_data sed(segment_number, segment_tag, voltage, current, power);
503  m_data.push_back(sed);
504  n_items++;
505  }
506 
507  virtual void write_to_file(ostream& os)
508  {
509  output_helper oh(os,_result_format);
510  oh.section_start();
511  os << " --------- STRUCTURE EXCITATION DATA AT NETWORK CONNECTION POINTS --------" << endl;
512  os << " TAG SEG VOLTAGE (VOLTS) CURRENT (AMPS) IMPEDANCE (OHMS) ADMITTANCE (MHOS) POWER" << endl;
513  os << " No: No: REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY (WATTS)" << endl;
514 
515  for (int i = 0; i < n_items; i++ )
516  {
517  m_data[i].write(oh);
518  }
519  }*/
520 
521  void add(int segment, int tag, nec_complex voltage, nec_complex current, nec_float power)
522  {
523  n_items++;
524  _tag.push_back(tag);
525  _segment.push_back(segment);
526  _voltage.push_back(voltage);
527  _current.push_back(current);
528  _impedance.push_back(voltage/current);
529  _admittance.push_back(current/voltage);
530  _power.push_back(power);
531 
532  }
533 
534  virtual void write_to_file(ostream& os)
535  {
536  output_helper oh(os,_result_format);
537  oh.section_start("STRUCTURE EXCITATION DATA AT NETWORK CONNECTION POINTS");
538  os << " TAG SEG VOLTAGE (VOLTS) CURRENT (AMPS) IMPEDANCE (OHMS) ADMITTANCE (MHOS) POWER" << endl;
539  os << " No: No: REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY (WATTS)" << endl;
540 
541  for (int i=0; i<n_items; i++)
542  {
543  oh.start_record();
544  oh.int_out(4, _tag[i]); oh.separator();
545  oh.int_out(5, _segment[i]); oh.separator();
546  oh.complex_out(11,4, _voltage[i]); oh.separator();
547  oh.complex_out(11,4, _current[i]); oh.separator();
548  oh.complex_out(11,4, _impedance[i]); oh.separator();
549  oh.complex_out(11,4, _admittance[i]); oh.separator();
550  oh.real_out(11,4, _power[i]);
551  oh.end_record();
552  }
553  }
554 
555  /*Added for the python wrapping : some basic access functions...*/
556 
557  vector<int> get_tag()
558  {
559  return _tag;
560  }
561 
562  vector<int> get_segment()
563  {
564  return _segment;
565  }
566 
567  vector<nec_complex> get_current()
568  {
569  return _current;
570  }
571 
572  vector<nec_complex> get_voltage()
573  {
574  return _voltage;
575  }
576 
577  vector<nec_float> get_power()
578  {
579  return _power;
580  }
581 
582  /*End of access functions added for the wrapping*/
583 
584 };
585 
588 class nec_antenna_input : public nec_base_result
589 {
590  // Antenna Input Parameters
591  vector<int> _tag, _segment;
592  vector<nec_float> _power;
593  vector<nec_complex> _voltage, _current, _impedance, _admittance;
594  long n_items;
595 
596 public:
597  nec_antenna_input()
598  {
599  n_items = 0;
600  }
601 
602  virtual ~nec_antenna_input()
603  {
604  }
605 
606  virtual enum nec_result_type get_result_type()
607  {
608  return RESULT_ANTENNA_INPUT;
609  }
610 
611  void set_input(int tag, int segment, nec_complex voltage, nec_complex current, nec_complex impedance, nec_complex admittance, nec_float power);
612 
613  virtual void write_to_file(ostream& os)
614  {
615  if (n_items == 0)
616  return;
617 
618  output_helper oh(os,_result_format);
619  oh.section_start("ANTENNA INPUT PARAMETERS");
620  os << " TAG SEG VOLTAGE (VOLTS) CURRENT (AMPS) IMPEDANCE (OHMS) ADMITTANCE (MHOS) POWER" << endl;
621  os << " NO. NO. REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY REAL IMAGINARY (WATTS)" << endl;
622  for (int i=0; i<n_items; i++)
623  {
624  oh.start_record();
625  oh.int_out(4, _tag[i]); oh.separator();
626  oh.int_out(5, _segment[i]); oh.separator();
627  oh.complex_out(11,4, _voltage[i]); oh.separator();
628  oh.complex_out(11,4, _current[i]); oh.separator();
629  oh.complex_out(11,4, _impedance[i]); oh.separator();
630  oh.complex_out(11,4, _admittance[i]); oh.separator();
631  oh.real_out(11,4, _power[i]);
632  oh.end_record();
633  }
634  }
635 
636  /*Added for the python wrapping : some basic access functions...*/
637 
638  vector<int> get_tag()
639  {
640  return _tag;
641  }
642 
643  vector<int> get_segment()
644  {
645  return _segment;
646  }
647 
648  vector<nec_complex> get_current()
649  {
650  return _current;
651  }
652 
653  vector<nec_complex> get_voltage()
654  {
655  return _voltage;
656  }
657 
658  vector<nec_complex>& get_impedance();
659 
660  vector<nec_float> get_power()
661  {
662  return _power;
663  }
664 
665  /*End of access functions added for the wrapping*/
666 
667 
668 };
669 
670 
671 class nec_near_field_pattern : public nec_base_result
672 {
673 private:
674  /*Near field pattern*/
675  int nfeh;
676  vector<nec_float> _x, _y, _z;
677  vector<nec_complex> _field_x, _field_y, _field_z;
678  long n_items;
679 
680 public:
681  nec_near_field_pattern(int in_nfeh)
682  {
683  nfeh = in_nfeh;
684  n_items = 0;
685  }
686 
687  virtual ~nec_near_field_pattern()
688  {
689  }
690 
691  virtual enum nec_result_type get_result_type()
692  {
693  return RESULT_NEAR_FIELD_PATTERN;
694  }
695 
696  void set_input(nec_float x, nec_float y, nec_float z, nec_complex field_x, nec_complex field_y, nec_complex field_z);
697 
698  virtual void write_to_file(ostream& os)
699  {
700  if (n_items == 0)
701  return;
702 
703  output_helper oh(os,_result_format);
704 
705  if ( nfeh != 1)
706  {
707  oh.section_start("NEAR ELECTRIC FIELDS");
708  os << " ------- LOCATION ------- ------- EX ------ ------- EY ------ ------- EZ ------" << endl;
709  os << " X Y Z MAGNITUDE PHASE MAGNITUDE PHASE MAGNITUDE PHASE" << endl;
710  os << " METERS METERS METERS VOLTS/M DEGREES VOLTS/M DEGREES VOLTS/M DEGREES" << endl;
711  }
712  else
713  {
714  oh.section_start("NEAR MAGNETIC FIELDS");
715  os << " ------- LOCATION ------- ------- HX ------ ------- HY ------ ------- HZ ------" << endl;
716  os << " X Y Z MAGNITUDE PHASE MAGNITUDE PHASE MAGNITUDE PHASE" << endl;
717  os << " METERS METERS METERS AMPS/M DEGREES AMPS/M DEGREES AMPS/M DEGREES" << endl;
718  }
719  for (int i=0; i<n_items; i++)
720  {
721  oh.start_record();
722  oh.padding(" ");
723  oh.real_out(9, 4, _x[i], false); oh.separator();
724  oh.real_out(9, 4, _y[i], false); oh.separator();
725  oh.real_out(9, 4, _z[i], false); oh.separator();
726  oh.padding(" ");
727  oh.real_out(11, 4, abs(_field_x[i]), true); oh.separator();
728  oh.real_out(7, 2, arg_degrees(_field_x[i]), false); oh.separator();
729  oh.padding(" ");
730  oh.real_out(11, 4, abs(_field_y[i]), true); oh.separator();
731  oh.real_out(7, 2, arg_degrees(_field_y[i]), false); oh.separator();
732  oh.padding(" ");
733  oh.real_out(11, 4, abs(_field_z[i]), true); oh.separator();
734  oh.real_out(7, 2, arg_degrees(_field_z[i]), false); oh.separator();
735  oh.end_record();
736  }
737  }
738 
739  /*Added for the python wrapping : some basic access functions...*/
740 
741  int get_nfeh()
742  {
743  return nfeh;
744  }
745 
746  vector<nec_float> get_x()
747  {
748  return _x;
749  }
750 
751  vector<nec_float> get_y()
752  {
753  return _y;
754  }
755 
756  vector<nec_float> get_z()
757  {
758  return _z;
759  }
760 
761  vector<nec_complex> get_field_x()
762  {
763  return _field_x;
764  }
765 
766  vector<nec_complex> get_field_y()
767  {
768  return _field_y;
769  }
770 
771  vector<nec_complex> get_field_z()
772  {
773  return _field_z;
774  }
775 
776  /*End of access functions added for the wrapping*/
777 };
778 
779 
780 class nec_radiation_pattern;
781 
782 class nec_structure_currents;
783 
797 class nec_results
798 {
799  vector<nec_base_result*> _results;
800  int _n;
801  bool _file_out;
802 
803 
804 public:
805  enum RESULT_FORMAT m_result_format;
806 
807  nec_results()
808  {
809  m_result_format = RESULT_FORMAT_NEC;
810 
811  _n = 0;
812  _file_out = false;
813  }
814 
815  // On destruction we write to a file.
816  ~nec_results()
817  {
818  // write_to_file();
819  for (int i=0;i<_n;i++)
820  {
821  delete _results[i];
822  _results[i] = NULL;
823  }
824  }
825 
826  void add(nec_base_result* br)
827  {
828  br->set_result_format(m_result_format);
829  _results.push_back(br);
830  _n++;
831  }
832 
839  nec_base_result* get_result(const long index, const enum nec_result_type result_type)
840  {
841  long counter = 0;
842 
843  for (int i=0;i<_n;i++)
844  {
845  if (_results[i]->get_result_type() == result_type)
846  {
847  if (index == counter++)
848  return _results[i];
849  }
850  }
851 
852  return NULL;
853  }
854 
860  nec_norm_rx_pattern* get_norm_rx_pattern(const long index)
861  {
862  return (nec_norm_rx_pattern*)get_result(index, RESULT_NORMALIZED_RECEIVING_PATTERN);
863  }
864 
870  nec_radiation_pattern* get_radiation_pattern(const long index)
871  {
872  return (nec_radiation_pattern*)get_result(index, RESULT_RADIATION_PATTERN);
873  }
874 
880  nec_antenna_input* get_antenna_input(const long index)
881  {
882  return (nec_antenna_input*)get_result(index, RESULT_ANTENNA_INPUT);
883  }
884 
890  nec_structure_excitation* get_structure_excitation(const long index)
891  {
892  return (nec_structure_excitation*)get_result(index, RESULT_STRUCTURE_EXCITATION);
893  }
894 
900  nec_near_field_pattern* get_near_field_pattern(const long index)
901  {
902  return (nec_near_field_pattern*)get_result(index, RESULT_NEAR_FIELD_PATTERN);
903  }
904 
910  nec_structure_currents* get_structure_currents(const long index)
911  {
912  return (nec_structure_currents*)get_result(index, RESULT_STRUCTURE_CURRENTS);
913  }
914 
915  void write(ostream& os)
916  {
917  for (int i=0;i<_n;i++)
918  {
919  if (_results[i]->write_file())
920  {
921  _results[i]->write_to_file(os);
922  _results[i]->set_write_file(false);
923  }
924  }
925  }
926 };
927 
928 #endif /* __nec_results__ */
929 
nec_results::get_near_field_pattern
nec_near_field_pattern * get_near_field_pattern(const long index)
Get near field pattern results.
Definition: nec_results.h:900
nec_results::get_radiation_pattern
nec_radiation_pattern * get_radiation_pattern(const long index)
Get radiation pattern results.
Definition: nec_results.h:870
nec_results::get_structure_excitation
nec_structure_excitation * get_structure_excitation(const long index)
Get structure excitation results.
Definition: nec_results.h:890
nec_results::get_norm_rx_pattern
nec_norm_rx_pattern * get_norm_rx_pattern(const long index)
Get normalized receiving pattern results.
Definition: nec_results.h:860
nec_structure_currents
Definition: nec_structure_currents.h:30
structure_excitation_data
Definition: nec_results.h:432
nec_results::get_structure_currents
nec_structure_currents * get_structure_currents(const long index)
Get structure currents results.
Definition: nec_results.h:910
safe_matrix< nec_float >
output_helper
A class that handles various standard output functions for the results.
Definition: nec_results.h:41
nec_results
Definition: nec_results.h:797
nec_results::get_antenna_input
nec_antenna_input * get_antenna_input(const long index)
Get antenna input parameter results.
Definition: nec_results.h:880
safe_array::maxCoeff
T maxCoeff() const
return the largest element of the array
Definition: safe_array.h:134
nec_near_field_pattern
Definition: nec_results.h:671
nec_norm_rx_pattern
Definition: nec_results.h:274
nec_radiation_pattern
Definition: nec_radiation_pattern.h:49
nec_results::get_result
nec_base_result * get_result(const long index, const enum nec_result_type result_type)
Get the nth result that matches the specified result type.
Definition: nec_results.h:839
segment
Definition: CurrentInput.h:26
safe_array< nec_float >
nec_structure_excitation
Holds structure excitation data at network connection points.
Definition: nec_results.h:474
nec_base_result
Definition: nec_results.h:230
nec_antenna_input
Definition: nec_results.h:588
Generated on Tue May 12 2015 13:30:45 for nec2++ by   doxygen 1.8.8