simudo 0.7.0.0__py3-none-any.whl

simudo/__init__.py

@@ -0,0 +1,20 @@
+# The try/except lets `pip install --no-deps simudo` provide the GUI files on a machine with no working Simudo/FEniCS install.
+from .version import __version__
+
+try:
+    from .util.ufl_import_hack import fix as _fix
+except ImportError:
+    # The numerical stack is absent. That is a legitimate install: the
+    # graphical interface is served from simudo/gui/ and never imports simudo,
+    # so a host machine may install this package with --no-deps purely to have
+    # the files. Let `import simudo` succeed there.
+    #
+    # The dolfin check keeps that narrow. If FEniCS *is* present then the ufl
+    # aliasing fix is mandatory and skipping it would surface much later as a
+    # baffling UFL error, so a broken install still fails loudly here.
+    import importlib.util as _importlib_util
+
+    if _importlib_util.find_spec('dolfin') is not None:
+        raise
+else:
+    _fix()

simudo/example/fourlayer/IV_Analysis.py

@@ -0,0 +1,73 @@
+import numpy as np
+from scipy.interpolate import interp1d
+from scipy.interpolate import UnivariateSpline
+
+__all__ = ["IV_params"]
+
+# From Matt Wilkins
+
+
+def ordertest(A):
+    """Test if list ``A`` is strictly ascending."""
+    return all(A[k] <= A[k + 1] for k in range(len(A) - 1))
+
+
+class IV_params:
+    """
+Takes arrays of current and voltage, and interpolates Voc, Isc, and Pmax.
+
+``voc`` and ``isc`` are linearly interpolated, ``pmax`` is found
+with a spline fit.
+
+If v and i are in V and A respectively, then pmax is in W.
+
+If the the power quadrant has negative I (as for Simudo), use optional
+argument ``powersign=-1.0``.
+
+Example
+-------
+
+::
+
+    p = iv_params(current_array, voltage_array)
+    print(p.voc, p.isc, p.pmax, p.ff, p.mppv, p.mppi)
+    """
+
+    def __init__(self, i, v, powersign=1.0):
+        self.i = np.array(i)
+        self.v = np.array(v)
+        assert len(i) == len(v), "Unequal length arrays"
+        if ordertest(v) == False:
+            self.i = self.i[::-1]
+            self.v = self.v[::-1]
+        assert ordertest(
+            self.v
+        ), "Voltage array out of order, must be monotonic"
+        assert (
+            max(i) >= 0.0 and min(i) <= 0.0 and max(i) > min(i)
+        ), "Current array does not cross zero"
+        assert (
+            max(v) >= 0.0 and min(v) <= 0.0 and max(v) > min(v)
+        ), "Voltage array does not cross zero"
+
+        interp_i = interp1d(self.v, self.i, kind="linear")
+        self.isc = float(interp_i(0.0))
+
+        interp_v = interp1d(self.i, self.v, kind="linear", bounds_error=False)
+        self.voc = float(interp_v(0.0))
+
+        spline_P = UnivariateSpline(
+            self.v, powersign * self.i * self.v, k=4, s=0
+        )
+        dPdV = spline_P.derivative()
+        roots = dPdV.roots()
+        Pmax = -1e10
+        for k in range(len(roots)):
+            P = spline_P(roots[k])
+            if P > Pmax:
+                Pmax = P
+                self.mppv = roots[k]
+        self.mppi = interp_i(self.mppv)
+
+        self.pmax = spline_P(self.mppv)  # self.mppi*self.mppv
+        self.ff = self.pmax / (self.voc * self.isc)