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

acoular/aiaa/aiaa.py

@@ -27,18 +27,17 @@ Examples
 
 import contextlib
 
-from numpy import array
+import numpy as np
 from traits.api import (
     File,
     Instance,
     Property,
     Union,
     cached_property,
-    on_trait_change,
+    observe,
     property_depends_on,
 )
 
-from acoular.deprecation import deprecated_alias
 from acoular.h5files import H5FileBase, _get_h5file_class
 from acoular.internal import digest
 from acoular.microphones import MicGeom
@@ -85,7 +84,6 @@ class TriggerAIAABenchmark(TimeSamplesAIAABenchmark):
         (self.num_samples, self.num_channels) = self.data.shape
 
 
-@deprecated_alias({'name': 'file'}, removal_version='25.10')
 class CsmAIAABenchmark(PowerSpectraImport):
     """Class to load the CSM that is stored in AIAA Benchmark HDF5 file."""
 
@@ -115,8 +113,8 @@ class CsmAIAABenchmark(PowerSpectraImport):
     def _get_basename(self):
         return get_file_basename(self.file)
 
-    @on_trait_change('basename')
-    def load_data(self):
+    @observe('basename')
+    def _load_data(self, event):  # noqa ARG002
         """Open the .h5 file and set attributes."""
         if self.h5f is not None:
             with contextlib.suppress(OSError):
@@ -156,7 +154,7 @@ class CsmAIAABenchmark(PowerSpectraImport):
         ndarray
             Array of length *block_size/2+1* containing the sample frequencies.
         """
-        return array(self.h5f.get_data_by_reference('/CsmData/binCenterFrequenciesHz')[:].flatten(), dtype=float)
+        return np.array(self.h5f.get_data_by_reference('/CsmData/binCenterFrequenciesHz')[:].flatten(), dtype=float)
 
 
 class MicAIAABenchmark(MicGeom):
@@ -172,8 +170,8 @@ class MicAIAABenchmark(MicGeom):
         None, File(filter=['*.h5'], exists=True), desc='name of the h5 file containing the microphone geometry'
     )
 
-    @on_trait_change('file')
-    def _import_mpos(self):
+    @observe('file')
+    def _import_mpos(self, event):  # noqa ARG002
         """
         Import the microphone positions from .h5 file.
 

acoular/base.py

@@ -7,6 +7,12 @@ The classes in this module are abstract base classes that provide a common inter
 that generate an output via the generator :meth:`result` in block-wise manner. They are not intended
 to be used directly, but to be subclassed by classes that implement the actual signal processing.
 
+.. inheritance-diagram::
+                acoular.base
+    :top-classes:
+                acoular.base.Generator
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -32,11 +38,9 @@ from traits.api import (
 )
 
 # acoular imports
-from .deprecation import deprecated_alias
 from .internal import digest
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, removal_version='25.10')
 class Generator(ABCHasStrictTraits):
     """Interface for any generating signal processing block.
 
@@ -156,7 +160,6 @@ class SpectraGenerator(Generator):
         """
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, read_only=True, removal_version='25.10')
 class TimeOut(SamplesGenerator):
     """
     Abstract base class receiving from a :attr:`source` and returning time domain signals.
@@ -204,11 +207,6 @@ class TimeOut(SamplesGenerator):
         """
 
 
-@deprecated_alias(
-    {'numchannels': 'num_channels', 'numsamples': 'num_samples', 'numfreqs': 'num_freqs'},
-    read_only=True,
-    removal_version='25.10',
-)
 class SpectraOut(SpectraGenerator):
     """
     Abstract base class receiving from a :attr:`source` and returning frequency domain signals.
@@ -263,7 +261,6 @@ class SpectraOut(SpectraGenerator):
         """
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, read_only=True, removal_version='25.10')
 class InOut(SamplesGenerator, SpectraGenerator):
     """
     Abstract base class receiving from a :attr:`source` and returning signals in the same domain.

acoular/calib.py

@@ -3,6 +3,12 @@
 # ------------------------------------------------------------------------------
 """Implements calibration of multichannel time signals.
 
+.. inheritance-diagram::
+                acoular.calib
+    :top-classes:
+                acoular.base.InOut
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -12,19 +18,14 @@
 # imports from other packages
 import xml.dom.minidom
 
-from numpy import array, newaxis
-from traits.api import CArray, CInt, File, List, Property, Union, cached_property, on_trait_change
-
-import acoular as ac
-
-from .base import InOut
+import numpy as np
+from traits.api import CArray, CInt, File, List, Property, Union, cached_property, observe
 
 # acoular imports
-from .deprecation import deprecated_alias
+from .base import InOut, SamplesGenerator, SpectraGenerator
 from .internal import digest
 
 
