acoular 25.7__py3-none-any.whl → 26.1__py3-none-any.whl

acoular/environments.py

@@ -4,6 +4,20 @@
 """
 Implements acoustic environments with and without flow.
 
+.. inheritance-diagram::
+                acoular.environments.Environment
+    :include-subclasses:
+    :top-classes:
+                acoular.environments.Environment
+    :parts: 1
+
+.. inheritance-diagram::
+                acoular.environments.FlowField
+    :include-subclasses:
+    :top-classes:
+                acoular.environments.FlowField
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -24,35 +38,10 @@ from abc import abstractmethod
 from warnings import warn
 
 import numba as nb
-from numpy import (
-    arange,
-    arccos,
-    arctan2,
-    array,
-    ascontiguousarray,
-    cos,
-    cross,
-    dot,
-    empty,
-    exp,
-    float32,
-    float64,
-    hstack,
-    identity,
-    isscalar,
-    matmul,
-    newaxis,
-    pi,
-    sign,
-    sin,
-    sqrt,
-    sum,  # noqa: A004
-    vstack,
-    zeros_like,
-)
+import numpy as np
+import scipy.linalg as spla
 from scipy.integrate import ode
 from scipy.interpolate import LinearNDInterpolator
-from scipy.linalg import norm
 from scipy.spatial import ConvexHull
 from traits.api import (
     ABCHasStrictTraits,
@@ -100,7 +89,7 @@ def dist_mat(gpos, mpos):  # pragma: no cover
     """
     _, M = mpos.shape
     _, N = gpos.shape
-    rm = empty((N, M), dtype=gpos.dtype)
+    rm = np.empty((N, M), dtype=gpos.dtype)
     TWO = rm.dtype.type(2.0)  # make sure to have a float32 or float 64 literal
     m0 = mpos[0]
     m1 = mpos[1]
@@ -110,7 +99,7 @@ def dist_mat(gpos, mpos):  # pragma: no cover
         g1 = gpos[1, n]
         g2 = gpos[2, n]
         for m in range(M):
-            rm[n, m] = sqrt((g0 - m0[m]) ** TWO + (g1 - m1[m]) ** TWO + (g2 - m2[m]) ** TWO)
+            rm[n, m] = np.sqrt((g0 - m0[m]) ** TWO + (g1 - m1[m]) ** TWO + (g2 - m2[m]) ** TWO)
     return rm
 
 
@@ -137,10 +126,10 @@ def cartToCyl(x, Q=None):  # noqa: N802, N803
         Cylindrical representation of given `N` points in cartesian coodrinates as
         an array of shape `(3, N)` with new coordinates :math:`(\phi, r, z)`.
     """
-    Q = identity(3) if Q is None else Q
-    if not (Q == identity(3)).all():  # noqa: SIM300
-        x = matmul(Q, x)  # modified position vector
-    return array([arctan2(x[1], x[0]), sqrt(x[0] ** 2 + x[1] ** 2), x[2]])
+    Q = np.identity(3) if Q is None else Q
+    if not (Q == np.identity(3)).all():  # noqa: SIM300
+        x = Q @ x  # modified position vector
+    return np.array([np.arctan2(x[1], x[0]), np.sqrt(x[0] ** 2 + x[1] ** 2), x[2]])
 
 
 def cylToCart(x, Q=None):  # noqa: N802, N803
@@ -166,10 +155,10 @@ def cylToCart(x, Q=None):  # noqa: N802, N803
         Cartesian representation of given `N` points in cylindrical coodrinates as
         an array of shape `(3, N)` with coodinates :math:`(x, y, z)`.
     """
-    Q = identity(3) if Q is None else Q
-    if not (Q == identity(3)).all():  # noqa: SIM300
-        x = matmul(Q, x)  # modified position vector
-    return array([x[1] * sin(x[0]), x[1] * cos(x[0]), x[2]])
+    Q = np.identity(3) if Q is None else Q
+    if not (Q == np.identity(3)).all():  # noqa: SIM300
+        x = Q @ x  # modified position vector
+    return np.array([x[1] * np.sin(x[0]), x[1] * np.cos(x[0]), x[2]])
 
 
 class Environment(HasStrictTraits):
@@ -193,7 +182,7 @@ class Environment(HasStrictTraits):
 
     #: The speed of sound in the environment. Default is ``343.0``, which corresponds to the
     #: approximate speed of sound at 20°C in dry air at sea level, if the unit is m/s.
