Modifications to paper.bib mostly

Author: mikaem

docs/paper/paper.bib

@@ -11,7 +11,7 @@ @article{dalcin18
 }
 
 @article{mortensen_joss,
-    author = {Mortensen, Mikael},
+    author = {Mikael Mortensen},
     year = {2018},
     title = {Shenfun: High performance spectral Galerkin computing platform},
     journal = {Journal of Open Source Software},
@@ -22,7 +22,7 @@ @article{mortensen_joss
 }
 
 @inproceedings{mortensen17,
-	author = {Mortensen, Mikael},
+	author = {Mikael Mortensen},
 	booktitle = {MekIT'17 - Ninth national conference on Computational Mechanics},
 	isbn = {978-84-947311-1-2},
 	pages = {273--298},
@@ -91,12 +91,12 @@ @article{mortensen16
   issn = {0010-4655},
   url = {https://doi.org/10.1016/j.cpc.2016.02.005},
   doi = {10.1016/j.cpc.2016.02.005},
-  author = {{Mikael Mortensen and Hans Petter Langtangen}},
+  author = {Mikael Mortensen and Hans Petter Langtangen},
 }
 
 @article{mortensen16b,
   title={{Massively parallel implementation in Python of a pseudo-spectral DNS code for turbulent flows}},
-  author={{Mikael Mortensen}},
+  author={Mikael Mortensen},
   journal={{Proceedings of EuroScipy 2015}},
   year={2016},
   archivePrefix = {arXiv},
@@ -105,7 +105,7 @@ @article{mortensen16b
 
 @article{ketcheson,
   title = {{More efficient time integration for Fourier pseudo-spectral DNS of incompressible turbulence}},
-  author = {{Ketcheson, David and Mortensen, Mikael and Parsani, Matteo and Schilling, Nathanael}},
+  author = {David Ketcheson and Mikael Mortensen and Matteo Parsani and Nathanael Schilling},
   journal = {{International Journal of Numerical Methods in Fluids}},
   volume = {in press},
   year = {2019},

docs/paper/paper.md

@@ -1,5 +1,5 @@
 ---
-title: 'Mpi4py-fft'
+title: 'mpi4py-fft: Parallel Fast Fourier Transforms with MPI for Python'
 tags:
  - Fast Fourier transforms
  - Fast Chebyshev transforms
@@ -67,7 +67,7 @@ transforms.
 redistributes arrays. Large arrays may be globally redistributed for
 alignment along any given axis, whenever needed by the user. This
 flexibility has enabled the development of ``shenfun``
-[@mortensen_joss,@mortensen17], which is a Python framework for
+[@mortensen_joss, @mortensen17], which is a Python framework for
 solving partial differential equations (PDEs) by the spectral Galerkin
 method. ``shenfun`` is able to solve PDEs of any given dimensionality
 by creating tensor product bases as outer products of one-dimensional
@@ -76,7 +76,7 @@ distributed effortlessly through ``mpi4py-fft``.
 Throughout the ``spectralDNS`` (https://github.com/spectralDNS/spectralDNS)
 project ``shenfun`` is being used extensively for
 Direct Numerical Simulations (DNS) of turbulent flows
-[@mortensen16,@mortensen16b,@ketcheson], using arrays with billions of
+[@mortensen16, @mortensen16b, @ketcheson], using arrays with billions of
 unknowns.
 
 ``mpi4py-fft`` provides a flexible distributed NumPy array interface,

mpi4py_fft/distarray.py

@@ -273,72 +273,71 @@ def get_pencil_and_transfer(self, axis):
         p1 = self._p0.pencil(axis)
         return p1, self._p0.transfer(p1, self.dtype)
 
-    def redistribute(self, axis=None, darray=None):
+    def redistribute(self, axis=None, out=None):
         """Global redistribution of local ``self`` array
 
-        Note
-        ----
-        Use either ``axis`` or ``darray``, not both.
-
         Parameters
         ----------
         axis : int, optional
             Align local ``self`` array along this axis
-        darray : :class:`.DistArray`, optional
+        out : :class:`.DistArray`, optional
             Copy data to this array of possibly different alignment
 
         Returns
         -------
-        DistArray : darray
-            The ``self`` array globally redistributed. If keyword ``darray`` is
+        DistArray : out
+            The ``self`` array globally redistributed. If keyword ``out`` is
             None then a new DistArray (aligned along ``axis``) is created
-            and returned. Otherwise the provided darray is returned.
+            and returned. Otherwise the provided out array is returned.
         """
         # Take care of some trivial cases first
         if axis == self.alignment:
             return self
 
+        if axis is not None and isinstance(out, DistArray):
+            assert axis == out.alignment
+
         # Check if self is already aligned along axis. In that case just switch
         # axis of pencil (both axes are undivided) and return
         if axis is not None:
             if self.commsizes[self.rank+axis] == 1:
                 self._p0.axis = axis
                 return self
 
-        if axis is None: # darray interface
-            assert isinstance(darray, np.ndarray)
-            assert self.global_shape == darray.global_shape
-            axis = darray.alignment
-            if self.commsizes == darray.commsizes:
+        if out is not None:
+            assert isinstance(out, DistArray)
+            assert self.global_shape == out.global_shape
+            axis = out.alignment
+            if self.commsizes == out.commsizes:
                 # Just a copy required. Should probably not be here
-                darray[:] = self
-                return darray
+                out[:] = self
+                return out
 
             # Check that arrays are compatible
             for i in range(len(self._p0.shape)):
-                if i != self._p0.axis and i != darray._p0.axis:
-                    assert self._p0.subcomm[i] == darray._p0.subcomm[i]
-                    assert self._p0.subshape[i] == darray._p0.subshape[i]
+                if i != self._p0.axis and i != out._p0.axis:
+                    assert self._p0.subcomm[i] == out._p0.subcomm[i]
+                    assert self._p0.subshape[i] == out._p0.subshape[i]
 
         p1, transfer = self.get_pencil_and_transfer(axis)
-        if darray is None:
-            darray = DistArray(self.global_shape,
+        if out is None:
+            out = DistArray(self.global_shape,
                                subcomm=p1.subcomm,
                                dtype=self.dtype,
                                alignment=axis,
                                rank=self.rank)
 
         if self.rank == 0:
-            transfer.forward(self, darray)
+            transfer.forward(self, out)
         elif self.rank == 1:
             for i in range(self.shape[0]):
-                transfer.forward(self[i], darray[i])
+                transfer.forward(self[i], out[i])
         elif self.rank == 2:
             for i in range(self.shape[0]):
                 for j in range(self.shape[1]):
-                    transfer.forward(self[i, j], darray[i, j])
+                    transfer.forward(self[i, j], out[i, j])
 
-        return darray
+        return out
 
 def newDistArray(pfft, forward_output=True, val=0, rank=0, view=False):
     """Return a new :class:`.DistArray` object for provided :class:`.PFFT` object