-@deprecated_alias({'from_file': 'file'}, removal_version='25.10')
 class Calib(InOut):
     """Processing block for handling calibration data in `*.xml` or NumPy format.
 
@@ -99,8 +100,8 @@ class Calib(InOut):
     # Internal identifier
     digest = Property(depends_on=['source.digest', 'data'])
 
-    @on_trait_change('data')
-    def set_num_mics(self):
+    @observe('data')
+    def _update_num_mics(self, event):  # noqa ARG002
         """Sets the number of microphones based on the shape of the data array."""
         self.num_mics = self.data.shape[0]
 
@@ -109,14 +110,14 @@ class Calib(InOut):
         if len(self.invalid_channels) == 0:
             return slice(0, None, None)
         allr = [i for i in range(self.num_mics) if i not in self.invalid_channels]
-        return array(allr)
+        return np.array(allr)
 
     @cached_property
     def _get_digest(self):
         return digest(self)
 
-    @on_trait_change('file')
-    def import_data(self):
+    @observe('file')
+    def _import_data(self, event):  # noqa ARG002
         """Loads the calibration data from `*.xml` file ."""
         doc = xml.dom.minidom.parse(self.file)
         names = []
@@ -124,7 +125,7 @@ class Calib(InOut):
         for element in doc.getElementsByTagName('pos'):
             names.append(element.getAttribute('Name'))
             data.append(float(element.getAttribute('factor')))
-        self.data = array(data, 'd')
+        self.data = np.array(data, 'd')
         self.num_mics = self.data.shape[0]
 
     def __validate_data(self):
@@ -136,13 +137,13 @@ class Calib(InOut):
             msg = 'No source data available.'
             raise ValueError(msg)
         tobj = self.source
-        while isinstance(tobj, ac.InOut):
+        while isinstance(tobj, InOut):
             tobj = tobj.source
-        if isinstance(tobj, ac.SamplesGenerator) and (self.data[self.channels].shape[0] != tobj.num_channels):
+        if isinstance(tobj, SamplesGenerator) and (self.data[self.channels].shape[0] != tobj.num_channels):
             msg = f'calibration data shape {self.data[self.channels].shape[0]} does not match \
                 source data shape {tobj.num_channels}'
             raise ValueError(msg)
-        if isinstance(tobj, ac.SpectraGenerator) and (
+        if isinstance(tobj, SpectraGenerator) and (
             self.data[self.channels].shape[0] != tobj.num_channels * tobj.num_freqs
         ):
             msg = f'calibration data shape {self.data[self.channels].shape[0]} does not match \
@@ -170,4 +171,4 @@ class Calib(InOut):
         """
         self.__validate_data()
         for block in self.source.result(num):
-            yield block * self.data[self.channels][newaxis]
+            yield block * self.data[self.channels][np.newaxis]

acoular/configuration.py

@@ -39,9 +39,9 @@ if 'numpy' in sys.modules:
     # check if it uses OpenBLAS or another library
     if 'openblas' in temp_stdout.getvalue().lower() and environ.get('OPENBLAS_NUM_THREADS') != '1':
         # it's OpenBLAS, set numba threads=1 to avoid overcommittment
-        import numba
+        import numba as nb
 
-        numba.set_num_threads(1)
+        nb.set_num_threads(1)
         warn(
             'We detected that Numpy is already loaded and uses OpenBLAS. Because '
             'this conflicts with Numba parallel execution, we disable parallel '

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):
@@ -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
@@ -265,7 +254,7 @@ class UniformFlowEnvironment(Environment):
 
     #: 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)), desc='flow direction')
 
     #: 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
@@ -358,14 +347,14 @@ class SlotJet(FlowField):
     v0 = Float(0.0, desc='exit velocity')
 
     #: 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)), desc='center of nozzle')
 
     #: 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)), desc='flow direction')
 
     #: 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)), desc='slot center line direction')
 
     #: Width of the slot (slot diameter). Default is ``0.2``.
     B = Float(0.2, desc='nozzle diameter')
@@ -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):
@@ -479,7 +468,7 @@ class OpenJet(FlowField):
     v0 = Float(0.0, desc='exit velocity')
 
     #: 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)), desc='center of nozzle')
 
     #: Diameter of the nozzle. Default is ``0.2``.
     D = Float(0.2, desc='nozzle diameter')
@@ -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
@@ -619,7 +608,7 @@ class RotatingFlow(FlowField):
 
     #: 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)), desc='center of rotation')
 
     #: 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):
@@ -816,7 +805,7 @@ class GeneralFlowEnvironment(Environment):
 
     #: 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, desc='maximum solid angle')
 
     #: 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)