Fix phasorplot legend handling, linewidth bugs, and bode improvements

Author: marcostfermin

electricpy/bode.py

@@ -22,9 +22,9 @@ def _sys_condition(system, feedback):
         num = system[0]
         den = system[1]
         # Convolve numerator or denominator as needed
-        if str(type(num)) == tuple:
+        if isinstance(num, tuple):
             num = convolve(num)  # Convolve terms in numerator
-        if str(type(den)) == tuple:
+        if isinstance(den, tuple):
             den = convolve(den)  # Convolve terms in denominator
         if feedback:  # If asked to add the numerator to the denominator
             ld = len(den)  # Length of denominator
@@ -99,11 +99,21 @@ def bode(system, mn=0.001, mx=1000, npts=100, title="", xlim=False, ylim=False,
 
     # Condition min and max freq terms
     degrees = False
-    if freqaxis.lower().find("deg") != -1:  # degrees requested
+    # Backwards-compatible: historically "deg" here behaved like "Hz"
+    if freqaxis.lower().find("hz") != -1 or freqaxis.lower().find("deg") != -1:
         degrees = True
-        # Scale Degrees to Radians for calculation
+        # Scale Hz to rad/sec for calculation
         mn = 2 * _np.pi * mn
         mx = 2 * _np.pi * mx
+
+    # Prevent invalid log10 values
+    if mn <= 0:
+        mn = 1e-12
+    if mx <= 0:
+        mx = 1e-12
+    if mx <= mn:
+        raise ValueError("mx must be greater than mn")
+
     mn = _np.log10(mn)  # find the _exponent value
     mx = _np.log10(mx)  # find the _exponent value
 
@@ -113,14 +123,14 @@ def bode(system, mn=0.001, mx=1000, npts=100, title="", xlim=False, ylim=False,
     # Calculate the bode system
     w, mag, ang = _sig.bode(system, wover)
 
-    def _plot(plot_title, y_label):
+    def _plot(plot_title, y_label, ydata):
         _plt.title(plot_title)
         _plt.ylabel(y_label)
-        if degrees:  # Plot in degrees
-            _plt.plot(w / (2 * _np.pi), ang)
+        if degrees:  # Plot in Hz
+            _plt.plot(w / (2 * _np.pi), ydata)
             _plt.xlabel("Frequency (Hz)")
         else:  # Plot in radians
-            _plt.plot(w, ang)
+            _plt.plot(w, ydata)
             _plt.xlabel("Frequency (rad/sec)")
         _plt.xscale("log")
         _plt.grid(which="both")
@@ -129,12 +139,12 @@ def _plot(plot_title, y_label):
         if ylim:
             _plt.ylim(ylim)
         if sv:
-            _plt.savefig(title + ".png")
+            _plt.savefig(plot_title + ".png")
 
     # Plot Magnitude
     if magnitude:
         magTitle = "Magnitude " + title
-        _plot(magTitle, "Magnitude (DB)")
+        _plot(magTitle, "Magnitude (DB)", mag)
         if disp3db:
             _plt.axhline(-3)
         if lowcut is not None:
@@ -144,7 +154,7 @@ def _plot(plot_title, y_label):
     # Plot Angle
     if angle:
         angTitle = "Angle " + title
-        _plot(angTitle, "Angle (degrees)")
+        _plot(angTitle, "Angle (degrees)", ang)
         _plt.show()
 
 
@@ -200,8 +210,14 @@ def sbode(f, NN=1000, title="", xlim=False, ylim=False, mn=0, mx=1000,
     angle:          bool, optional
                     Control argument to enable plotting of angle, default=True
     """
-    W = _np.linspace(mn, mx, NN)
-    H = _np.zeros(NN, dtype=_np.complex)
+    # Avoid log(0) on semilog plots
+    if mn <= 0:
+        mn_plot = 1e-12
+    else:
+        mn_plot = mn
+
+    W = _np.linspace(mn_plot, mx, NN)
+    H = _np.zeros(NN, dtype=complex)
 
     for n in range(0, NN):
         s = 1j * W[n]
@@ -278,17 +294,23 @@ def zbode(f, dt=0.01, NN=1000, title="", mn=0, mx=2 * _pi, xlim=False, ylim=Fals
     angle:          bool, optional
                     Control argument to enable plotting of angle, default=True
     """
-    phi = _np.linspace(mn, mx, NN)
+    # Avoid log(0) on semilog plots
+    if mn <= 0:
+        mn_plot = 1e-12
+    else:
+        mn_plot = mn
+
+    phi = _np.linspace(mn_plot, mx, NN)
 
-    H = _np.zeros(NN, dtype=_np.complex)
+    H = _np.zeros(NN, dtype=complex)
     for n in range(0, NN):
         z = _exp(1j * phi[n])
         if approx is not False and callable(approx):
             # Approximated Z-Domain
             s = approx(z, dt)  # Pass current z-value and dt
             H[n] = f(s)
         else:  # Z-Domain Transfer Function Provided
-            H[n] = dt * f(z)
+            H[n] = f(z)
 
     if magnitude:
         _plt.semilogx((180 / _pi) * phi, 20 * _np.log10(abs(H)), 'k')

electricpy/phasors.py

@@ -127,9 +127,18 @@ def phasorz(C=None, L=None, freq=60, complex=True):
     Z:      complex
             The ohmic impedance of either C or L (respectively).
     """
+    if (C is None) and (L is None):
+        raise ValueError("Either C or L must be provided.")
+    if (C is not None) and (L is not None):
+        raise ValueError("Provide only one of C or L, not both.")
     w = 2 * _np.pi * freq
+    if w == 0:
+        raise ValueError("freq must be non-zero.")
+
     # C Given in ohms, return as Z
     if C is not None:
+        if C == 0:
+            raise ValueError("C must be non-zero.")
         Z = -1 / (w * C)
     # L Given in ohms, return as Z
     if L is not None:
@@ -181,8 +190,6 @@ def phasorlist(arr):
     electricpy.phasors.vectarray:    Magnitude/Angle Array Pairing Function
     electricpy.phasors.phasorz:      Impedance Phasor Generator
     """
-    # Use List Comprehension to Process
-
     # Return Array
     return _np.array([phasor(i) for i in arr])
 
@@ -223,14 +230,10 @@ def vectarray(arr, degrees=True, flatarray=False):
     electricpy.phasors.phasor:       Phasor Generating Function
     electricpy.phasors.phasorlist:   Phasor Generator for List or Array
     """
-    # Iteratively Append Arrays to the Base
-
     def vector_cast(num):
         mag, ang = _c.polar(num)
-
         if degrees:
             ang = _np.degrees(ang)
-
         return [mag, ang]
 
     polararr = _np.array([vector_cast(num) for num in arr])
@@ -277,10 +280,13 @@ def phasordata(mn, mx=None, npts=1000, mag=1, ang=0, freq=60,
                 The resultant data array.
     """
     # Test Inputs for Min/Max
-    if mx == None:
+    if mx is None:
         # No Minimum provided, use Value as Maximum
         mx = mn
         mn = 0
+    npts = int(npts)
+    if npts <= 0:
+        raise ValueError("npts must be a positive integer.")
     # Generate Omega
     w = 2 * _np.pi * freq
     # Generate Time Array
@@ -313,7 +319,7 @@ def compose(*arr):
 
     - [ real, imag]
     - [ [ real1, ..., realn ], [ imag1, ..., imagn ] ]
-    - [ [ real1, imag1 ], ..., [ realn, imagn ] ]
+    - [ [ real1, imag1 ], ..., [ realn, imag2 ] ]
 
     Will always return values in form:
 
@@ -347,7 +353,7 @@ def compose(*arr):
             raise ValueError("Invalid Array Shape, must be 2xN or Nx2.")
         # Successfully Generated Array, Return
         return (retarr)
-    except:  # 1-Dimension Array
+    except Exception:  # 1-Dimension Array
         length = arr.size
         # Test for invalid Array Size
         if length != 2:
@@ -380,31 +386,33 @@ def parallelz(*args):
     Zp:     complex
             The calculated parallel impedance of the input tuple.
     """
-    # Gather length (number of elements in tuple)
-    L = len(args)
-    if L == 1:
-        Z = args[0]  # Only One Tuple Provided
-        try:
-            L = len(Z)
-            if L == 1:
-                Zp = Z[0]  # Only one impedance, burried in tuple
-            else:
-                # Inversely add the first two elements in tuple
-                Zp = (1 / Z[0] + 1 / Z[1]) ** (-1)
-                # If there are more than two elements, add them all inversely
-                if L > 2:
-                    for i in range(2, L):
-                        Zp = (1 / Zp + 1 / Z[i]) ** (-1)
-        except ValueError or IndexError:
-            Zp = Z  # Only one impedance
+    # Normalize input: allow parallelz([Z1,Z2,...]) or parallelz(Z1,Z2,...)
+    if len(args) == 0:
+        raise ValueError("At least one impedance must be provided.")
+    if len(args) == 1 and isinstance(args[0], (tuple, list, _np.ndarray)):
+        Z = args[0]
     else:
-        Z = args  # Set of Args acts as Tuple
-        # Inversely add the first two elements in tuple
-        Zp = (1 / Z[0] + 1 / Z[1]) ** (-1)
-        # If there are more than two elements, add them all inversely
-        if L > 2:
-            for i in range(2, L):
-                Zp = (1 / Zp + 1 / Z[i]) ** (-1)
+        Z = args
+
+    try:
+        L = len(Z)
+    except Exception:
+        return Z
+
+    if L == 0:
+        raise ValueError("At least one impedance must be provided.")
+    if L == 1:
+        return Z[0]
+
+    # Inverse-sum method with explicit zero checks
+    invsum = 0
+    for Zi in Z:
+        if Zi == 0:
+            raise ValueError("Impedance values must be non-zero for parallel combination.")
+        invsum += 1 / Zi
+    if invsum == 0:
+        raise ValueError("Invalid impedances: reciprocal sum evaluates to zero.")
+    Zp = 1 / invsum
     return Zp
 
 # END