acoular 24.5__py3-none-any.whl → 24.10__py3-none-any.whl

acoular/fprocess.py

@@ -0,0 +1,368 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) Acoular Development Team.
+# ------------------------------------------------------------------------------
+"""Implements blockwise processing methods in the frequency domain.
+
+.. autosummary::
+    :toctree: generated/
+
+    RFFT
+    IRFFT
+    AutoPowerSpectra
+    CrossPowerSpectra
+    FFTSpectra
+"""
+
+from warnings import warn
+
+import numpy as np
+from scipy import fft
+from traits.api import Bool, CArray, Enum, Instance, Int, Property, Trait, Union, cached_property
+
+from .base import SamplesGenerator, SpectraGenerator, SpectraOut, TimeOut
+from .fastFuncs import calcCSM
+from .internal import digest
+from .spectra import BaseSpectra
+from .tools.utils import SamplesBuffer
+
+
+class RFFT(BaseSpectra, SpectraOut):
+    """Provides the one-sided Fast Fourier Transform (FFT) for real-valued multichannel time data.
+
+    The FFT is calculated block-wise, i.e. the input data is divided into blocks of length
+    :attr:`block_size` and the FFT is calculated for each block. Optionally, a window function
+    can be applied to the data before the FFT calculation via the :attr:`window` attribute.
+    """
+
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
+    #: Number of workers to use for the FFT calculation. If negative values are used,
+    #: all available logical CPUs will be considered (``scipy.fft.rfft`` implementation wraps around from ``os.cpu_count()``).
+    #: Default is `None` (handled by scipy)
+    workers = Union(Int(), None, default_value=None, desc='number of workers to use')
+
+    #: Scaling method, either 'amplitude', 'energy' or :code:`none`.
+    #: Default is :code:`none`.
+    #: 'energy': compensates for the energy loss due to truncation of the FFT result. The resulting
+    #: one-sided spectrum is multiplied by 2.0, except for the DC and Nyquist frequency.
+    #: 'amplitude': scales the one-sided spectrum so that the amplitude of discrete tones does not depend
+    #: on the block size.
+    scaling = Enum('none', 'energy', 'amplitude')
+
+    #: block size of the FFT. Default is 1024.
+    block_size = Property()
+
+    #: Number of frequencies in the output.
+    numfreqs = Property(depends_on='_block_size')
+
+    #: Number of snapshots in the output.
+    numsamples = Property(depends_on='source.numsamples, _block_size')
+
+    #: 1-D array of FFT sample frequencies.
+    freqs = Property()
+
+    # internal block size variable
+    _block_size = Int(1024, desc='block size of the FFT')
+
+    # internal identifier
+    digest = Property(depends_on=['source.digest', 'scaling', 'precision', '_block_size', 'window', 'overlap'])
+
+    @cached_property
+    def _get_digest(self):
+        return digest(self)
+
+    @cached_property
+    def _get_numfreqs(self):
+        return int(self.block_size / 2 + 1)
+
+    @cached_property
+    def _get_numsamples(self):
+        if self.source.numsamples >= 0:
+            return int(np.floor(self.source.numsamples / self.block_size))
+        return -1
+
+    def _get_block_size(self):
+        return self._block_size
+
+    def _set_block_size(self, value):
+        if value % 2 != 0:
+            msg = 'Block size must be even'
+            raise ValueError(msg)
+        self._block_size = value
+
+    def _scale(self, data, scaling_value):
+        """Corrects the energy of the one-sided FFT data."""
+        if self.scaling == 'amplitude' or self.scaling == 'energy':
+            data[1:-1] *= 2.0
+        data *= scaling_value
+        return data
+
+    def _get_freqs(self):
+        """Return the Discrete Fourier Transform sample frequencies.
+
+        Returns
+        -------
+        f : ndarray
+            1-D Array of length *block_size/2+1* containing the sample frequencies.
+
+        """
+        if self.source is not None:
+            return abs(fft.fftfreq(self.block_size, 1.0 / self.source.sample_freq)[: int(self.block_size / 2 + 1)])
+        return np.array([])
+
+    def result(self, num=1):
+        """Python generator that yields the output block-wise.
+
+        Parameters
+        ----------
+        num : integer
+            This parameter defines the number of multi-channel spectra (i.e. snapshots) per block
+            returned by the generator.
+
+        Returns
+        -------
+        Spectra block of shape (num, :attr:`numchannels`*:attr:`numfreqs`).
+            The last block may be shorter than num.
+
+        """
+        wind = self.window_(self.block_size)
+        if self.scaling == 'none' or self.scaling == 'energy':  # only compensate for the window
+            svalue = 1 / np.sqrt(np.dot(wind, wind) / self.block_size)
+        elif self.scaling == 'amplitude':  # compensates for the window and the energy loss
+            svalue = 1 / wind.sum()
+        wind = wind[:, np.newaxis]
+        fftdata = np.zeros((num, self.numchannels * self.numfreqs), dtype=self.precision)
+        j = 0
+        for i, data in enumerate(self._get_source_data()):  # yields one block of time data
+            j = i % num
+            fftdata[j] = self._scale(
+                fft.rfft(data * wind, n=self.block_size, axis=0, workers=self.workers).astype(self.precision),
+                scaling_value=svalue,
+            ).reshape(-1)
+            if j == num - 1:
+                yield fftdata
+        if j < num - 1:  # yield remaining fft spectra
+            yield fftdata[: j + 1]
+
+
+class IRFFT(TimeOut):
+    """Calculates the inverse Fast Fourier Transform (IFFT) for one-sided multi-channel spectra."""
+
+    #: Data source; :class:`~acoular.base.SpectraGenerator` or derived object.
+    source = Instance(SpectraGenerator)
+
+    #: Number of workers to use for the FFT calculation. If negative values are used,
+    #: all available logical CPUs will be considered (``scipy.fft.rfft`` implementation wraps around from ``os.cpu_count()``).
+    #: Default is `None` (handled by scipy)
+    workers = Union(Int(), None, default_value=None, desc='number of workers to use')
+
+    #: The floating-number-precision of the resulting time signals, corresponding to numpy dtypes.
+    #: Default is 64 bit.
+    precision = Trait('float64', 'float32', desc='precision of the time signal after the ifft')
+
+    #: Number of time samples in the output.
+    numsamples = Property(depends_on='source.numsamples, source._block_size')
+
+    # internal time signal buffer to handle arbitrary output block sizes
+    _buffer = CArray(desc='signal buffer')
+
+    # internal identifier
+    digest = Property(depends_on=['source.digest', 'scaling', 'precision', '_block_size', 'window', 'overlap'])
+
+    def _get_numsamples(self):
+        if self.source.numsamples >= 0:
+            return int(self.source.numsamples * self.source.block_size)
+        return -1
+
+    @cached_property
+    def _get_digest(self):
+        return digest(self)
+
+    def _validate(self):
+        if not self.source.block_size or self.source.block_size < 0:
+            msg = (
+                f'Source of class {self.__class__.__name__} has an unknown blocksize: {self.source.block_size}.'
+                'This is likely due to incomplete spectral data from which the inverse FFT cannot be calculated.'
+            )
+            raise ValueError(msg)
+        if (self.source.numfreqs - 1) * 2 != self.source.block_size:
+            msg = (
+                f'Block size must be 2*(numfreqs-1) but is {self.source.block_size}.'
+                'This is likely due to incomplete spectral data from which the inverse FFT cannot be calculated.'
+            )
+            raise ValueError(msg)
+        if self.source.block_size % 2 != 0:
+            msg = f'Block size must be even but is {self.source.block_size}.'
+            raise ValueError(msg)
+
+    def result(self, num):
+        """Python generator that yields the output block-wise.
+
+        Parameters
+        ----------
+        num : integer
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). The last block may be shorter than num.
+
+        Yields
+        ------
+        numpy.ndarray
+            Yields blocks of shape (num, numchannels).
+        """
+        self._validate()
+        bs = self.source.block_size
+        if num != bs:
+            buffer_length = (int(np.ceil(num / bs)) + 1) * bs
+            buffer = SamplesBuffer(source=self, source_num=bs, length=buffer_length, dtype=self.precision)
+            yield from buffer.result(num)
+        else:
+            for spectra in self.source.result(1):
+                yield fft.irfft(
+                    spectra.reshape(self.source.numfreqs, self.numchannels), n=num, axis=0, workers=self.workers
+                )
+
+
+class AutoPowerSpectra(SpectraOut):
+    """Calculates the real-valued auto-power spectra."""
+
+    #: Data source; :class:`~acoular.base.SpectraGenerator` or derived object.
+    source = Instance(SpectraGenerator)
+
+    #: Scaling method, either 'power' or 'psd' (Power Spectral Density).
+    #: Only relevant if the source is a :class:`~acoular.fprocess.FreqInOut` object.
+    scaling = Enum('power', 'psd')
+
+    #: Determines if the spectra yielded by the source are single-sided spectra.
+    single_sided = Bool(True, desc='single sided spectrum')
+
+    #: The floating-number-precision of entries, corresponding to numpy dtypes. Default is 64 bit.
+    precision = Trait('float64', 'float32', desc='floating-number-precision')
+
+    # internal identifier
+    digest = Property(depends_on=['source.digest', 'precision', 'scaling', 'single_sided'])
+
+    @cached_property
+    def _get_digest(self):
+        return digest(self)
+
+    def _get_scaling_value(self):
+        scale = 1 / self.block_size**2
+        if self.single_sided:
+            scale *= 2
+        if self.scaling == 'psd':
+            scale *= self.block_size * self.source.sample_freq
+        return scale
+
+    def result(self, num=1):
+        """Python generator that yields the real-valued auto-power spectra.
+
+        Parameters
+        ----------
+        num : integer
+            This parameter defines the number of snapshots within each output data block.
+
+        Yields
+        ------
+        numpy.ndarray
+            Yields blocks of shape (num, numchannels*numfreqs).
+            The last block may be shorter than num.
+
+        """
+        scale = self._get_scaling_value()
+        for temp in self.source.result(num):
+            yield ((temp * temp.conjugate()).real * scale).astype(self.precision)
+
+
+class CrossPowerSpectra(AutoPowerSpectra):
+    """Calculates the complex-valued auto- and cross-power spectra.
+
+    Receives the complex-valued spectra from the source and returns the cross-spectral matrix (CSM) in a flattened
+    representation (i.e. the auto- and cross-power spectra are concatenated along the last axis).
+    If :attr:`calc_mode` is 'full', the full CSM is calculated, if 'upper', only the upper triangle is calculated.
+    """
+
+    #: Data source; :class:`~acoular.base.SpectraGenerator` or derived object.
+    source = Trait(SpectraGenerator)
+
+    #: The floating-number-precision of entries of csm, eigenvalues and
+    #: eigenvectors, corresponding to numpy dtypes. Default is 64 bit.
+    precision = Trait('complex128', 'complex64', desc='precision of the fft')
+
+    #: Calculation mode, either 'full' or 'upper'.
+    #: 'full' calculates the full cross-spectral matrix, 'upper' calculates
+    # only the upper triangle. Default is 'full'.
+    calc_mode = Trait('full', 'upper', 'lower', desc='calculation mode')
+
+    #: Number of channels in output. If :attr:`calc_mode` is 'full', then
+    #: :attr:`numchannels` is :math:`n^2`, where :math:`n` is the number of
+    #: channels in the input. If :attr:`calc_mode` is 'upper', then
+    #: :attr:`numchannels` is :math:`n + n(n-1)/2`.
+    numchannels = Property(depends_on='source.numchannels')
+
+    # internal identifier
+    digest = Property(depends_on=['source.digest', 'precision', 'scaling', 'single_sided', 'calc_mode'])
+
+    @cached_property
+    def _get_numchannels(self):
+        n = self.source.numchannels
+        return n**2 if self.calc_mode == 'full' else int(n + n * (n - 1) / 2)
+
+    @cached_property
+    def _get_digest(self):
+        return digest(self)
+
+    def result(self, num=1):
+        """Python generator that yields the output block-wise.
+
+        Parameters
+        ----------
+        num : integer
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block).
+
+        Yields
+        ------
+        numpy.ndarray
+            Yields blocks of shape (num, numchannels*numfreq).
+        """
+        nc_src = self.source.numchannels
+        nc = self.numchannels
+        nf = self.numfreqs
+        scale = self._get_scaling_value()
+
+        csm_flat = np.zeros((num, nc * nf), dtype=self.precision)
+        csm_upper = np.zeros((nf, nc_src, nc_src), dtype=self.precision)
+        for data in self.source.result(num):
+            for i in range(data.shape[0]):
+                calcCSM(csm_upper, data[i].astype(self.precision).reshape(nf, nc_src))
+                if self.calc_mode == 'full':
+                    csm_lower = csm_upper.conj().transpose(0, 2, 1)
+                    [np.fill_diagonal(csm_lower[cntFreq, :, :], 0) for cntFreq in range(csm_lower.shape[0])]
+                    csm_flat[i] = (csm_lower + csm_upper).reshape(-1)
+                elif self.calc_mode == 'upper':
+                    csm_flat[i] = csm_upper[:, :nc].reshape(-1)
+                else:  # lower
+                    csm_lower = csm_upper.conj().transpose(0, 2, 1)
+                    csm_flat[i] = csm_lower[:, :nc].reshape(-1)
+                csm_upper[...] = 0  # calcCSM adds cummulative
+            yield csm_flat[: i + 1] * scale
+
+
+class FFTSpectra(RFFT):
+    """Provides the one-sided Fast Fourier Transform (FFT) for multichannel time data.
+
+    Alias for :class:`~acoular.fprocess.RFFT`.
+
+    .. deprecated:: 24.10
+        Using :class:`~acoular.fprocess.FFTSpectra` is deprecated and will be removed in Acoular
+        version 25.07. Use :class:`~acoular.fprocess.RFFT` instead.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        warn(
+            'Using FFTSpectra is deprecated and will be removed in Acoular version 25.07. Use class RFFT instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )

acoular/grids.py

@@ -25,6 +25,7 @@
 
 # imports from other packages
 from os import path
+from warnings import warn
 
 from numpy import (
     absolute,
@@ -32,7 +33,7 @@ from numpy import (
     arange,
     argmin,
     array,
-    asfarray,
+    asarray,
     concatenate,
     copysign,
     fabs,
@@ -50,12 +51,11 @@ from numpy import (
     where,
     zeros,
 )
-from numpy.linalg import norm
+from scipy.linalg import norm
 
 # from matplotlib.path import Path
 from scipy.spatial import Delaunay
 from traits.api import (
-    Any,
     Bool,
     CArray,
     File,
@@ -66,6 +66,7 @@ from traits.api import (
     List,
     Property,
     Tuple,
+    Union,
     cached_property,
     on_trait_change,
     property_depends_on,
@@ -110,8 +111,8 @@ def _det(xvert, yvert):
         all points are collinear.
 
     """
