necpp 2.3.2__tar.gz → 2.3.4__tar.gz

{necpp-2.3.2/necpp.egg-info → necpp-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: necpp
-Version: 2.3.2
+Version: 2.3.4
 Summary: Python Antenna Simulation Module (nec2++) C-style interface
 Author-email: Tim Molteno <tim@physics.otago.ac.nz>
 License-Expression: GPL-3.0-only

{necpp-2.3.2 → necpp-2.3.4/necpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: necpp
-Version: 2.3.2
+Version: 2.3.4
 Summary: Python Antenna Simulation Module (nec2++) C-style interface
 Author-email: Tim Molteno <tim@physics.otago.ac.nz>
 License-Expression: GPL-3.0-only

{necpp-2.3.2 → necpp-2.3.4}/necpp.py

@@ -197,3 +197,9 @@ def nec_impedance_real(in_context, freq_index):
 def nec_impedance_imag(in_context, freq_index):
     return _necpp.nec_impedance_imag(in_context, freq_index)
 
+def nec_impedance_real_indexed(in_context, freq_index, feed_index):
+    return _necpp.nec_impedance_real_indexed(in_context, freq_index, feed_index)
+
+def nec_impedance_imag_indexed(in_context, freq_index, feed_index):
+    return _necpp.nec_impedance_imag_indexed(in_context, freq_index, feed_index)
+

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/c_geometry.cpp

@@ -1152,29 +1152,28 @@ void c_geometry::reflect_plane( int sym_plane, int& tag_increment )
 
   /* --- planar symmetry --- */
   /* sym_plane bits: 0 = negate X, 1 = negate Y, 2 = negate Z */
-  int mask = sym_plane;
-  bool neg_x = mask & 1;
-  bool neg_y = mask & 2;
-  bool neg_z = mask & 4;
-  int num_axes = (neg_x?1:0) + (neg_y?1:0) + (neg_z?1:0);
-  int num_copies = 1 << num_axes;   /* 2 for single axis, 4 for two axes */
-
   int64_t orig_n = n_segments;
   int64_t orig_m = m;
   int itx = tag_increment;
 
-  /* Axis priority: Z (bit 2) > Y (bit 1) > X (bit 0).
-     For two-axis combos, copy order is: original, axis1-neg, axis2-neg, both-neg.
-     Tag increments: +0, +itx, +2*itx, +3*itx. */
-  int axis1_mask = 0, axis2_mask = 0;
-  if ( neg_z ) { axis1_mask = 4; axis2_mask = neg_y ? 2 : (neg_x ? 1 : 0); }
-  else if ( neg_y ) { axis1_mask = 2; axis2_mask = neg_x ? 1 : 0; }
-  else if ( neg_x ) { axis1_mask = 1; }
+  /* Build copy masks in the Z, Y, X order used by sequential NEC-2
+     reflection passes. Each pass appends a reflected copy of every existing
+     combination. */
+  int copy_mask[8] = { 0 };
+  int num_copies = 1;
+
+  for ( int axis_mask = 4; axis_mask > 0; axis_mask >>= 1 )
+  {
+    if ( 0 == (sym_plane & axis_mask) )
+      continue;
 
-  int tag_inc[4] = { 0, itx, 2*itx, 3*itx };
+    for ( int copy = 0; copy < num_copies; copy++ )
+      copy_mask[num_copies + copy] = copy_mask[copy] | axis_mask;
+
+    num_copies *= 2;
+  }
 
-  /* Final tag_increment: X never doubles, Z and Y always double */
-  tag_increment = itx << ( (neg_z ? 1 : 0) + (neg_y ? 1 : 0) );
+  tag_increment = itx * num_copies;
 
   /* --- SEGMENTS --- */
   if ( orig_n > 0 )
@@ -1196,23 +1195,9 @@ void c_geometry::reflect_plane( int sym_plane, int& tag_increment )
     for( int copy = 1; copy < num_copies; copy++ )
     {
       /* Determine which axes to negate for this copy */
-      bool flip_x = false, flip_y = false, flip_z = false;
-      if ( copy == 1 )
-      {
-	if ( axis1_mask == 4 ) flip_z = true;
-	else if ( axis1_mask == 2 ) flip_y = true;
-	else if ( axis1_mask == 1 ) flip_x = true;
-      }
-      else if ( copy == 2 )
-      {
-	if ( axis2_mask == 4 ) flip_z = true;
-	else if ( axis2_mask == 2 ) flip_y = true;
-	else if ( axis2_mask == 1 ) flip_x = true;
-      }
-      else if ( copy == 3 )
-      {
-	flip_x = neg_x; flip_y = neg_y; flip_z = neg_z;
-      }
+      bool flip_x = (0 != (copy_mask[copy] & 1));
+      bool flip_y = (0 != (copy_mask[copy] & 2));
+      bool flip_z = (0 != (copy_mask[copy] & 4));
 
       int64_t base = copy * orig_n;
 
@@ -1269,7 +1254,7 @@ void c_geometry::reflect_plane( int sym_plane, int& tag_increment )
 	if ( itagi == 0 )
 	  segment_tags[nx] = 0;
 	if ( itagi != 0 )
-	  segment_tags[nx] = itagi + tag_inc[copy];
+	  segment_tags[nx] = itagi + copy * itx;
 
 	segment_radius[nx] = segment_radius[i];
       }
@@ -1298,23 +1283,9 @@ void c_geometry::reflect_plane( int sym_plane, int& tag_increment )
 
     for( int copy = 1; copy < num_copies; copy++ )
     {
-      bool flip_x = false, flip_y = false, flip_z = false;
-      if ( copy == 1 )
-      {
-	if ( axis1_mask == 4 ) flip_z = true;
-	else if ( axis1_mask == 2 ) flip_y = true;
-	else if ( axis1_mask == 1 ) flip_x = true;
-      }
-      else if ( copy == 2 )
-      {
-	if ( axis2_mask == 4 ) flip_z = true;
-	else if ( axis2_mask == 2 ) flip_y = true;
-	else if ( axis2_mask == 1 ) flip_x = true;
-      }
-      else if ( copy == 3 )
-      {
-	flip_x = neg_x; flip_y = neg_y; flip_z = neg_z;
-      }
+      bool flip_x = (0 != (copy_mask[copy] & 1));
+      bool flip_y = (0 != (copy_mask[copy] & 2));
+      bool flip_z = (0 != (copy_mask[copy] & 4));
 
       int neg_count = (flip_x?1:0) + (flip_y?1:0) + (flip_z?1:0);
       bool neg_psalp = (neg_count % 2 == 1);

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/c_geometry_tb.cpp

@@ -212,3 +212,64 @@ TEST_CASE( "NE card with multiple near-field points", "[near_field]") {
 
     nec_delete(nec);
 }
+
+TEST_CASE( "GX one-plane symmetry produces finite impedance", "[symmetry]") {
+    // PR #124: GX cards produced INF impedance due to uninitialized scratch
+    // slot in solves(), inverted fblock() guard, and incomplete reflection.
+    // One wire, GX 2 100 -> reflect in X, tag increment 2, NOP=2.
+    nec_context* nec = nec_create();
+
+    HANDLE_NEC(nec_wire(nec, 1, 11, -0.75, 0.0, -0.245, -0.75, 0.0, 0.245, 0.001, 1.0, 1.0));
+    HANDLE_NEC(nec_wire(nec, 2, 11, -0.25, 0.0, -0.245, -0.25, 0.0, 0.245, 0.001, 1.0, 1.0));
+    // GX: tag_inc=2, planes=100 -> X only (ix=1, iy=0, iz=0 -> nop=2)
+    HANDLE_NEC(nec_gx_card(nec, 2, 100));
+    HANDLE_NEC(nec_geometry_complete(nec, 0));
+    HANDLE_NEC(nec_fr_card(nec, 0, 1, 299.7925, 0.0));
+    // Feed all 4 tags (original + GX reflections) in natural order
+    HANDLE_NEC(nec_ex_card(nec, 0, 1, 6, 0, 1.0, 0.0, 0, 0, 0, 0));
+    HANDLE_NEC(nec_ex_card(nec, 0, 2, 6, 0, 1.0, 0.0, 0, 0, 0, 0));
+    HANDLE_NEC(nec_ex_card(nec, 0, 3, 6, 0, 1.0, 0.0, 0, 0, 0, 0));
+    HANDLE_NEC(nec_ex_card(nec, 0, 4, 6, 0, 1.0, 0.0, 0, 0, 0, 0));
+    HANDLE_NEC(nec_rp_card(nec, 0, 1, 361, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+
+    // Feed 0 (tag 1): 65.7 - j0.75 ohms
+    double zr = nec->get_impedance_real(0, 0);
+    double zi = nec->get_impedance_imag(0, 0);
+    REQUIRE( zr == Catch::Approx(65.7).margin(0.5) );
+    REQUIRE( zi == Catch::Approx(-0.75).margin(1.0) );
+
+    // Feed 1 (tag 2): 52.8 - j9.7 ohms
+    double zr1 = nec->get_impedance_real(0, 1);
+    double zi1 = nec->get_impedance_imag(0, 1);
+    REQUIRE( zr1 == Catch::Approx(52.8).margin(0.5) );
+    REQUIRE( zi1 == Catch::Approx(-9.7).margin(1.0) );
+
+    // Out-of-range feed index returns sentinel
+    double zr_bad = nec->get_impedance_real(0, 99);
+    REQUIRE( zr_bad == -999.0 );
+
+    nec_delete(nec);
+}
+
+TEST_CASE( "GX three-plane symmetry produces correct impedance", "[symmetry]") {
+    // PR #124: three-plane symmetry (nop=8) was broken — fblock() had wrong
+    // pass count, reflect_plane() missed copies 4-7. GX 1 111 -> all planes.
+    nec_context* nec = nec_create();
+
+    HANDLE_NEC(nec_wire(nec, 1, 9, 0.1, 0.1, 0.1, 0.1, 0.1, 0.35, 0.001, 1.0, 1.0));
+    // GX: tag_inc=1, planes=111 -> X,Y,Z (nop=8)
+    HANDLE_NEC(nec_gx_card(nec, 1, 111));
+    HANDLE_NEC(nec_geometry_complete(nec, 0));
+    HANDLE_NEC(nec_fr_card(nec, 0, 1, 299.8, 0.0));
+    HANDLE_NEC(nec_ex_card(nec, 0, 1, 5, 0, 1.0, 0.0, 0, 0, 0, 0));
+    HANDLE_NEC(nec_rp_card(nec, 0, 1, 361, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+
+    double zr = nec_impedance_real(nec, 0);
+    double zi = nec_impedance_imag(nec, 0);
+
+    // Tag 1 (only EX card): 13.7 - j470 ohms
+    REQUIRE( zr == Catch::Approx(13.7).margin(1.0) );
+    REQUIRE( zi == Catch::Approx(-470.5).margin(1.0) );
+
+    nec_delete(nec);
+}

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/libNEC.cpp

@@ -151,6 +151,13 @@ double nec_impedance_imag(nec_context* in_context, int freq_index) {
   return in_context->get_impedance_imag(freq_index);
 }
 
+double nec_impedance_real_indexed(nec_context* in_context, int freq_index, int feed_index) {
+  return in_context->get_impedance_real(freq_index, feed_index);
+}
+double nec_impedance_imag_indexed(nec_context* in_context, int freq_index, int feed_index) {
+  return in_context->get_impedance_imag(freq_index, feed_index);
+}
+
 long nec_medium_parameters(nec_context* in_context, double permittivity, double permeability) {
   NEC_ERROR_HANDLE(in_context->medium_parameters(permittivity, permeability));
 }

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/libnecpp.h

@@ -596,6 +596,15 @@ double nec_impedance_real(nec_context* in_context, int freq_index);
  */
 double nec_impedance_imag(nec_context* in_context, int freq_index);
 
+/*! \brief Impedance: Real Part for a specific feed.
+    \param feed_index  Zero-based feed index within the frequency.
+    \return Real impedance in ohms, or -999.0 if no result exists. */
+double nec_impedance_real_indexed(nec_context* in_context, int freq_index, int feed_index);
+
+/*! \brief Impedance: Imaginary Part for a specific feed.
+    \param feed_index  Zero-based feed index within the frequency. */
+double nec_impedance_imag_indexed(nec_context* in_context, int freq_index, int feed_index);
+
 ///@}
 
 #ifdef __cplusplus

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/matrix_algebra.cpp

@@ -398,7 +398,11 @@ void solves(complex_array& a, int_array& ip, complex_array& b, int64_t neq,
 
             /* transform matrix eq. rhs vector according to symmetry modes */
             for (int64_t i = 0; i < npeq; i++ ) {
-                nec_complex sum_normal(b[i+column_offset]);
+                /* Each image row below is seeded from this row's untransformed
+                   value, so hold it in scm[0] before the normalized sum
+                   overwrites b[i]. */
+                scm[0] = b[i+column_offset];
+                nec_complex sum_normal(scm[0]);
                 for (int64_t k = 1; k < nop; k++ ) {
                     int64_t ia= i+ k* npeq;
                     scm[k]= b[ia+column_offset];
@@ -441,7 +445,11 @@ void solves(complex_array& a, int_array& ip, complex_array& b, int64_t neq,
     for (int64_t ic = 0; ic < nrh; ic++ ) {
         int64_t column_offset = ic*neq;
         for (int64_t i = 0; i < npeq; i++ ) {
-            nec_complex sum_normal(b[i+column_offset]);
+            /* Each image row below is seeded from this row's untransformed
+               value, so hold it in scm[0] before the summed value overwrites
+               b[i]. */
+            scm[0] = b[i+column_offset];
+            nec_complex sum_normal(scm[0]);
             for (int64_t k = 1; k < nop; k++ ) {
                 int64_t ia= i+ k* npeq;
                 scm[k]= b[ia+column_offset];

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/nec_context.cpp

@@ -6439,14 +6439,17 @@ void nec_context::fblock( int nrow, int ncol, int64_t imax, int ipsym ) {
   int kk=1;
   symmetry_array[0]=cplx_10();
   
-  if ((2 == nop) || (4 == nop) || (8 == nop))
-      return;
-  int ka = nop / 2;
-  
-//   int k_power = 2;
-//   for( ka = 1; k_power != nop; ka++ )
-//     k_power *= 2;
-  
+  /* Plane symmetry admits two, four, or eight sections; the doubling below
+     cannot span the matrix for any other count. */
+  if ((2 != nop) && (4 != nop) && (8 != nop))
+      nec_stop("SYMMETRY ERROR - NOP: %d", nop );
+
+  /* Each pass doubles the width of the filled block, so the pass count is
+     log2(nop). */
+  int ka = 1;
+  for (int k_power = 2; k_power != nop; k_power *= 2)
+    ka++;
+
   for(int k = 0; k < ka; k++ )  {
     for(int i = 0; i < kk; i++ )  {
       for(int j = 0; j < kk; j++ )  {

{necpp-2.3.2 → necpp-2.3.4}/necpp_src/src/nec_context.h

@@ -208,21 +208,58 @@ public:
   }
   
   /****************** IMPEDANCE CHARACTERISTICS *********************/
-  
-  /*! \brief Impedance: Real Part */
-  double get_impedance_real(int freq_index = 0)  {
+
+  /*! \name Antenna Input Impedance
+   *
+   * Each call to nec_ex_card() or nec_fr_card() with a new frequency
+   * creates a feed.  Multiple feeds at the same frequency (e.g. phased
+   * arrays) are stored as separate entries within a single
+   * nec_antenna_input result; the \p feed_index selects among them.
+   *
+   * | Scenario                    | freq_index | feed_index |
+   * |-----------------------------|-----------|------------|
+   * | Single dipole               | 0         | 0          |
+   * | Two feeds, same frequency   | 0         | 0 or 1     |
+   * | Swept frequency, single feed| 0, 1, …   | 0          |
+   *
+   * If no result exists (no simulation run, missing feed, or
+   * out-of-range index) the sentinel value \c -999.0 is returned.
+   *
+   * Prior to v2.3.4 these methods returned imp.back() — the *last*
+   * feed's impedance — which depended on EX card ordering and was
+   * incorrect for multi-feed setups.  They now return imp[feed_index]
+   * with \p feed_index defaulting to 0 (the first feed).
+   *
+   * @{
+   */
+
+  /*! \brief Real part of the feed-point impedance.
+      \param freq_index Zero-based simulation index (0 = first frequency).
+      \param feed_index Zero-based feed index within that frequency
+                        (0 = first EX card at that frequency).
+      \return Resistance in ohms, or \c -999.0 if no result exists.
+      \see get_impedance_imag() */
+  double get_impedance_real(int freq_index = 0, int feed_index = 0)  {
           nec_antenna_input* ipt = get_input_parameters(freq_index);
           if (NULL == ipt) return -999.0;
           vector<nec_complex>& imp(ipt->get_impedance());
-          return imp.back().real();
+          if (feed_index < 0 || (size_t)feed_index >= imp.size()) return -999.0;
+          return imp[feed_index].real();
   }
-  /*! \brief Impedance: Imaginary Part */
-  double get_impedance_imag(int freq_index = 0)  {
+  /*! \brief Imaginary part of the feed-point impedance.
+      \param freq_index Zero-based simulation index (0 = first frequency).
+      \param feed_index Zero-based feed index within that frequency.
+      \return Reactance in ohms, or \c -999.0 if no result exists.
+      \see get_impedance_real() */
+  double get_impedance_imag(int freq_index = 0, int feed_index = 0)  {
           nec_antenna_input* ipt = get_input_parameters(freq_index);
           if (NULL == ipt) return -999.0;  
           vector<nec_complex>& imp(ipt->get_impedance());
-          return imp.back().imag();
+          if (feed_index < 0 || (size_t)feed_index >= imp.size()) return -999.0;
+          return imp[feed_index].imag();
   }
+
+  /*! @} */
           
   /*! \brief Get Antenna Input Parameter Results
   \param index The zero-based index for the result (simulations can return more than one set of results).

{necpp-2.3.2 → necpp-2.3.4}/necpp_wrap.c

@@ -5957,6 +5957,84 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_nec_impedance_real_indexed(PyObject *self, PyObject *args) {
+  PyObject *resultobj = 0;
+  nec_context *arg1 = (nec_context *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject *swig_obj[3] ;
+  double result;
+  
+  (void)self;
+  if (!SWIG_Python_UnpackTuple(args, "nec_impedance_real_indexed", 3, 3, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_nec_context, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nec_impedance_real_indexed" "', argument " "1"" of type '" "nec_context *""'"); 
+  }
+  arg1 = (nec_context *)(argp1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nec_impedance_real_indexed" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nec_impedance_real_indexed" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = (int)(val3);
+  result = (double)nec_impedance_real_indexed(arg1,arg2,arg3);
+  resultobj = SWIG_From_double((double)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_nec_impedance_imag_indexed(PyObject *self, PyObject *args) {
+  PyObject *resultobj = 0;
+  nec_context *arg1 = (nec_context *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject *swig_obj[3] ;
+  double result;
+  
+  (void)self;
+  if (!SWIG_Python_UnpackTuple(args, "nec_impedance_imag_indexed", 3, 3, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_nec_context, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nec_impedance_imag_indexed" "', argument " "1"" of type '" "nec_context *""'"); 
+  }
+  arg1 = (nec_context *)(argp1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nec_impedance_imag_indexed" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nec_impedance_imag_indexed" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = (int)(val3);
+  result = (double)nec_impedance_imag_indexed(arg1,arg2,arg3);
+  resultobj = SWIG_From_double((double)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 static PyMethodDef SwigMethods[] = {
 	 { "nec_create", _wrap_nec_create, METH_NOARGS, NULL},
 	 { "nec_delete", _wrap_nec_delete, METH_O, NULL},
@@ -6004,6 +6082,8 @@ static PyMethodDef SwigMethods[] = {
 	 { "nec_gain_lhcp_sd", _wrap_nec_gain_lhcp_sd, METH_VARARGS, NULL},
 	 { "nec_impedance_real", _wrap_nec_impedance_real, METH_VARARGS, NULL},
 	 { "nec_impedance_imag", _wrap_nec_impedance_imag, METH_VARARGS, NULL},
+	 { "nec_impedance_real_indexed", _wrap_nec_impedance_real_indexed, METH_VARARGS, NULL},
+	 { "nec_impedance_imag_indexed", _wrap_nec_impedance_imag_indexed, METH_VARARGS, NULL},
 	 { NULL, NULL, 0, NULL }
 };
 

{necpp-2.3.2 → necpp-2.3.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "necpp"
-version = "2.3.2"
+version = "2.3.4"
 description = "Python Antenna Simulation Module (nec2++) C-style interface"
 readme = "README.md"
 license = "GPL-3.0-only"

{necpp-2.3.2 → necpp-2.3.4}/setup.py

@@ -22,7 +22,7 @@ BUILD_DIR = "necpp_src/build"
 os.makedirs(BUILD_DIR, exist_ok=True)
 
 # Try to read the version from pyproject.toml; fall back to a known default.
-_version = "2.3.2"
+_version = "2.3.4"
 try:
     import tomllib  # Python 3.11+
 except ImportError: