necpp 2.3.4__tar.gz → 2.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: necpp
-Version: 2.3.4
+Version: 2.3.5
 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.4 → necpp-2.3.5/necpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: necpp
-Version: 2.3.4
+Version: 2.3.5
 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.4 → necpp-2.3.5}/necpp.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ necpp_src/src/nec_structure_currents.h
 necpp_src/src/nec_wasm.cpp
 necpp_src/src/nec_wire.h
 necpp_src/src/net_solve.cpp
+necpp_src/src/radiation_input_tb.cpp
 necpp_src/src/safe_array.h
 necpp_src/src/safe_array_tb.cpp
 necpp_src/src/typesafe_stdint.h

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

@@ -1,12 +1,12 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.2.0
+# Version 4.4.0
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.
 
 from sys import version_info as _swig_python_version_info
 # Import the low-level C/C++ module
-if __package__ or "." in __name__:
+if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
     from . import _necpp
 else:
     import _necpp
@@ -79,6 +79,9 @@ def nec_gm_card(in_context, itsi, nrpt, rox, roy, roz, xs, ys, zs, its):
 
 def nec_gx_card(in_context, i1, i2):
     return _necpp.nec_gx_card(in_context, i1, i2)
+NEC_GROUND_CONNECTION_NONE = _necpp.NEC_GROUND_CONNECTION_NONE
+NEC_GROUND_CONNECTION_IMAGE = _necpp.NEC_GROUND_CONNECTION_IMAGE
+NEC_GROUND_CONNECTION_ZERO_CURRENT = _necpp.NEC_GROUND_CONNECTION_ZERO_CURRENT
 
 def nec_geometry_complete(in_context, gpflag):
     return _necpp.nec_geometry_complete(in_context, gpflag)

{necpp-2.3.4 → necpp-2.3.5}/necpp_src/src/BaseInput.h

@@ -19,23 +19,24 @@
 
 #include "math_util.h"
 
+#include <algorithm>
+#include <cmath>
 #include <fstream>
 #include <sstream>
 