-    c = Float(343.0, desc='speed of sound')
+    c = Float(343.0)
 
     #: The region of interest (ROI) for calculations. (Not needed for most types of environment.)
     #: Default is :obj:`None`.
@@ -231,12 +220,12 @@ class Environment(HasStrictTraits):
         #
         #         - shape `(N,)` if ``mpos`` is a single point, or
         #         - shape `(N, M)` if ``mpos`` consists of multiple points.
-        if isscalar(mpos):
-            mpos = array((0, 0, 0), dtype=float64)[:, newaxis]
-        rm = dist_mat(ascontiguousarray(gpos), ascontiguousarray(mpos))
-        #        mpos = mpos[:, newaxis, :]
-        #        rmv = gpos[:, :, newaxis]-mpos
-        #        rm = sum(rmv*rmv, 0)**0.5
+        if np.isscalar(mpos):
+            mpos = np.array((0, 0, 0), dtype=np.float64)[:, np.newaxis]
+        rm = dist_mat(np.ascontiguousarray(gpos), np.ascontiguousarray(mpos))
+        #        mpos = mpos[:, np.newaxis, :]
+        #        rmv = gpos[:, :, np.newaxis]-mpos
+        #        rm = np.sum(rmv*rmv, 0)**0.5
         if rm.shape[1] == 1:
             rm = rm[:, 0]
         return rm
@@ -261,11 +250,11 @@ class UniformFlowEnvironment(Environment):
 
     #: The Mach number of the flow, defined as the ratio of the flow velocity to the speed of sound.
     #: Default is ``0.0``, which corresponds to no flow.
-    ma = Float(0.0, desc='flow mach number')
+    ma = Float(0.0)
 
     #: A unit vector specifying the direction of the flow in 3D Cartesian coordinates.
     #: Default is ``(1.0, 0, 0)``, which corresponds to flow in the x-direction.