-    xvert = asfarray(xvert)
-    yvert = asfarray(yvert)
+    xvert = asarray(xvert, dtype=float)
+    yvert = asarray(yvert, dtype=float)
     x_prev = concatenate(([xvert[-1]], xvert[:-1]))
     y_prev = concatenate(([yvert[-1]], yvert[:-1]))
     return sum(yvert * x_prev - xvert * y_prev, axis=0)
@@ -128,8 +129,8 @@ class Polygon:
         if len(x) != len(y):
             msg = 'x and y must be equally sized.'
             raise IndexError(msg)
-        self.x = asfarray(x)
-        self.y = asfarray(y)
+        self.x = asarray(x, dtype=float)
+        self.y = asarray(y, dtype=float)
         # Closes the polygon if were open
         x1, y1 = x[0], y[0]
         xn, yn = x[-1], y[-1]
@@ -166,8 +167,8 @@ class Polygon:
              Software, Vol 7, No. 1, pp 45-47.
 
         """
-        xpoint = asfarray(xpoint)
-        ypoint = asfarray(ypoint)
+        xpoint = asarray(xpoint, dtype=float)
+        ypoint = asarray(ypoint, dtype=float)
         # Scalar to array
         if xpoint.shape == ():
             xpoint = array([xpoint], dtype=float)
@@ -296,6 +297,7 @@ class Grid(HasPrivateTraits):
     def pos(self):
         """Calculates grid co-ordinates.
         Deprecated; use :attr:`gpos` attribute instead.
