Streamplot ignores rightmost column and topmost row of velocity data

[pmackenz]

Bug report

Bug summary

streamplot ignores the rightmost column (and topmost row) in U and V and replaces them by a copy of the second to last column (row). This yields wrong stream lines in the rightmost column and topmost row of cells. The issue is most noticeable on coarse grids. (see example plots)

Code for reproduction

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-1, 1, 3)
y = np.linspace(0, 1, 2)

U = np.array([[.2,.2,.2],[.2,1,.2]])
V = np.array([[-1,2,-1],[-1,0.,-1]])

plt.streamplot(x,y, U,V)
plt.quiver(x,y, U,V)
plt.xlim(-1.5,1.5)
plt.ylim(-0.5,1.5)
plt.savefig('StreamPlotIssue1.png')
plt.close()

x = np.linspace(-1, 1, 5)
y = np.linspace(0, 1, 4)

U = np.array([[.2,.2,.2,.2,.2],[.2,.2,.2,.2,.2],[.2,.2,.2,.2,.2],[.2,1.,1.,1,.2]])
V = np.array([[-1,.5,2,.5,-1],[-1,.5,2,.5,-1],[-1,.5,2,.5,-1],[-1,0.,0.,0.,-1]])

plt.streamplot(x,y, U,V)
plt.quiver(x,y, U,V)
plt.xlim(-1.5,1.5)
plt.ylim(-0.5,1.5)
plt.savefig('StreamPlotIssue2.png')
plt.close()

Actual outcome

The first image uses just 2 cells (2 in x, 1 in y direction). The field should create an antisymmetric wave. The left cell is OK, the right one is garbage. (The example is chosen such that the top row issue doesn't show too badly). The overlaid quiver plot shows the correct velocity.

The second image uses 4 cells in x and 3 cells in y-direction for the same velocity field. Quiver shows the correct velocity as overlay. The rightmost column and top row of cells show the wrong streamlines.

For quick reference: the variables used

# image 1
#x:
[-1.  0.  1.]
# y:
[0. 1.]
# U:
[[0.2 0.2 0.2]
 [0.2 1.  0.2]]
# V:
[[-1.  2. -1.]
 [-1.  0. -1.]]

# image 2

#x:
[-1.  -0.5  0.   0.5  1. ]
# y:
[0.         0.33333333 0.66666667 1.        ]
# U:
[[0.2 0.2 0.2 0.2 0.2]
 [0.2 0.2 0.2 0.2 0.2]
 [0.2 0.2 0.2 0.2 0.2]
 [0.2 1.  1.  1.  0.2]]
# V:
[[-1.   0.5  2.   0.5 -1. ]
 [-1.   0.5  2.   0.5 -1. ]
 [-1.   0.5  2.   0.5 -1. ]
 [-1.   0.   0.   0.  -1. ]]

Expected outcome

A streamline plot consistent with velocity shown in quiver overlay.

Matplotlib version

• Operating system:
  MacOS High Sierra (10.13.5)
• Matplotlib version:
  matplotlib-2.1.2-py36h6d6146d_0
• Matplotlib backend (print(matplotlib.get_backend())):
  MacOSX
• Python version:
  3.6
• Jupyter version (if applicable):
  n/a
• Other libraries:
  numpy

Python and matplotlib installed using anaconda3 package

[pharshalp]

The interpolation (in the case of streamplot) might be failing because of fewer number of grid values specified (the V component changes sign and only 3 points are used to capture this change).

If I increase the number of points to 9 (adding evenly spaced values) then the result seems to be correct...

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-1, 1, 9)
y = np.linspace(0, 1, 2)

U = np.array([[.2, .2, .2, .2, .2, .2, .2, .2, .2],
[.2, 0.4, 0.6, 0.8, 1, 0.8, 0.6, 0.4, .2]])
V = np.array([[-1, -0.25, 0.5, 1.25, 2, 1.25, 0.5, -0.25, -1],
[-1, -0.75, -0.5, -0.25, 0., 0.25, 0.5, 0.75, -1]])

plt.streamplot(x, y, U, V)
plt.quiver(x, y, U, V)
plt.xlim(-1.5, 1.5)
plt.ylim(-0.5, 1.5)
plt.savefig('StreamPlotIssue_more_points.png')
plt.close()

[jklymak]

A streamline is defined as the integral of the crossstream velocity, so I wouldn’t be surprised that there are edge effects for a digital representation. If you need a smoother stream plot interpolate the data first.

[pmackenz]

pharshalp, your example shows the same faulty streamplot. Per definition, tangents to streamlines are the velocity. Look at the top, second from the right. There are about 100 degrees between the tangent and the velocity. The integration is simply wrong for the top and the right. Making it larger just makes the faulty domain smaller, but it does not make it right.

jklymak, if the tangent to the streamline does not line up with the velocity, the streamline is wrong. No maybe, no "would not be surprised", just wrong. To make the point stronger: the streamlines are perfect on the left and at the bottom and anywhere but the top and right side.

As for the remaining suggestions: 1 cell (2x2 points) defines a unique interpolated velocity field that can be integrated on a cell by cell base, so even for a single cell. matplotlib uses only the bottom left value when using a single cell. It ignores to top and right.

Proposed issue: somewhere in the code an index goes to number of cells instead of number of nodes, which is cells+1. It is a faulty loop or indexing problem on the upper limit of the horizontal and the vertical limit. FYI, Wolfram mathematica shows how to do it right, even on a single cell.

[jklymak]

Any finite representation will have gridscale inaccuracies compared to a formal definition. If you have a proposed algorithm that deals with those inaccuracies in a different way than the matplotlib implementation of streamline a pull request would receive due attention.

[pmackenz]

OK, I'll look into it. Might take a while till I find the time. Still believe it's a simple indexing issue rather than the overall algorithm.

…

On Mon, Jun 18, 2018 at 7:50 AM Jody Klymak ***@***.***> wrote: Any finite representation will have gridscale inaccuracies compared to a formal definition. If you have a proposed algorithm that deals with those inaccuracies in a different way than the matplotlib implementation of streamline a pull request would receive due attention. — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#11452 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/APJMlCb6QGWEPqt-_NiJLe2PozHrWqW7ks5t975QgaJpZM4Uq77n> .

[pmackenz]

Pull Request with bug fix submitted :)

Here the new, now correct, output of the above sample code:

[pmackenz]

... and here the correct streamlines for your data set:

[ImportanceOfBeingErnest]

Link to potential fix: #11455

[efiring]

closed by #11455