-    fdv = CArray(dtype=float64, shape=(3,), value=array((1.0, 0, 0)), desc='flow direction')
+    fdv = CArray(dtype=np.float64, shape=(3,), value=np.array((1.0, 0, 0)))
 
     #: A unique identifier based on the environment properties. (read-only)
     digest = Property(
@@ -301,14 +290,14 @@ class UniformFlowEnvironment(Environment):
         #
         #         - shape `(N,)` if ``mpos`` is a single point, or
         #         - shape `(N, M)` if ``mpos`` consists of multiple points.
-        if isscalar(mpos):
-            mpos = array((0, 0, 0), dtype=float32)[:, newaxis]
-        fdv = self.fdv / sqrt((self.fdv * self.fdv).sum())
-        mpos = mpos[:, newaxis, :]
-        rmv = gpos[:, :, newaxis] - mpos
-        rm = sqrt(sum(rmv * rmv, 0))
-        macostheta = (self.ma * sum(rmv.reshape((3, -1)) * fdv[:, newaxis], 0) / rm.reshape(-1)).reshape(rm.shape)
-        rm *= 1 / (-macostheta + sqrt(macostheta * macostheta - self.ma * self.ma + 1))
+        if np.isscalar(mpos):
+            mpos = np.array((0, 0, 0), dtype=np.float32)[:, np.newaxis]
+        fdv = self.fdv / np.sqrt((self.fdv * self.fdv).sum())
+        mpos = mpos[:, np.newaxis, :]
+        rmv = gpos[:, :, np.newaxis] - mpos
+        rm = np.sqrt(np.sum(rmv * rmv, 0))
+        macostheta = (self.ma * np.sum(rmv.reshape((3, -1)) * fdv[:, np.newaxis], 0) / rm.reshape(-1)).reshape(rm.shape)
+        rm *= 1 / (-macostheta + np.sqrt(macostheta * macostheta - self.ma * self.ma + 1))
         if rm.shape[1] == 1:
             rm = rm[:, 0]
         return rm
@@ -355,24 +344,24 @@ class SlotJet(FlowField):
     """
 
     #: Exit velocity at the :attr:`slot jet origin<origin>` (nozzle). Default is ``0.0``.
-    v0 = Float(0.0, desc='exit velocity')
+    v0 = Float(0.0)
 
     #: The location of the slot nozzle center. Default is ``(0.0, 0.0, 0.0)``.
-    origin = CArray(dtype=float64, shape=(3,), value=array((0.0, 0.0, 0.0)), desc='center of nozzle')
+    origin = CArray(dtype=np.float64, shape=(3,), value=np.array((0.0, 0.0, 0.0)))
 
     #: Unit vector representing the flow direction. Default is ``(1.0, 0.0, 0.0)``.
-    flow = CArray(dtype=float64, shape=(3,), value=array((1.0, 0.0, 0.0)), desc='flow direction')
+    flow = CArray(dtype=np.float64, shape=(3,), value=np.array((1.0, 0.0, 0.0)))
 
     #: Unit vector parallel to the slot center plane, used to define the slot orientation.
     #: Default is ``(0.0, 1.0, 0.0)``.
-    plane = CArray(dtype=float64, shape=(3,), value=array((0.0, 1.0, 0.0)), desc='slot center line direction')
+    plane = CArray(dtype=np.float64, shape=(3,), value=np.array((0.0, 1.0, 0.0)))
 
     #: Width of the slot (slot diameter). Default is ``0.2``.
-    B = Float(0.2, desc='nozzle diameter')
+    B = Float(0.2)
 
     #: Non-dimensional length of the zone of flow establishment (jet core length).
     #: Default is ``5.2``.
-    l = Float(5.2, desc='flow establishment length')  # noqa: E741
+    l = Float(5.2)  # noqa: E741
 
     #: A unique identifier based on the field properties. (read-only)
     digest = Property(
@@ -415,18 +404,18 @@ class SlotJet(FlowField):
           with respect to the spatial coordinates.
         """
         # normalize
-        flow = self.flow / norm(self.flow)
-        plane = self.plane / norm(self.plane)
+        flow = self.flow / spla.norm(self.flow)
+        plane = self.plane / spla.norm(self.plane)
         # additional axes of global coordinate system
-        yy = -cross(flow, plane)
-        zz = cross(flow, yy)
+        yy = -np.cross(flow, plane)
+        zz = np.cross(flow, yy)
         # distance from slot exit plane
         xx1 = xx - self.origin
         # local coordinate system
-        x = dot(flow, xx1)
-        y = dot(yy, xx1)
+        x = np.dot(flow, xx1)
+        y = np.dot(yy, xx1)
         x1 = 0.5668 / self.l * x  # C1 in Albertson1950
-        h1 = abs(y) + sqrt(pi) * 0.5 * x1 - 0.5 * self.B
+        h1 = abs(y) + np.sqrt(np.pi) * 0.5 * x1 - 0.5 * self.B
         if h1 < 0.0:
             # core jet
             Ux = self.v0
@@ -434,14 +423,14 @@ class SlotJet(FlowField):
             Udy = 0
         else:
             # shear layer
-            Ux = self.v0 * exp(-h1 * h1 / (2 * x1 * x1))
-            Udx = (h1 * h1 / (x * x1 * x1) - sqrt(pi) * 0.5 * h1 / (x * x1)) * Ux
-            Udy = -sign(y) * h1 * Ux / (x1 * x1)
+            Ux = self.v0 * np.exp(-h1 * h1 / (2 * x1 * x1))
+            Udx = (h1 * h1 / (x * x1 * x1) - np.sqrt(np.pi) * 0.5 * h1 / (x * x1)) * Ux
+            Udy = -np.sign(y) * h1 * Ux / (x1 * x1)
         # Jacobi matrix
-        dU = array(((Udx, 0, 0), (Udy, 0, 0), (0, 0, 0))).T
+        dU = np.array(((Udx, 0, 0), (Udy, 0, 0), (0, 0, 0))).T
         # rotation matrix
-        R = array((flow, yy, zz)).T
-        return dot(R, array((Ux, 0, 0))), dot(dot(R, dU), R.T)
+        R = np.array((flow, yy, zz)).T
+        return np.dot(R, np.array((Ux, 0, 0))), np.dot(np.dot(R, dU), R.T)
 
 
 class OpenJet(FlowField):
@@ -476,17 +465,17 @@ class OpenJet(FlowField):
     """
 
     #: Exit velocity at the jet origin (nozzle). Default is ``0.0``.
-    v0 = Float(0.0, desc='exit velocity')
+    v0 = Float(0.0)
 
     #: The location of the nozzle center. Default is ``(0.0, 0.0, 0.0)``.
-    origin = CArray(dtype=float64, shape=(3,), value=array((0.0, 0.0, 0.0)), desc='center of nozzle')
+    origin = CArray(dtype=np.float64, shape=(3,), value=np.array((0.0, 0.0, 0.0)))
 
     #: Diameter of the nozzle. Default is ``0.2``.
-    D = Float(0.2, desc='nozzle diameter')
+    D = Float(0.2)
 
     #: Non-dimensional length of the zone of flow establishment (jet core length).
     #: Default is ``6.2``. :cite:`Albertson1950`
-    l = Float(6.2, desc='flow establishment length')  # noqa: E741
+    l = Float(6.2)  # noqa: E741
 
     #: A unique identifier based on the field properties. (read-only)
     digest = Property(
@@ -530,10 +519,10 @@ class OpenJet(FlowField):
           to `y` and `z` are set to zero to avoid division by zero.
         """
         x, y, z = xx - self.origin
-        r = sqrt(y * y + z * z)
+        r = np.sqrt(y * y + z * z)
         x1 = 0.5022 / self.l * x  # C2 in Albertson1950
         h1 = r + x1 - 0.5 * self.D
-        U = self.v0 * exp(-h1 * h1 / (2 * x1 * x1))
+        U = self.v0 * np.exp(-h1 * h1 / (2 * x1 * x1))
         if h1 < 0.0:
             Udr = 0.0
             U = self.v0
@@ -549,9 +538,9 @@ class OpenJet(FlowField):
             Udx = 0
 
         # flow field
-        v = array((U, 0.0, 0.0))
+        v = np.array((U, 0.0, 0.0))
         # Jacobi matrix
-        dv = array(((Udx, 0.0, 0.0), (Udy, 0.0, 0.0), (Udz, 0.0, 0.0))).T
+        dv = np.array(((Udx, 0.0, 0.0), (Udy, 0.0, 0.0), (Udz, 0.0, 0.0))).T
         return v, dv
 
 
@@ -568,7 +557,7 @@ class RotatingFlow(FlowField):
     - The rotation is assumed to be about the z-axis. The velocity components in the x-y plane are
       determined by the angular velocity :attr:`omega`, while the z-component is constant
       and set by :attr:`v0`.
-    - The angular velocity :attr:`omega` is computed as: ``omega = 2 * pi * rps``,
+    - The angular velocity :attr:`omega` is computed as: ``omega = 2 * np.pi * rps``,
       with the :attr:`rps` given in revolutions per second (i.e. Hz).
 
     Examples
@@ -577,7 +566,7 @@ class RotatingFlow(FlowField):
     >>> import numpy as np
     >>>
     >>> flow = RotatingFlow(rps=1, v0=1.0)
-    >>> velocity, jacobian = flow.v(array((1.0, 1.0, 0.0)))
+    >>> velocity, jacobian = flow.v(np.array((1.0, 1.0, 0.0)))
     >>> velocity
     array([-6.28318531,  6.28318531,  1.        ])
     >>> jacobian
@@ -586,11 +575,11 @@ class RotatingFlow(FlowField):
            [ 0.        ,  0.        ,  0.        ]])
     """
 
-    # Revolutions per minute (RPM). Default is ``0.0``.
-    # Positive values indicate clockwise rotation of the flow.
-    # This is contrary to the usual definition of the direction of rotation.
-    # Deprecated! Please use the differently defined :attr:`rps` attribute instead.
-    rpm = Property(transient=True, desc='revolutions per minute of the flow; positive values for clockwise rotation')
+    #: Revolutions per minute (RPM). Default is ``0.0``.
+    #: Positive values indicate clockwise rotation of the flow.
+    #: This is contrary to the usual definition of the direction of rotation.
+    #: Deprecated! Please use the differently defined :attr:`rps` attribute instead.
+    rpm = Property(transient=True)
 
     def _get_rpm(self):
         warn(
@@ -612,14 +601,14 @@ class RotatingFlow(FlowField):
 
     #: Rotational speed in revolutions per second. Negative values indicate clockwise
     #: rigid-body-like rotation of the flow. Default is ``0.0``.
-    rps = Float(0.0, desc='rotational speed of the flow in Hz')
+    rps = Float(0.0)
 
     #: Constant flow velocity in the z-direction. Default is ``0.0``.
-    v0 = Float(0.0, desc='flow velocity')
+    v0 = Float(0.0)
 
     #: The location of the center of rotation.
     #: Default is ``(0.0, 0.0, 0.0)``.
-    origin = CArray(dtype=float64, shape=(3,), value=array((0.0, 0.0, 0.0)), desc='center of rotation')
+    origin = CArray(dtype=np.float64, shape=(3,), value=np.array((0.0, 0.0, 0.0)))
 
     #: A unique identifier based on the field properties. (read-only)
     digest = Property(
@@ -634,7 +623,7 @@ class RotatingFlow(FlowField):
 
     @cached_property
     def _get_omega(self):
-        return 2 * pi * self.rps
+        return 2 * np.pi * self.rps
 
     @cached_property
     def _get_digest(self):
@@ -682,13 +671,13 @@ class RotatingFlow(FlowField):
         W = self.v0
 
         # flow field
-        v = array((U, V, W))
+        v = np.array((U, V, W))
         # Jacobi matrix
-        dv = array(((0.0, omega, 0.0), (-omega, 0.0, 0.0), (0.0, 0.0, 0.0))).T
+        dv = np.array(((0.0, omega, 0.0), (-omega, 0.0, 0.0), (0.0, 0.0, 0.0))).T
         return v, dv
 
 
-def spiral_sphere(N, Om=None, b=None):  # noqa: N803 # change to 4*pi
+def spiral_sphere(N, Om=None, b=None):  # noqa: N803 # change to 4*np.pi
     """
     Generate unit vectors equally distributed over a sphere or a portion of it.
 