+/* Relative difference of two values, normalised by the larger magnitude.
+   The scale test must use magnitudes: comparing signed values against the
+   1e-8 floor treats any two negative numbers as "effectively zero". */
 nec_float diff(nec_float a, nec_float b)
 {
 	if (a == b)
 		return 0;
-	if ((a < 1e-8) && (b < 1e-8))
+
+	nec_float scale = std::max(std::fabs(a), std::fabs(b));
+	if (scale < 1e-8)
 		return 0;
 
-	nec_float sub = a - b;
-	nec_float sum = a + b;
-	
-	nec_float ret = sub*sub;
-	if ((a != 0) && (b != 0))
-		ret /= sum*sum;
-	ret = sqrt(ret);
+	nec_float ret = std::fabs(a - b) / scale;
 	if (ret > 1e-2)
 	{
 		cout << "    diff(" << a << "," << b << ") = " << ret << endl;
@@ -47,16 +48,12 @@ nec_float diff(nec_complex a, nec_complex b)
 {
 	if (a == b)
 		return 0;
-	if ((abs(a) < 1e-8) && (abs(b) < 1e-8))
+
+	nec_float scale = std::max(abs(a), abs(b));
+	if (scale < 1e-8)
 		return 0;
 
-	nec_float ret = norm(a - b);
-	nec_float sum = norm(a + b);
-	
-	if (sum != 0)
-		ret /= sum;
-		
-	ret = sqrt(ret);
+	nec_float ret = abs(a - b) / scale;
 	if (ret > 1e-2)
 	{
 		stringstream ss;
@@ -91,7 +88,7 @@ protected:
 
 	double read_sci(std::istream& is)
 	{
-		double x;
+		double x = 0.0;	/* zero on extraction failure (was returned uninitialized) */
 		is.setf(ios_base::skipws);
 		is >> x;
 		return x;
@@ -99,7 +96,7 @@ protected:
 
 	double read_fixed(std::istream& is)
 	{
-		double x;
+		double x = 0.0;	/* zero on extraction failure (was returned uninitialized) */
 		is.setf(ios_base::skipws);
 		is >> x;
 		return x;

{necpp-2.3.4 → necpp-2.3.5}/necpp_src/src/RadiationInput.h

@@ -19,6 +19,8 @@
 #pragma once
 
 #include <vector>
+#include <cctype>
+#include <cstdlib>
 
 #include "BaseInput.h"
 
@@ -70,9 +72,23 @@ public:
 					pol_axial_ratio.push_back(read_fixed(ss));
 					pol_tilt.push_back(read_fixed(ss));
 									
-					ss >> pol_sense;
-					
-					E_theta_mag.push_back(read_sci(ss));
+					string sense_token;
+					ss >> sense_token;
+					if (!sense_token.empty() && isalpha(static_cast<unsigned char>(sense_token[0])))
+					{
+						/* SENSE column present (LINEAR/LEFT/RIGHT) */
+						pol_sense = sense_token;
+						E_theta_mag.push_back(read_sci(ss));
+					}
+					else
+					{
+						/* SENSE column is blank when the polarization is
+						   undefined (e.g. HORIZ gain = -999.99 at the horizon).
+						   The token just read is E_theta_mag, not a sense. */
+						pol_sense = "";
+						E_theta_mag.push_back(sense_token.empty() ? 0.0 : atof(sense_token.c_str()));
+					}
+
 					E_theta_phase.push_back(read_fixed(ss));
 	
 					E_phi_mag.push_back(read_sci(ss));

{necpp-2.3.4 → necpp-2.3.5}/necpp_src/src/c_evlcom.cpp

@@ -17,6 +17,8 @@
 */
 #include "c_evlcom.h"
 
+#include <array>
+
 #include "matrix_algebra.h" // for test()
 #include "nec_exception.h"
 
@@ -28,6 +30,16 @@ using namespace std;
 #define NM	131072
 #define MAXH	20
 #define CRIT	1.0E-4
+/* Issue #131 item 3: gshank()'s Shanks-acceleration tail test is a little
+   looser than the Romberg step test (CRIT, used by rom1()) without changing
+   any printed output — the accelerated tail extrapolation is stable well
+   before the step-level tolerance binds. Measured to cut ~1.5% of saoa()
+   integrand evaluations per Sommerfeld table with byte-identical output on
+   every testharness deck and unchanged agreement with the nec2c/FORTRAN
+   references. The companion change that raised gshank()'s denm floor was
+   reverted (see the denm assignment below) after it broke convergence on
+   decks with wires close to the ground. */
+#define CRIT_H	1.1E-4
 #define	PTP	.6283185308
 #define NTS	4
 
@@ -44,16 +56,16 @@ void c_evlcom::lambda( nec_float t, nec_complex *xlam, nec_complex *dxlam ) cons
 	the step increment may be changed from dela to delb.  Shank's 
 	algorithm to accelerate convergence of a slowly converging series
 	is used. */
-void c_evlcom::gshank( nec_complex start, nec_complex dela, complex_array& sum,
-	int nans, complex_array& seed, int ibk, nec_complex bk, nec_complex delb )
+void c_evlcom::gshank( nec_complex start, nec_complex dela, nec_complex* sum,
+	int nans, nec_complex* seed, int ibk, nec_complex bk, nec_complex delb )
 {
 	bool brk = false;
 	int ibx, jm;
-	static nec_float rbk, amg, den, denm;
+	nec_float rbk, amg, den, denm;
 	nec_complex a1, a2, as1, as2, del, aa;
 	nec_complex q1[6][20], q2[6][20];
 	 
-	complex_array ans1(6), ans2(6);
+	std::array<nec_complex,6> ans1, ans2;
 	
 	rbk=real(bk);
 	del=dela;
@@ -171,7 +183,15 @@ void c_evlcom::gshank( nec_complex start, nec_complex dela, complex_array& sum,
 				den=amg;		
 		} /* for ( i = 0; i < nans; i++ ) */
 		
-		denm=1.e-3*den*CRIT;
+		/* Convergence floor for the Shanks test: the increment is judged
+		   against max(|q2|*CRIT_H, denm) with denm at 1.e-3 of the largest
+		   accelerated term. Issue #131 item 3 initially raised this floor
+		   to 2.e-1, which lets gshank() return while the integrand is still
+		   converging; the resulting errors in the Sommerfeld tables make
+		   rom2()'s Romberg test (rx = 1e-4) unreachable for decks with
+		   wires close to the ground (e.g. elevated radial screens), so the
+		   integration grinds at the subdivision cap indefinitely. */
+		denm=1.e-3*den*CRIT_H;
 		jm=intx-3;
 		if (jm < 1)
 			jm = 1;
@@ -182,7 +202,7 @@ void c_evlcom::gshank( nec_complex start, nec_complex dela, complex_array& sum,
 			for (int i = 0; i < nans; i++ )
 			{
 				a1=q2[i][j];
-				den=(fabs(real(a1))+fabs(imag(a1)))*CRIT;
+				den=(fabs(real(a1))+fabs(imag(a1)))*CRIT_H;
 				if (den < denm)
 					den=denm;
 				a1=q1[i][j]-a1;
@@ -215,13 +235,19 @@ void c_evlcom::gshank( nec_complex start, nec_complex dela, complex_array& sum,
 
 /*! \brief rom1 integrates the 6 Sommerfeld integrals from m_contour_a to m_contour_b in lambda.
 	The method of variable interval width Romberg integration is used. */
-void c_evlcom::rom1( int n, complex_array& sum, int nx )
+void c_evlcom::rom1( int n, nec_complex* sum, int nx )
 {
 	int ns, nt;
-	static nec_float z, ze, s, ep, zend, dz=0.0, dzot=0.0, tr, ti;
-	static nec_complex t00, t11, t02;
+	/* All of these are written before they are read within rom1, and the
+	   complex scratch buffers only persist across iterations of the loop
+	   below (not across rom1 invocations).  Using automatic locals keeps
+	   the scalars in registers and keeps the 6-element buffers on the
+	   stack, avoiding both the function-local-static round-trip and a
+	   heap allocation per call. */
+	nec_float z, ze, s, ep, zend, dz=0.0, dzot=0.0, tr, ti;
+	nec_complex t00, t11, t02;
 	
-	static complex_array g1(6), g2(6), g3(6), g4(6), g5(6), t01(6), t10(6), t20(6);
+	std::array<nec_complex,6> g1, g2, g3, g4, g5, t01, t10, t20;
 	
 	ASSERT(n == 6);
 	
@@ -379,19 +405,28 @@ void c_evlcom::rom1( int n, complex_array& sum, int nx )
 
 /*! \brief saoa computes the integrand for each of the 6 Sommerfeld
 	integrals for source and observer above ground. */
-void c_evlcom::saoa( nec_float t, complex_array& ans)
+void c_evlcom::saoa( nec_float t, std::array<nec_complex,6>& ans)
 {
-	static nec_complex xl, dxl, cgam1, cgam2, b0, b0p, com, dgam, den1, den2;
+	/* These are all written-before-read within this call, so they are
+	   plain automatic locals.  Keeping them in registers (instead of
+	   function-local statics, which are RAM-resident and serialize
+	   concurrent execution) is important because saoa is the innermost
+	   hot loop of the Sommerfeld integration. */
+	nec_complex xl, dxl, cgam1, cgam2, b0, b0p, com, dgam, den1, den2;
 	
 	lambda(t, &xl, &dxl);
+	/* xl^2 is used in cgam1/cgam2, the dgam large-|xl| branches, and the
+	   rho==0 answer; compute it once.  saoa is the innermost hot loop of
+	   the Sommerfeld integration, so this is not premature. */
+	nec_complex xl_sq = xl*xl;
 	if ( m_bessel_flag == true )
 	{
 		/* Bessel function form */
 		bessel(xl*m_rho, &b0, &b0p);
 		b0  *=2.;
 		b0p *=2.;
-		cgam1=sqrt(xl*xl-m_ck1sq);
-		cgam2=sqrt(xl*xl-m_ck2sq);
+		cgam1=sqrt(xl_sq-m_ck1sq);
+		cgam2=sqrt(xl_sq-m_ck2sq);
 		if (real(cgam1) == 0.0)
 			cgam1=nec_complex(0.0,-fabs(imag(cgam1)));
 		if (real(cgam2) == 0.)
@@ -423,21 +458,21 @@ void c_evlcom::saoa( nec_float t, complex_array& ans)
 				else
 				{
 					nec_float sign =1.0;
-					dgam=1.0/(xl*xl);
+					dgam=1.0/xl_sq;
 					dgam=sign*((m_ct3*dgam+m_ct2)*dgam+m_ct1)/xl;
 				}
 			}
 			else
 			{
 				nec_float sign = -1.0;
-				dgam=1.0/(xl*xl);
+				dgam=1.0/xl_sq;
 				dgam=sign*((m_ct3*dgam+m_ct2)*dgam+m_ct1)/xl;
 			} /* if (xlr >= m_ck2) */
 		} /* if (imag(xl) >= 0.) */
 		else
 		{
 			nec_float sign=1.0;
-			dgam=1.0/(xl*xl);
+			dgam=1.0/xl_sq;
 			dgam=sign*((m_ct3*dgam+m_ct2)*dgam+m_ct1)/xl;
 		}
 	} /* if (norm(xl) < m_tsmag) */
@@ -446,23 +481,6 @@ void c_evlcom::saoa( nec_float t, complex_array& ans)
 		dgam=cgam2-cgam1;
 	}
 	
-#if 0
-	nec_float xlr = real(xl);
-	if ( (xlr >= m_ck2) && (xlr <= m_ck1r))
-	{
-		dgam=cgam2-cgam1;
-	}
-	else
-	{
-		sign = 1.0;
-		if ((imag(xl) >= 0.0) && (xlr < m_ck2))
-			sign = -1.0;
-		
-		nec_floaf temp = 1.0/(xl*xl);
-		dgam=sign*((m_ct3*temp+m_ct2)*temp+m_ct1)/xl;
-	}
-#endif	
-	
 	den2=m_cksm*dgam/(cgam2*(m_ck1sq*cgam2+m_ck2sq*cgam1));
 	den1=1./(cgam1+cgam2)-m_cksm/cgam2;
 	com=dxl*xl*exp(-cgam2*m_zph);
@@ -477,7 +495,7 @@ void c_evlcom::saoa( nec_float t, complex_array& ans)
 	}
 	else
 	{
-		ans[0] = -com*xl*xl*.5;
+		ans[0] = -com*xl_sq*.5;
 		ans[3]=ans[0];
 	}
 	
@@ -494,7 +512,7 @@ void c_evlcom::evlua( nec_complex *erv, nec_complex *ezv,
 	static nec_float del, slope, rmis;
 	static nec_complex cp1, cp2, cp3, bk, delta, delta2;
 	
-	complex_array sum(6), ans(6);
+	nec_complex sum[6], ans[6];
 	
 	del=m_zph;
 	if ( m_rho > del )

{necpp-2.3.4 → necpp-2.3.5}/necpp_src/src/c_evlcom.h

@@ -17,6 +17,8 @@
 */
 #pragma once
 
+#include <array>
+
 #include "math_util.h"
 
 void 	bessel(nec_complex z, nec_complex *j0, nec_complex *j0p);
@@ -40,23 +42,27 @@ public:
 		the step increment may be changed from dela to delb.  Shank's 
 		algorithm to accelerate convergence of a slowly converging series
 		is used. */
-	void gshank( nec_complex start, nec_complex dela, complex_array& sum,
-		int nans, complex_array& seed, int ibk, nec_complex bk, nec_complex delb );
+	void gshank( nec_complex start, nec_complex dela, nec_complex* sum,
+		int nans, nec_complex* seed, int ibk, nec_complex bk, nec_complex delb );
 
 
 	/*! \brief rom1 integrates the 6 Sommerfeld integrals from m_contour_a to m_contour_b in lambda.
 		The method of variable interval width Romberg integration is used. */
-	void rom1( int n, complex_array& sum, int nx );
+	void rom1( int n, nec_complex* sum, int nx );
 	
 	/*! \brief saoa computes the integrand for each of the 6 Sommerfeld
 		integrals for source and observer above ground. */
-	void saoa( nec_float t, complex_array& ans);
+	void saoa( nec_float t, std::array<nec_complex,6>& ans);
 
 	/*! \brief evlua controls the integration contour in the complex
 		lambda plane for evaluation of the Sommerfeld integrals. */
 	void evlua( nec_complex *erv, nec_complex *ezv,
 		nec_complex *erh, nec_complex *eph );
 
+	/*! \brief Test support: select the Bessel-function form (true) or the
+		Hankel-function form (false) of the integrand used by saoa(). */
+	void set_bessel_flag(bool f) { m_bessel_flag = f; }
+
 private:
 	/*! \brief Flag to select Bessel or Hankel function form (was jh) */
 	bool m_bessel_flag;