PyNEC 1.7.3.4__tar.gz → 1.7.4__tar.gz

pynec-1.7.4/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: PyNEC
+Version: 1.7.4
+Summary: Python Antenna Simulation Module (nec2++) object-oriented interface
+Author-email: Tim Molteno <tim@physics.otago.ac.nz>
+License: GPLv3
+Project-URL: Homepage, http://github.com/tmolteno/python-necpp
+Project-URL: Repository, http://github.com/tmolteno/python-necpp
+Keywords: nec2,nec2++,antenna,electromagnetism,radio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Communications :: Ham Radio
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: numpy
+Dynamic: license-file
+
+# Python NEC2++ Module
+
+This module wraps the C++ API for antenna simulation of nec2++. It is easier to work with, and more powerful than the C-style API wrapper. Works with Python 2.7 and 3+.
+
+
+## Usage
+
+Here is an example that plots a radiation pattern.
+
+    from PyNEC import *
+    import numpy as np
+
+    #creation of a nec context
+    context=nec_context()
+
+    #get the associated geometry
+    geo = context.get_geometry()
+
+    #add wires to the geometry
+    geo.wire(0, 36, 0, 0, 0, -0.042, 0.008, 0.017, 0.001, 1.0, 1.0)
+    context.geometry_complete(0)
+
+    context.gn_card(-1, 0, 0, 0, 0, 0, 0, 0)
+
+    #add a "ex" card to specify an excitation
+    context.ex_card(1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0)
+
+    #add a "fr" card to specify the frequency 
+    context.fr_card(0, 2, 2400.0e6, 100.0e6)
+
+    #add a "rp" card to specify radiation pattern sampling parameters and to cause program execution
+    context.rp_card(0, 91, 1, 0, 5, 0, 0, 0.0, 45.0, 4.0, 2.0, 1.0, 0.0)
+
+    #get the radiation_pattern
+    rp = context.get_radiation_pattern(0)
+
+    # Gains are in decibels
+    gains_db = rp.get_gain()
+    gains = 10.0**(gains_db / 10.0)
+    thetas = rp.get_theta_angles() * 3.1415 / 180.0
+    phis = rp.get_phi_angles() * 3.1415 / 180.0
+
+
+    # Plot stuff
+    import matplotlib.pyplot as plt
+
+    ax = plt.subplot(111, polar=True)
+    ax.plot(thetas, gains[:,0], color='r', linewidth=3)
+    ax.grid(True)
+
+    ax.set_title("Gain at an elevation of 45 degrees", va='bottom')
+    plt.savefig('RadiationPattern.png')
+    plt.show()
+
+## Manual Build & install
+
+Requirements
+
+* [Swig](http://www.swig.org/download.html)
+* For Windows: [C/C++ compilers](https://wiki.python.org/moin/WindowsCompilers).
+* Git bash (for running build.sh script)
+* [uv](https://github.com/astral-sh/uv) (recommended) or pip + setuptools + numpy + wheel
+
+*Note: Download and extract swigwin.zip and add the path to swig.exe to environment.*
+
+Then do following:
+    
+        $ git clone --recursive https://github.com/tmolteno/python-necpp.git
+        $ cd python-necpp
+        $ cd PyNEC
+        $ ./build.sh
+        $ uv build               # Modern, fast build
+        $ uv pip install .       # Or: pip install .
+    
+*Note: 'sudo' is not required in windows.*
+    
+## Install from PyPI
+
+    $ sudo pip install pynec
+    
+*Note: 'sudo' is not required in windows.*
+
+## Testing
+
+Requirements
+
+* python package: matplotlib
+
+    $ python example/test_rp.py
+
+The example directory contains the following additional examples (that are inspired by excercises from a course on antennas):
+
+* logperiodic_opt.py is an example on how to combine PyNECPP with scipy.optimize to use a genetic algorithm to **optimize an antenna for multiple frequency bands** at the same time (which I thin is not possible in 4nec2). The resulting gains and VSWR are plotted over the frequency range of interest. This requires scipy >= 0.15.0 due to the usage of scipy.optimize.differential_evolution.
+* monopole_realistic_ground_plane.py plots the vertical gain pattern of a monopole antenna. Its dimensions are optimized with a local search, and the path through the search space is visualized with a heat map.
+* dipole.py does a very simple optimization of a dipole, and plots the VSWR over a given frequency range for different system impedances to file.
+
+

pynec-1.7.4/PyNEC.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: PyNEC
+Version: 1.7.4
+Summary: Python Antenna Simulation Module (nec2++) object-oriented interface
+Author-email: Tim Molteno <tim@physics.otago.ac.nz>
+License: GPLv3
+Project-URL: Homepage, http://github.com/tmolteno/python-necpp
+Project-URL: Repository, http://github.com/tmolteno/python-necpp
+Keywords: nec2,nec2++,antenna,electromagnetism,radio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Communications :: Ham Radio
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: numpy
+Dynamic: license-file
+
+# Python NEC2++ Module
+
+This module wraps the C++ API for antenna simulation of nec2++. It is easier to work with, and more powerful than the C-style API wrapper. Works with Python 2.7 and 3+.
+
+
+## Usage
+
+Here is an example that plots a radiation pattern.
+
+    from PyNEC import *
+    import numpy as np
+
+    #creation of a nec context
+    context=nec_context()
+
+    #get the associated geometry
+    geo = context.get_geometry()
+
+    #add wires to the geometry
+    geo.wire(0, 36, 0, 0, 0, -0.042, 0.008, 0.017, 0.001, 1.0, 1.0)
+    context.geometry_complete(0)
+
+    context.gn_card(-1, 0, 0, 0, 0, 0, 0, 0)
+
+    #add a "ex" card to specify an excitation
+    context.ex_card(1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0)
+
+    #add a "fr" card to specify the frequency 
+    context.fr_card(0, 2, 2400.0e6, 100.0e6)
+
+    #add a "rp" card to specify radiation pattern sampling parameters and to cause program execution
+    context.rp_card(0, 91, 1, 0, 5, 0, 0, 0.0, 45.0, 4.0, 2.0, 1.0, 0.0)
+
+    #get the radiation_pattern
+    rp = context.get_radiation_pattern(0)
+
+    # Gains are in decibels
+    gains_db = rp.get_gain()
+    gains = 10.0**(gains_db / 10.0)
+    thetas = rp.get_theta_angles() * 3.1415 / 180.0
+    phis = rp.get_phi_angles() * 3.1415 / 180.0
+
+
+    # Plot stuff
+    import matplotlib.pyplot as plt
+
+    ax = plt.subplot(111, polar=True)
+    ax.plot(thetas, gains[:,0], color='r', linewidth=3)
+    ax.grid(True)
+
+    ax.set_title("Gain at an elevation of 45 degrees", va='bottom')
+    plt.savefig('RadiationPattern.png')
+    plt.show()
+
+## Manual Build & install
+
+Requirements
+
+* [Swig](http://www.swig.org/download.html)
+* For Windows: [C/C++ compilers](https://wiki.python.org/moin/WindowsCompilers).
+* Git bash (for running build.sh script)
+* [uv](https://github.com/astral-sh/uv) (recommended) or pip + setuptools + numpy + wheel
+
+*Note: Download and extract swigwin.zip and add the path to swig.exe to environment.*
+
+Then do following:
+    
+        $ git clone --recursive https://github.com/tmolteno/python-necpp.git
+        $ cd python-necpp
+        $ cd PyNEC
+        $ ./build.sh
+        $ uv build               # Modern, fast build
+        $ uv pip install .       # Or: pip install .
+    
+*Note: 'sudo' is not required in windows.*
+    
+## Install from PyPI
+
+    $ sudo pip install pynec
+    
+*Note: 'sudo' is not required in windows.*
+
+## Testing
+
+Requirements
+
+* python package: matplotlib
+
+    $ python example/test_rp.py
+
+The example directory contains the following additional examples (that are inspired by excercises from a course on antennas):
+
+* logperiodic_opt.py is an example on how to combine PyNECPP with scipy.optimize to use a genetic algorithm to **optimize an antenna for multiple frequency bands** at the same time (which I thin is not possible in 4nec2). The resulting gains and VSWR are plotted over the frequency range of interest. This requires scipy >= 0.15.0 due to the usage of scipy.optimize.differential_evolution.
+* monopole_realistic_ground_plane.py plots the vertical gain pattern of a monopole antenna. Its dimensions are optimized with a local search, and the path through the search space is visualized with a heat map.
+* dipole.py does a very simple optimization of a dipole, and plots the VSWR over a given frequency range for different system impedances to file.
+
+

{PyNEC-1.7.3.4 → pynec-1.7.4}/PyNEC.egg-info/SOURCES.txt

@@ -3,10 +3,12 @@ MANIFEST.in
 PyNEC.py
 PyNEC_wrap.cxx
 README.md
+pyproject.toml
 setup.py
 PyNEC.egg-info/PKG-INFO
 PyNEC.egg-info/SOURCES.txt
 PyNEC.egg-info/dependency_links.txt
+PyNEC.egg-info/requires.txt
 PyNEC.egg-info/top_level.txt
 example/antenna_util.py
 example/context_clean.py
@@ -71,4 +73,6 @@ necpp_src/src/nec_structure_currents.cpp
 necpp_src/src/nec_structure_currents.h
 necpp_src/src/nec_wire.h
 necpp_src/src/safe_array.h
-necpp_src/src/typesafe_stdint.h
+necpp_src/src/typesafe_stdint.h
+tests/test_examples.py
+tests/test_get_gain.py

pynec-1.7.4/PyNEC.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

{PyNEC-1.7.3.4 → pynec-1.7.4}/PyNEC.py

@@ -1,119 +1,119 @@
-# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.12
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.2.0
 #
-# Do not make changes to this file unless you know what you are doing--modify
+# 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
-if _swig_python_version_info >= (2, 7, 0):
-    def swig_import_helper():
-        import importlib
-        pkg = __name__.rpartition('.')[0]
-        mname = '.'.join((pkg, '_PyNEC')).lstrip('.')
-        try:
-            return importlib.import_module(mname)
-        except ImportError:
-            return importlib.import_module('_PyNEC')
-    _PyNEC = swig_import_helper()
-    del swig_import_helper
-elif _swig_python_version_info >= (2, 6, 0):
-    def swig_import_helper():
-        from os.path import dirname
-        import imp
-        fp = None
-        try:
-            fp, pathname, description = imp.find_module('_PyNEC', [dirname(__file__)])
-        except ImportError:
-            import _PyNEC
-            return _PyNEC
-        try:
-            _mod = imp.load_module('_PyNEC', fp, pathname, description)
-        finally:
-            if fp is not None:
-                fp.close()
-        return _mod
-    _PyNEC = swig_import_helper()
-    del swig_import_helper
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _PyNEC
 else:
     import _PyNEC
-del _swig_python_version_info
-
-try:
-    _swig_property = property
-except NameError:
-    pass  # Python < 2.2 doesn't have 'property'.
 
 try:
     import builtins as __builtin__
 except ImportError:
     import __builtin__
 
-def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
-    if (name == "thisown"):
-        return self.this.own(value)
-    if (name == "this"):
-        if type(value).__name__ == 'SwigPyObject':
-            self.__dict__[name] = value
-            return
-    method = class_type.__swig_setmethods__.get(name, None)
-    if method:
-        return method(self, value)
-    if (not static):
-        if _newclass:
-            object.__setattr__(self, name, value)
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
         else:
-            self.__dict__[name] = value
-    else:
-        raise AttributeError("You cannot add attributes to %s" % self)
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
 
 
-def _swig_setattr(self, class_type, name, value):
-    return _swig_setattr_nondynamic(self, class_type, name, value, 0)
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
 
 
-def _swig_getattr(self, class_type, name):
-    if (name == "thisown"):
-        return self.this.own()
-    method = class_type.__swig_getmethods__.get(name, None)
-    if method:
-        return method(self)
-    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
 
 
-def _swig_repr(self):
-    try:
-        strthis = "proxy of " + self.this.__repr__()
-    except __builtin__.Exception:
-        strthis = ""
-    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
 
-try:
-    _object = object
-    _newclass = 1
-except __builtin__.Exception:
-    class _object:
-        pass
-    _newclass = 0
-
-class nec_context(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_context, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_context, name)
+
+class nec_context(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        this = _PyNEC.new_nec_context()
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
+        _PyNEC.nec_context_swiginit(self, _PyNEC.new_nec_context())
     __swig_destroy__ = _PyNEC.delete_nec_context
-    __del__ = lambda self: None
 
     def get_geometry(self):
         return _PyNEC.nec_context_get_geometry(self)
 
+    def get_gain(self, freq_index, theta_index, phi_index):
+        return _PyNEC.nec_context_get_gain(self, freq_index, theta_index, phi_index)
+
+    def get_gain_max(self, freq_index):
+        return _PyNEC.nec_context_get_gain_max(self, freq_index)
+
+    def get_gain_min(self, freq_index):
+        return _PyNEC.nec_context_get_gain_min(self, freq_index)
+
+    def get_gain_mean(self, freq_index):
+        return _PyNEC.nec_context_get_gain_mean(self, freq_index)
+
+    def get_gain_sd(self, freq_index):
+        return _PyNEC.nec_context_get_gain_sd(self, freq_index)
+
+    def get_gain_rhcp_max(self, freq_index):
+        return _PyNEC.nec_context_get_gain_rhcp_max(self, freq_index)
+
+    def get_gain_rhcp_min(self, freq_index):
+        return _PyNEC.nec_context_get_gain_rhcp_min(self, freq_index)
+
+    def get_gain_rhcp_mean(self, freq_index):
+        return _PyNEC.nec_context_get_gain_rhcp_mean(self, freq_index)
+
+    def get_gain_rhcp_sd(self, freq_index):
+        return _PyNEC.nec_context_get_gain_rhcp_sd(self, freq_index)
+
+    def get_gain_lhcp_max(self, freq_index):
+        return _PyNEC.nec_context_get_gain_lhcp_max(self, freq_index)
+
+    def get_gain_lhcp_min(self, freq_index):
+        return _PyNEC.nec_context_get_gain_lhcp_min(self, freq_index)
+
+    def get_gain_lhcp_mean(self, freq_index):
+        return _PyNEC.nec_context_get_gain_lhcp_mean(self, freq_index)
+
+    def get_gain_lhcp_sd(self, freq_index):
+        return _PyNEC.nec_context_get_gain_lhcp_sd(self, freq_index)
+
+    def get_impedance_real(self, freq_index):
+        return _PyNEC.nec_context_get_impedance_real(self, freq_index)
+
+    def get_impedance_imag(self, freq_index):
+        return _PyNEC.nec_context_get_impedance_imag(self, freq_index)
+
     def get_input_parameters(self, index):
         return _PyNEC.nec_context_get_input_parameters(self, index)
 
@@ -185,14 +185,11 @@ class nec_context(_object):
 
     def pl_card(self, ploutput_filename, itmp1, itmp2, itmp3, itmp4):
         return _PyNEC.nec_context_pl_card(self, ploutput_filename, itmp1, itmp2, itmp3, itmp4)
-nec_context_swigregister = _PyNEC.nec_context_swigregister
-nec_context_swigregister(nec_context)
-
-class c_geometry(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, c_geometry, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, c_geometry, name)
+
+# Register nec_context in _PyNEC:
+_PyNEC.nec_context_swigregister(nec_context)
+class c_geometry(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def wire(self, tag_id, segment_count, xw1, yw1, zw1, xw2, yw2, zw2, rad, rdel, rrad):
@@ -234,25 +231,17 @@ class c_geometry(_object):
     def quadrilateral_patch(self, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3, ax4, ay4, az4):
         return _PyNEC.c_geometry_quadrilateral_patch(self, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3, ax4, ay4, az4)
 
-    def multiple_patch(self, nx, ny, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3, ax4, ay4, az4):
-        return _PyNEC.c_geometry_multiple_patch(self, nx, ny, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3, ax4, ay4, az4)
+    def multiple_patch(self, nx, ny, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3):
+        return _PyNEC.c_geometry_multiple_patch(self, nx, ny, ax1, ay1, az1, ax2, ay2, az2, ax3, ay3, az3)
 
     def __init__(self):
-        this = _PyNEC.new_c_geometry()
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
+        _PyNEC.c_geometry_swiginit(self, _PyNEC.new_c_geometry())
     __swig_destroy__ = _PyNEC.delete_c_geometry
-    __del__ = lambda self: None
-c_geometry_swigregister = _PyNEC.c_geometry_swigregister
-c_geometry_swigregister(c_geometry)
 
-class nec_radiation_pattern(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_radiation_pattern, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_radiation_pattern, name)
+# Register c_geometry in _PyNEC:
+_PyNEC.c_geometry_swigregister(c_geometry)
+class nec_radiation_pattern(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -344,14 +333,11 @@ class nec_radiation_pattern(_object):
 
     def get_rp_ipd(self):
         return _PyNEC.nec_radiation_pattern_get_rp_ipd(self)
-nec_radiation_pattern_swigregister = _PyNEC.nec_radiation_pattern_swigregister
-nec_radiation_pattern_swigregister(nec_radiation_pattern)
 
-class nec_norm_rx_pattern(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_norm_rx_pattern, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_norm_rx_pattern, name)
+# Register nec_radiation_pattern in _PyNEC:
+_PyNEC.nec_radiation_pattern_swigregister(nec_radiation_pattern)
+class nec_norm_rx_pattern(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -395,14 +381,11 @@ class nec_norm_rx_pattern(_object):
 
     def get_mag(self):
         return _PyNEC.nec_norm_rx_pattern_get_mag(self)
-nec_norm_rx_pattern_swigregister = _PyNEC.nec_norm_rx_pattern_swigregister
-nec_norm_rx_pattern_swigregister(nec_norm_rx_pattern)
 
-class nec_structure_excitation(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_structure_excitation, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_structure_excitation, name)
+# Register nec_norm_rx_pattern in _PyNEC:
+_PyNEC.nec_norm_rx_pattern_swigregister(nec_norm_rx_pattern)
+class nec_structure_excitation(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -425,14 +408,11 @@ class nec_structure_excitation(_object):
 
     def get_power(self):
         return _PyNEC.nec_structure_excitation_get_power(self)
-nec_structure_excitation_swigregister = _PyNEC.nec_structure_excitation_swigregister
-nec_structure_excitation_swigregister(nec_structure_excitation)
 
-class nec_antenna_input(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_antenna_input, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_antenna_input, name)
+# Register nec_structure_excitation in _PyNEC:
+_PyNEC.nec_structure_excitation_swigregister(nec_structure_excitation)
+class nec_antenna_input(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -458,14 +438,11 @@ class nec_antenna_input(_object):
 
     def get_impedance(self):
         return _PyNEC.nec_antenna_input_get_impedance(self)
-nec_antenna_input_swigregister = _PyNEC.nec_antenna_input_swigregister
-nec_antenna_input_swigregister(nec_antenna_input)
 
-class nec_near_field_pattern(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_near_field_pattern, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_near_field_pattern, name)
+# Register nec_antenna_input in _PyNEC:
+_PyNEC.nec_antenna_input_swigregister(nec_antenna_input)
+class nec_near_field_pattern(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -494,14 +471,11 @@ class nec_near_field_pattern(_object):
 
     def get_field_z(self):
         return _PyNEC.nec_near_field_pattern_get_field_z(self)
-nec_near_field_pattern_swigregister = _PyNEC.nec_near_field_pattern_swigregister
-nec_near_field_pattern_swigregister(nec_near_field_pattern)
 
-class nec_structure_currents(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_structure_currents, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_structure_currents, name)
+# Register nec_near_field_pattern in _PyNEC:
+_PyNEC.nec_near_field_pattern_swigregister(nec_near_field_pattern)
+class nec_structure_currents(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -596,14 +570,11 @@ class nec_structure_currents(_object):
 
     def get_patch_e_z(self):
         return _PyNEC.nec_structure_currents_get_patch_e_z(self)
-nec_structure_currents_swigregister = _PyNEC.nec_structure_currents_swigregister
-nec_structure_currents_swigregister(nec_structure_currents)
 
-class nec_ground(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, nec_ground, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, nec_ground, name)
+# Register nec_structure_currents in _PyNEC:
+_PyNEC.nec_structure_currents_swigregister(nec_structure_currents)
+class nec_ground(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
     def __init__(self, *args, **kwargs):
         raise AttributeError("No constructor defined")
@@ -635,9 +606,7 @@ class nec_ground(_object):
 
     def get_conductivity2(self):
         return _PyNEC.nec_ground_get_conductivity2(self)
-nec_ground_swigregister = _PyNEC.nec_ground_swigregister
-nec_ground_swigregister(nec_ground)
-
-# This file is compatible with both classic and new-style classes.
 
+# Register nec_ground in _PyNEC:
+_PyNEC.nec_ground_swigregister(nec_ground)