+        The :meth:`pos` method will be removed in version 25.01.
 
         Returns
         -------
@@ -303,6 +305,10 @@ class Grid(HasPrivateTraits):
             The grid point x, y, z-coordinates in one array.
 
         """
+        msg = (
+            "The 'pos' method is deprecated and will be removed in version 25.01. " "Use the 'gpos' attribute instead."
+        )
+        warn(msg, DeprecationWarning, stacklevel=2)
         return self.gpos  # array([[0.], [0.], [0.]])
 
     def subdomain(self, sector):
@@ -535,7 +541,7 @@ class RectGrid3D(RectGrid):
     nzsteps = Property(desc='number of grid points along x-axis')
 
     # Private trait for increment handling
-    _increment = Any(0.1)
+    _increment = Union(Float(), CArray(shape=(3,), dtype=float), default_value=0.1, desc='step size')
 
     #: The cell side length for the grid. This can either be a scalar (same
     #: increments in all 3 dimensions) or a (3,) array of floats with
@@ -550,8 +556,8 @@ class RectGrid3D(RectGrid):
         if isscalar(increment):
             try:
                 self._increment = absolute(float(increment))
-            except:
-                raise TraitError(args=self, name='increment', info='Float or CArray(3,)', value=increment)
+            except ValueError as ve:
+                raise TraitError(args=self, name='increment', info='Float or CArray(3,)', value=increment) from ve
         elif len(increment) == 3:
             self._increment = array(increment, dtype=float)
         else:
@@ -559,14 +565,18 @@ class RectGrid3D(RectGrid):
 
     # Respective increments in x,y, and z-direction (in m).
     # Deprecated: Use :attr:`~RectGrid.increment` for this functionality
-    increment3D = Property(desc='3D step sizes')
+    increment3D = Property(desc='3D step sizes')  # noqa N815
 
-    def _get_increment3D(self):
+    def _get_increment3D(self):  # noqa N802
+        msg = "Using 'increment3D' is deprecated and will be removed in version 25.01." "Use 'increment' instead."
+        warn(msg, DeprecationWarning, stacklevel=2)
         if isscalar(self._increment):
             return array([self._increment, self._increment, self._increment])
         return self._increment
 
-    def _set_increment3D(self, inc):
+    def _set_increment3D(self, inc):  # noqa N802
+        msg = "Using 'increment3D' is deprecated and will be removed in version 25.01." "Use 'increment' instead."
+        warn(msg, DeprecationWarning, stacklevel=2)
         if not isscalar(inc) and len(inc) == 3:
             self._increment = array(inc, dtype=float)
         else:
@@ -587,21 +597,21 @@ class RectGrid3D(RectGrid):
 
     @property_depends_on('x_min, x_max, _increment')
     def _get_nxsteps(self):
-        i = abs(self.increment3D[0])
+        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[0])
         if i != 0:
             return int(round((abs(self.x_max - self.x_min) + i) / i))
         return 1
 
     @property_depends_on('y_min, y_max, _increment')
     def _get_nysteps(self):
-        i = abs(self.increment3D[1])
+        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[1])
         if i != 0:
             return int(round((abs(self.y_max - self.y_min) + i) / i))
         return 1
 
     @property_depends_on('z_min, z_max, _increment')
     def _get_nzsteps(self):
-        i = abs(self.increment3D[2])
+        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[2])
         if i != 0:
             return int(round((abs(self.z_max - self.z_min) + i) / i))
         return 1
@@ -655,9 +665,13 @@ class RectGrid3D(RectGrid):
         if z < self.z_min or z > self.z_max:
             msg = f'z-value out of range {z:f} ({self.z_min:f}, {self.z_max:f})'
             raise ValueError(msg)
-        xi = int(round((x - self.x_min) / self.increment3D[0]))
-        yi = int(round((y - self.y_min) / self.increment3D[1]))
-        zi = int(round((z - self.z_min) / self.increment3D[2]))
+        if isscalar(self.increment):
+            incx = incy = incz = self.increment
+        else:
+            incx, incy, incz = self.increment
+        xi = int(round((x - self.x_min) / incx))
+        yi = int(round((y - self.y_min) / incy))
+        zi = int(round((z - self.z_min) / incz))
         return xi, yi, zi
 
     def indices(self, x1, y1, z1, x2, y2, z2):
@@ -792,7 +806,7 @@ class LineGrid(Grid):
     def _get_gpos(self):
         dist = self.length / (self.numpoints - 1)
         loc = array(self.loc, dtype=float).reshape((3, 1))
-        direc_n = self.direction / norm(self.direction)
+        direc_n = array(self.direction) / norm(self.direction)
         pos = zeros((self.numpoints, 3))
         for s in range(self.numpoints):
             pos[s] = loc.T + direc_n * dist * s

acoular/h5cache.py

@@ -13,7 +13,7 @@ from .configuration import Config, config
 from .h5files import _get_cachefile_class
 
 
-class H5cache_class(HasPrivateTraits):
+class HDF5Cache(HasPrivateTraits):
     """Cache class that handles opening and closing 'tables.File' objects."""
 
     config = Instance(Config)
@@ -24,23 +24,23 @@ class H5cache_class(HasPrivateTraits):
 
     open_files = WeakValueDictionary()
 
-    openFileReferenceCount = Dict()
+    open_file_reference = Dict()
 
     def _idle_if_busy(self):
         while self.busy:
             pass
 
-    def open_cachefile(self, cacheFileName, mode):
-        File = _get_cachefile_class()
-        return File(path.join(self.cache_dir, cacheFileName), mode)
+    def open_cachefile(self, filename, mode):
+        file = _get_cachefile_class()
+        return file(path.join(self.cache_dir, filename), mode)
 
     def close_cachefile(self, cachefile):
-        self.openFileReferenceCount.pop(get_basename(cachefile))
+        self.open_file_reference.pop(get_basename(cachefile))
         cachefile.close()
 
     def get_filename(self, file):
-        File = _get_cachefile_class()
-        if isinstance(file, File):
+        file_class = _get_cachefile_class()
+        if isinstance(file, file_class):
             return get_basename(file)
         return 0
 
@@ -51,13 +51,13 @@ class H5cache_class(HasPrivateTraits):
             return iter(self.open_files.values())
 
     def close_unreferenced_cachefiles(self):
-        for openCacheFile in self.get_open_cachefiles():
-            if not self.is_reference_existent(openCacheFile):
-                #                print("close unreferenced File:",get_basename(openCacheFile))
-                self.close_cachefile(openCacheFile)
+        for cachefile in self.get_open_cachefiles():
+            if not self.is_reference_existent(cachefile):
+                #                print("close unreferenced File:",get_basename(cachefile))
+                self.close_cachefile(cachefile)
 
     def is_reference_existent(self, file):
-        existFlag = False
+        exist_flag = False
         # inspect all refererres to the file object
         gc.collect()  # clear garbage before collecting referrers
         for ref in gc.get_referrers(file):
@@ -65,41 +65,41 @@ class H5cache_class(HasPrivateTraits):
             # attribute?
             if isinstance(ref, dict) and 'h5f' in ref:
                 # file is still referred, must not be closed
-                existFlag = True
+                exist_flag = True
                 break
-        return existFlag
+        return exist_flag
 
-    def is_cachefile_existent(self, cacheFileName):
-        if cacheFileName in listdir(self.cache_dir):
+    def is_cachefile_existent(self, filename):
+        if filename in listdir(self.cache_dir):
             return True
         return False
 
-    def _increase_file_reference_counter(self, cacheFileName):
-        self.openFileReferenceCount[cacheFileName] = self.openFileReferenceCount.get(cacheFileName, 0) + 1
+    def _increase_file_reference_counter(self, filename):
+        self.open_file_reference[filename] = self.open_file_reference.get(filename, 0) + 1
 
-    def _decrease_file_reference_counter(self, cacheFileName):
-        self.openFileReferenceCount[cacheFileName] = self.openFileReferenceCount[cacheFileName] - 1
+    def _decrease_file_reference_counter(self, filename):
+        self.open_file_reference[filename] = self.open_file_reference[filename] - 1
 
     def _print_open_files(self):
-        print(list(self.openFileReferenceCount.items()))
+        print(list(self.open_file_reference.items()))
 
     def get_cache_file(self, obj, basename, mode='a'):
         """Returns pytables .h5 file to h5f trait of calling object for caching."""
         self._idle_if_busy()  #
         self.busy = True
 
-        cacheFileName = basename + '_cache.h5'
-        objFileName = self.get_filename(obj.h5f)
+        filename = basename + '_cache.h5'
+        obj_filename = self.get_filename(obj.h5f)
 
-        if objFileName:
-            if objFileName == cacheFileName:
+        if obj_filename:
+            if obj_filename == filename:
                 self.busy = False
                 return
-            self._decrease_file_reference_counter(objFileName)
+            self._decrease_file_reference_counter(obj_filename)
 
-        if cacheFileName not in self.open_files:  # or tables.file._open_files.filenames
+        if filename not in self.open_files:  # or tables.file._open_files.filenames
             if config.global_caching == 'readonly' and not self.is_cachefile_existent(
-                cacheFileName,
+                filename,
             ):  # condition ensures that cachefile is not created in readonly mode
                 obj.h5f = None
                 self.busy = False
@@ -107,11 +107,11 @@ class H5cache_class(HasPrivateTraits):
                 return
             if config.global_caching == 'readonly':
                 mode = 'r'
-            f = self.open_cachefile(cacheFileName, mode)
-            self.open_files[cacheFileName] = f
+            f = self.open_cachefile(filename, mode)
+            self.open_files[filename] = f
 
-        obj.h5f = self.open_files[cacheFileName]
-        self._increase_file_reference_counter(cacheFileName)
+        obj.h5f = self.open_files[filename]
+        self._increase_file_reference_counter(filename)
 
         # garbage collection
         self.close_unreferenced_cachefiles()
@@ -120,7 +120,7 @@ class H5cache_class(HasPrivateTraits):
         self._print_open_files()
 
 
-H5cache = H5cache_class(config=config)
+H5cache = HDF5Cache(config=config)
 
 
 def get_basename(file):