@@ -706,7 +695,7 @@ def spiral_sphere(N, Om=None, b=None):  # noqa: N803 # change to 4*pi
         The number of points to generate on the sphere.
 
     Om : :class:`float`, optional
-        The solid angle in steradians to cover on the sphere. Default is ``2 * pi``,
+        The solid angle in steradians to cover on the sphere. Default is ``2 * np.pi``,
         which corresponds to a hemisphere. Smaller values result in covering
         a smaller portion of the hemisphere.
 
@@ -743,37 +732,37 @@ def spiral_sphere(N, Om=None, b=None):  # noqa: N803 # change to 4*pi
     Generate 50 points over half a hemisphere with the z-axis as the center direction:
 
     >>> import numpy as np
-    >>> points = spiral_sphere(50, Om=np.pi, b=array((0, 0, 1)))
+    >>> points = spiral_sphere(50, Om=np.pi, b=np.array((0, 0, 1)))
     >>> points.shape
     (3, 50)
 
     Generate 200 points with a different direction vector:
 
-    >>> points = spiral_sphere(200, b=array((1, 0, 0)))
+    >>> points = spiral_sphere(200, b=np.array((1, 0, 0)))
     >>> points.shape
     (3, 200)
     """
-    Om = 2 * pi if Om is None else Om
-    b = array((0, 0, 1)) if b is None else b
+    Om = 2 * np.pi if Om is None else Om
+    b = np.array((0, 0, 1)) if b is None else b
     # first produce 'equally' distributed directions in spherical coords
-    o = 4 * pi / Om
-    h = -1 + 2 * arange(N) / (N * o - 1.0)
-    theta = arccos(h)
-    phi = zeros_like(theta)
+    o = 4 * np.pi / Om
+    h = -1 + 2 * np.arange(N) / (N * o - 1.0)
+    theta = np.arccos(h)
+    phi = np.zeros_like(theta)
     for i, hk in enumerate(h[1:]):
-        phi[i + 1] = phi[i] + 3.6 / sqrt(N * o * (1 - hk * hk)) % (2 * pi)
+        phi[i + 1] = phi[i] + 3.6 / np.sqrt(N * o * (1 - hk * hk)) % (2 * np.pi)
     # translate to cartesian coords
-    xyz = vstack((sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta)))
+    xyz = np.vstack((np.sin(theta) * np.cos(phi), np.sin(theta) * np.sin(phi), np.cos(theta)))
     # mirror everything on a plane so that b points into the center
     a = xyz[:, 0]
-    b = b / norm(b)
-    ab = (a - b)[:, newaxis]
-    if norm(ab) < 1e-10:
+    b = b / spla.norm(b)
+    ab = (a - b)[:, np.newaxis]
+    if spla.norm(ab) < 1e-10:
         return xyz
     # this is the Householder matrix for mirroring
-    H = identity(3) - dot(ab, ab.T) / dot(ab.T, a)
+    H = np.identity(3) - np.dot(ab, ab.T) / np.dot(ab.T, a)
     # actual mirroring
-    return dot(H, xyz)
+    return np.dot(H, xyz)
 
 
 class GeneralFlowEnvironment(Environment):
@@ -809,14 +798,14 @@ class GeneralFlowEnvironment(Environment):
 
     #: The flow field object describing the velocity field,
     #: which must be an instance of :class:`~acoular.environments.FlowField`.
-    ff = Instance(FlowField, desc='flow field')
+    ff = Instance(FlowField)
 
     #: The number of rays used per solid angle :math:`\Omega`. Defaults to ``200``.
-    N = Int(200, desc='number of rays per Om')
+    N = Int(200)
 
     #: The maximum solid angle (in steradians) used in the ray-tracing algorithm.
     #: Default is :obj:`numpy.pi`.
-    Om = Float(pi, desc='maximum solid angle')
+    Om = Float(np.pi)
 
     #: A unique identifier based on the environment properties. (read-only)
     digest = Property(
@@ -834,10 +823,10 @@ class GeneralFlowEnvironment(Environment):
     def _r(self, gpos, mpos=0.0):
         c = self.c
 
-        if isscalar(mpos):
-            mpos = array((0, 0, 0), dtype=float32)[:, newaxis]
+        if np.isscalar(mpos):
+            mpos = np.array((0, 0, 0), dtype=np.float32)[:, np.newaxis]
 
-        gt = empty((gpos.shape[-1], mpos.shape[-1]))
+        gt = np.empty((gpos.shape[-1], mpos.shape[-1]))
         for micnum, x0 in enumerate(mpos.T):
             key = x0.tobytes()  # make array hashable
             try:
@@ -888,16 +877,16 @@ class GeneralFlowEnvironment(Environment):
             x = y[0:3]
             s = y[3:6]
             vv, dv = v(x)
-            sa = sqrt(s[0] * s[0] + s[1] * s[1] + s[2] * s[2])
-            x = empty(6)
+            sa = np.sqrt(s[0] * s[0] + s[1] * s[1] + s[2] * s[2])
+            x = np.empty(6)
             x[0:3] = c * s / sa - vv  # time reversal
-            x[3:6] = dot(s, -dv.T)  # time reversal
+            x[3:6] = np.dot(s, -dv.T)  # time reversal
             return x
 
         # integration along a single ray
         def fr(x0, n0, rmax, dt, v, xyz, t):
-            s0 = n0 / (c + dot(v(x0)[0], n0))
-            y0 = hstack((x0, s0))
+            s0 = n0 / (c + np.dot(v(x0)[0], n0))
+            y0 = np.hstack((x0, s0))
             oo = ode(f1)
             oo.set_f_params(v)
             oo.set_integrator(
@@ -909,18 +898,18 @@ class GeneralFlowEnvironment(Environment):
             while oo.successful():
                 xyz.append(oo.y[0:3])
                 t.append(oo.t)
-                if norm(oo.y[0:3] - x0) > rmax:
+                if spla.norm(oo.y[0:3] - x0) > rmax:
                     break
                 oo.integrate(oo.t + dt)
 
         gs2 = roi.shape[-1]
         vv = self.ff.v
-        NN = int(sqrt(self.N))
+        NN = int(np.sqrt(self.N))
         xe = roi.mean(1)  # center of grid
-        r = x0[:, newaxis] - roi
-        rmax = sqrt((r * r).sum(0).max())  # maximum distance
+        r = x0[:, np.newaxis] - roi
+        rmax = np.sqrt((r * r).sum(0).max())  # maximum distance
         nv = spiral_sphere(self.N, self.Om, b=xe - x0)
-        rstep = rmax / sqrt(self.N)
+        rstep = rmax / np.sqrt(self.N)
         rmax += rstep
         tstep = rstep / c
         xyz = []
@@ -930,13 +919,13 @@ class GeneralFlowEnvironment(Environment):
             fr(x0, n0, rmax, tstep, vv, xyz, t)
             if i and i % NN == 0:
                 if not lastind:
-                    dd = ConvexHull(vstack((roi.T, xyz)), incremental=True)
+                    dd = ConvexHull(np.vstack((roi.T, xyz)), incremental=True)
                 else:
                     dd.add_points(xyz[lastind:], restart=True)
                 lastind = len(xyz)
                 # ConvexHull includes grid if no grid points on hull
                 if dd.simplices.min() >= gs2:
                     break
-        xyz = array(xyz)
-        t = array(t)
+        xyz = np.array(xyz)
+        t = np.array(t)
         return LinearNDInterpolator(xyz, t)