Minor fixes to references and such

mikaem · mikaem · commit 731a8896bc65 · 2019-03-29T08:41:50.000+01:00
diff --git a/docs/paper/paper.bib b/docs/paper/paper.bib
@@ -3,18 +3,19 @@ @article{dalcin18
                Mikael Mortensen and
                David E. Keyes},
   title     = {Fast parallel multidimensional {FFT} using advanced {MPI}},
-  journal   = {{Journal of Parallel and Distributed Computing}},
-  volume    = {in press},
+  journal   = {{J. Parallel Distrib. Comput.}},
+  volume    = {128},
+  pages     = {137--150},
   year      = {2019},
-  url       = {http://arxiv.org/abs/1804.09536},
-  eprint    = {1804.09536}
+  doi       = {10.1016/j.jpdc.2019.02.006},
+  url       = {https://doi.org/10.1016/j.jpdc.2019.02.006}
 }
 
 @article{mortensen_joss,
     author = {Mikael Mortensen},
     year = {2018},
-    title = {Shenfun: High performance spectral Galerkin computing platform},
-    journal = {Journal of Open Source Software},
+    title = {{Shenfun: High performance spectral Galerkin computing platform}},
+    journal = {J. Open Source Software},
     volume = {3},
     number = {31},
     pages = {1071},
@@ -26,8 +27,8 @@ @inproceedings{mortensen17
 	booktitle = {MekIT'17 - Ninth national conference on Computational Mechanics},
 	isbn = {978-84-947311-1-2},
 	pages = {273--298},
-	publisher = {International Center for Numerical Methods in Engineering (CIMNE)},
-	title = {Shenfun - automating the spectral Galerkin method},
+	publisher = {Int Center for Numerical Methods in Engineering (CIMNE)},
+	title = {{Shenfun - automating the spectral Galerkin method}},
   editor = {Skallerud, Bjorn Helge and Andersson, Helge Ingolf},
 	year = {2017}
   }
@@ -48,7 +49,7 @@ @article{strang94
 @article{mpi4py08,
 author = {Lisandro Dalcin and Rodrigo Paz and Mario Storti and Jorge D'Elia},
 title = {{MPI} for {P}ython: Performance improvements and {MPI}-2 extensions},
-journal = {Journal of Parallel and Distributed Computing},
+journal = {J. Parallel Distrib. Comput.},
 volume = {68},
 number = {5},
 pages = {655--662},
@@ -61,7 +62,7 @@ @article{mpi4py08
 @article{cython11,
  author = {Behnel, Stefan and Bradshaw, Robert and Citro, Craig and Dalcin, Lisandro and Seljebotn, Dag Sverre and Smith, Kurt},
  title = {Cython: The Best of Both Worlds},
- journal = {Computing in Science and Engg.},
+ journal = {Comput. in Science and Engg.},
  volume = {13},
  number = {2},
  pages = {31--39},
@@ -84,7 +85,7 @@ @article{fftw05
 
 @article{mortensen16,
   title = {{High performance Python for direct numerical simulations of turbulent flows}},
-  journal = {{Computer Physics Communications}},
+  journal = {{Comput. Phys. Comm.}},
   volume = {203},
   pages = {53--65},
   year = {2016},
@@ -106,7 +107,7 @@ @article{mortensen16b
 @article{ketcheson,
   title = {{More efficient time integration for Fourier pseudo-spectral DNS of incompressible turbulence}},
   author = {David Ketcheson and Mikael Mortensen and Matteo Parsani and Nathanael Schilling},
-  journal = {{International Journal of Numerical Methods in Fluids}},
+  journal = {{Int J Numer Meth Fluids}},
   volume = {in press},
   year = {2019},
   url = {https://arxiv.org/abs/1810.10197}
diff --git a/docs/source/global.rst b/docs/source/global.rst
@@ -350,9 +350,9 @@ reverse ``backward`` method of the :class:`.Transfer` objects::
 
 A different approach is also possible with the high-level API::
 
-    a0.redistribute(darray=a1)
-    a1.redistribute(darray=a2)
-    a2.redistribute(darray=a3)
+    a0.redistribute(out=a1)
+    a1.redistribute(out=a2)
+    a2.redistribute(out=a3)
 
 which corresponds to the backward transfers. However, with the high-level
 API the transfer objects are created (and deleted on exit) during the call
diff --git a/mpi4py_fft/distarray.py b/mpi4py_fft/distarray.py
@@ -1,5 +1,5 @@
 import os
-from numbers import Number
+from numbers import Number, Integral
 import numpy as np
 from mpi4py import MPI
 from .pencil import Pencil, Subcomm
@@ -24,12 +24,14 @@ class DistArray(np.ndarray):
     dtype : np.dtype, optional
         Type of array
     buffer : Numpy array, optional
-        Array of correct shape
+        Array of correct shape. The buffer owns the memory that is used for
+        this array.
     alignment : None or int, optional
         Make sure array is aligned in this direction. Note that alignment does
         not take rank into consideration.
     rank : int, optional
-        Rank of tensor (scalar is zero, vector one, matrix two)
+        Rank of tensor (number of free indices, a scalar is zero, vector one,
+        matrix two)
 
 
     For more information, see `numpy.ndarray <https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html>`_
@@ -55,11 +57,12 @@ class DistArray(np.ndarray):
     """
     def __new__(cls, global_shape, subcomm=None, val=None, dtype=np.float,
                 buffer=None, alignment=None, rank=0):
-        if len(global_shape[rank:]) < 2:
+        if len(global_shape[rank:]) < 2: # 1D case
             obj = np.ndarray.__new__(cls, global_shape, dtype=dtype, buffer=buffer)
             if buffer is None and isinstance(val, Number):
                 obj.fill(val)
             obj._rank = rank
+            obj._p0 = None
             return obj
 
         if isinstance(subcomm, Subcomm):
@@ -155,17 +158,20 @@ def __getitem__(self, i):
         if self.ndim == 1:
             return np.ndarray.__getitem__(self, i)
 
-        if isinstance(i, (int, slice)) and self.rank > 0:
+        if isinstance(i, (Integral, slice)) and self.rank > 0:
             v0 = np.ndarray.__getitem__(self, i)
             v0._rank = self.rank - (self.ndim - v0.ndim)
-            #if v0.ndim < self.ndim:
-            #    v0._rank -= 1
             return v0
 
-        if isinstance(i, tuple) and len(i) == 2 and self.rank == 2:
+        if isinstance(i, (Integral, slice)) and self.rank == 0:
+            return np.ndarray.__getitem__(self.v, i)
+
+        assert isinstance(i, tuple)
+        if len(i) <= self.rank:
             v0 = np.ndarray.__getitem__(self, i)
-            v0._rank = 0
+            v0._rank = self.rank - (self.ndim - v0.ndim)
             return v0
+
         return np.ndarray.__getitem__(self.v, i)
 
     @property
@@ -445,7 +451,7 @@ def newDistArray(pfft, forward_output=True, val=0, rank=0, view=False):
     val : int or float, optional
         Value used to initialize array.
     rank: int, optional
-        Scalar has rank 0, vector 1 and matrix 2
+        Scalar has rank 0, vector 1 and matrix 2.
     view : bool, optional
         If True return view of the underlying Numpy array, i.e., return
         cls.view(np.ndarray). Note that the DistArray still will
diff --git a/mpi4py_fft/io/nc_file.py b/mpi4py_fft/io/nc_file.py
@@ -53,7 +53,7 @@ def __init__(self, ncname, domain=None, mode='a', clobber=True, **kw):
         self.f = Dataset(ncname, mode=mode, clobber=clobber, parallel=True,
                          comm=comm, **kw)
         self.dims = None
-        if not 'time' in self.f.variables:
+        if 'time' not in self.f.variables:
             self.f.createDimension('time', None)
             self.f.createVariable('time', np.float, ('time'))
         self.close()
diff --git a/mpi4py_fft/mpifft.py b/mpi4py_fft/mpifft.py
@@ -91,9 +91,9 @@ class PFFT(object):
         - int -> Just one axis to transform over
         - sequence of ints -> e.g., (0, 1, 2) or (0, 2, 1)
         - sequence of sequence of ints -> e.g., ((0,), (1,)) or ((0,), (1, 2))
-          For seq. of seq. of ints only the last inner sequence may be longer
-          than 1. This corresponds to collapsing axes, where serial FFTs are
-          performed for all collapsed axes in one single call
+          For seq. of seq. of ints all but the last transformed sequence
+          may be longer than 1. This corresponds to collapsing axes, where
+          serial FFTs are performed for all collapsed axes in one single call
     dtype : np.dtype, optional
         Type of input array
     slab : bool, optional
@@ -361,21 +361,6 @@ def local_slice(self, forward_output=True):
                                                                    ip.subshape)]
         return tuple(s)
 
-    def local_shape(self, forward_output=False): #pragma: no cover
-        """The local (to each processor) shape of data
-
-        Parameters
-        ----------
-        forward_output : bool, optional
-            Return shape of output array (spectral space) if True, else return
-            shape of input array (physical space)
-        """
-        import warnings
-        warnings.warn("local_shape() is deprecated; use shape().", FutureWarning)
-        if forward_output is not True:
-            return self.forward.input_pencil.subshape
-        return self.backward.input_pencil.subshape
-
     def global_shape(self, forward_output=False):
         """Return global shape of associated tensors
 
