intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/streamplot.cpython-312.pyc

Ë
†RjË]ãó
—dZd
dl
Zd
dlZd
dlmZmZmZ
d
dlm	Z

d
dlmZ

d
dlmZ
dg
Z					dd„
ZGd„d«ZGd„d	«ZGd
„d«ZGd„d
«ZGd„de«ZGd„de«Zd„ZGd„de«Zdd„
Zd„Zd„Zd„Z y)z,
Streamline plotting for 2D vector fields.

éN)Ú_apiÚcmÚpatchesÚ
streamplotc	ó
—t
|
|«}t|«
}t||«}|€tjj
}|
€|j}
|€|jj«}|€tjd}i}t|d|
z¬«}tjgd¢
|¬«
|dk(r|dz}t|tj «}|rG|j"|j"k7rt%d	«
‚
gg
}tj&j)|«
}n
||d
<||d
<t|tj «r*|j"|j"k7rt%d«
‚
g|d<n
||d<||d<||d
<||d
<|j"|j"k7s|j"|j"k7rt%d«
‚
tj&j)|«
}tj&j)|«
}t+||||||«}g}|€]t-|j"«
D]C\}}|||fdk(s
Œ|j/||«\}}||||«} | €
Œ3|j1| «

ŒE�
n]tj2|t4¬«j7«}!|!D]t\}"}#|j8|"cxkr|j8|j:zkr2n
n/|j<|#cxkr|j<|j>zkr
Œbn

t%d|"›d|#›d�«
‚
|!d
d
…dfxx|j8zcc<|!d
d
…dfxx|j<zcc<|!D]€\}"}#|jA|"|#«\}}tjB|d|jDdz
«}tjB|d|jFdz
«}||||«} | €
Œp|j1| «

Œ‚|rI|	€2tIjJ|jM«|jO««}	tQjR|«
}g}$g}%|D�]0} | jT\}&}'|jW|&|'«\}(})|(|j8z
}(|)|j<z
})t|tj «s|rUtjX|(|)g«
j[ddd«}*|$j]tj^|*d
d|*dd
g«
«

n(tjX|(|)g«
}*|$j1|*«

tj`tjbtjd|(«
tjd|)«
««
}+tjf|+|+ddz«},|(|,|)|,f}-tjh|(|,|,dz«
tjh|)|,|,dz«
f}.t|tj «r,tk||&|'«d
d}/|dj]|/«

|/|,|d<|r5tk||&|'«d
d}0j1|0«

||	|0|,«
«
|d
<tmjn|-|.fd|
i
|¤
Ž
}1|%j1|1«

�Œ3tqjr|$f
d|
i
|¤
Ž
}2|j8|j8|j:zg|2jtjvd
d
|j<|j<|j>zg|2jtjxd
d
|rP|2j{tj&j_«
«

|2j}|«

|2j|	«

|j�|2«

tqj‚|%«
}3|%D]}1|j…|1«

Œ|j‡«
t‰|2|3«}4|4S)aµ
    Draw streamlines of a vector flow.

    Parameters
    ----------
    x, y : 1D/2D arrays
        Evenly spaced strictly increasing arrays to make a grid.  If 2D, all
        rows of *x* must be equal and all columns of *y* must be equal; i.e.,
        they must be as if generated by ``np.meshgrid(x_1d, y_1d)``.
    u, v : 2D arrays
        *x* and *y*-velocities. The number of rows and columns must match
        the length of *y* and *x*, respectively.
    density : float or (float, float)
        Controls the closeness of streamlines. When ``density = 1``, the domain
        is divided into a 30x30 grid. *density* linearly scales this grid.
        Each cell in the grid can have, at most, one traversing streamline.
        For different densities in each direction, use a tuple
        (density_x, density_y).
    linewidth : float or 2D array
        The width of the streamlines. With a 2D array the line width can be
        varied across the grid. The array must have the same shape as *u*
        and *v*.
    color : :mpltype:`color` or 2D array
        The streamline color. If given an array, its values are converted to
        colors using *cmap* and *norm*.  The array must have the same shape
        as *u* and *v*.
    cmap, norm
        Data normalization and colormapping parameters for *color*; only used
        if *color* is an array of floats. See `~.Axes.imshow` for a detailed
        description.
    arrowsize : float
        Scaling factor for the arrow size.
    arrowstyle : str
        Arrow style specification.
        See `~matplotlib.patches.FancyArrowPatch`.
    minlength : float
        Minimum length of streamline in axes coordinates.
    start_points : (N, 2) array
        Coordinates of starting points for the streamlines in data coordinates
        (the same coordinates as the *x* and *y* arrays).
    zorder : float
        The zorder of the streamlines and arrows.
        Artists with lower zorder values are drawn first.
    maxlength : float
        Maximum length of streamline in axes coordinates.
    integration_direction : {'forward', 'backward', 'both'}, default: 'both'
        Integrate the streamline in forward, backward or both directions.
    data : indexable object, optional
        DATA_PARAMETER_PLACEHOLDER
    broken_streamlines : boolean, default: True
        If False, forces streamlines to continue until they
        leave the plot domain.  If True, they may be terminated if they
        come too close to another streamline.

    Returns
    -------
    StreamplotSet
        Container object with attributes

        - ``lines``: `.LineCollection` of streamlines

        - ``arrows``: `.PatchCollection` containing `.FancyArrowPatch`
          objects representing the arrows half-way along streamlines.

        This container will probably change in the future to allow changes
        to the colormap, alpha, etc. for both lines and arrows, but these
        changes should be backward compatible.
    Nzlines.linewidthé
)Ú
arrowstyleÚmutation_scale)ÚbothÚforwardÚbackward)
Úintegration_directionrg@z?If 'color' is given, it must match the shape of the (x, y) gridÚcolorzCIf 'linewidth' is given, it must match the shape of the (x, y) gridÚ	linewidthÚzorderz3'u' and 'v' must match the shape of the (x, y) gridr)
ÚdtypezStarting point (z, z) outside of data boundariesé
éÿÿÿÿéÚ	transform)EÚGridÚ
StreamMaskÚ	DomainMapÚmlinesÚLine2DrÚ	transDataÚ
_get_linesÚget_next_colorÚmplÚrcParamsÚdictrÚ
check_in_listÚ
isinstanceÚnpÚndarrayÚshapeÚ
ValueErrorÚmaÚmasked_invalidÚ_get_integratorÚ_gen_starting_pointsÚ	mask2gridÚappendÚ
asanyarrayÚfloatÚcopyÚx_originÚwidthÚy_originÚheightÚ	data2gridÚclipÚnxÚnyÚmcolorsÚ	NormalizeÚminÚmaxrÚ_ensure_cmapÚ
TÚ	grid2dataÚ	transposeÚreshapeÚextendÚhstackÚcumsumÚhypotÚdiffÚsearchsortedÚmeanÚ
interpgridrÚFancyArrowPatchÚmcollectionsÚLineCollectionÚsticky_edgesÚ
xÚ
yÚ	set_arrayÚset_cmapÚset_normÚadd_collectionÚPatchCollectionÚ	add_patchÚautoscale_viewÚ
StreamplotSet)5ÚaxesrNrOÚ
uÚ
vÚdensityrrÚcmapÚnormÚ	arrowsizer	Ú	minlengthrrÚstart_pointsÚ	maxlengthrÚbroken_streamlinesÚgridÚmaskÚdmapÚline_kwÚarrow_kwÚuse_multicolor_linesÚline_colorsÚ	integrateÚtrajectoriesÚxmÚymÚxgÚygÚ
tÚsp2ÚxsÚysÚstreamlinesÚarrowsÚtgxÚtgyÚtxÚtyÚpointsÚ
sÚ
nÚ
arrow_tailÚ
arrow_headÚline_widthsÚcolor_valuesÚ
pÚlcÚacÚstream_containers5                                                     úX/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/streamplot.pyrrsÞ€ôR�
�1‹:€DÜ�gÓ€DÜ�T˜4Ó €Dà
€~Ü—‘×%Ñ%ˆðÐØ—N‘Nˆ	à€}Ø—‘×.Ñ.Ó0ˆàÐÜ—L‘LÐ!2Ñ3ˆ	à€Gܘz¸"¸y¹.ÔI€Hä×ÑÒ6Ø-Bõ
D
ð Ò&Ø�R‰ˆ	ä% e¬R¯Z©ZÓ8ÐÙØ�;‰;˜$Ÿ*™*Ò$Üð
/ó
0ð

0à�dˆÜ—‘×$Ñ$ UÓ+‰à ˆ�ÑØ!ˆ�Ñä�)œRŸZ™ZÔ(Ø�?‰?˜dŸj™jÒ(Üð
8ó
9ð

9à!ˆ�Òà(ˆ�ÑØ )ˆ�Ñà€GˆHÑØ€HˆXÑð	‡w�w�$—*‘*Ò 
§¡¨4¯:©:Ò 5ÜÐNÓOÐOä
�‰×јQÓ€AÜ
�‰×јQÓ€Aä 
 1 d¨I°yØ 5ó
7€Ið€LØÐÜ*¨4¯:©:Ó6ò	+‰FˆB�Ø�B˜�F‰|˜qÓ ØŸ™¨¨BÓ/‘��BÙ˜b "Ð&8Ó9�
Ø‘=Ø ×'Ñ'¨
Õ*ò	+ô�m‰m˜L´Ô6×;Ñ;Ó=ˆðò	4‰FˆB�Ø—M‘M RÔE¨4¯=©=¸4¿:¹:Ñ+EÕEØ—M‘M RÔF¨4¯=©=¸4¿;¹;Ñ+FÕFÜ Ð#3°B°4°r¸"¸ð
>3ð
"3ó
4ð
4ð	4ð	ŠAˆqˆD‹	�T—]‘]Ñ"‹	ØŠAˆqˆD‹	�T—]‘]Ñ"‹	àò	'‰FˆB�Ø—^‘^ B¨Ó+‰FˆB�ô
—‘˜˜Q §¡¨!¡Ó,ˆBÜ—‘˜˜Q §¡¨!¡Ó,ˆBá˜"˜bÐ"4Ó5ˆA؉}Ø×#Ñ# AÕ&ð	'ñ؈<Ü×$Ñ$ U§Y¡Y£[°%·)±)³+Ó>ˆDÜ�‰˜tÓ$ˆà€KØ
€FØ
ó!ˆ
Ø—3‘3‰ˆˆSà—‘  SÓ)‰ˆˆBØ
ˆd�m‰mшØ
ˆd�m‰mшô�i¤§¡Ô,Ñ0DÜ—\‘\ 2 r (Ó+×3Ñ3°B¸
¸1Ó=ˆFØ×ÑœrŸy™y¨&°°"¨+°v¸a¸b°zÐ)BÓCÕDä—\‘\ 2 r (Ó+ˆFØ×Ñ˜vÔ&ô
�I‰I”b—h‘hœrŸw™w r›{¬B¯G©G°B«KÓ8Ó9ˆ
Ü�O‰O˜A˜q ™u r™zÓ*ˆ
ؘ‘e˜R 
™U�^ˆ
Ü—g‘g˜b  1 q¡5˜kÓ*¬B¯G©G°B°q¸¸Q¹°KÓ,@ÐAˆ
ä�i¤§¡Ô,Ü$ Y°°SÓ9¸#¸2Ð>ˆKØ�KÑ ×'Ñ'¨Ô4Ø$/°
¡NˆH�[Ñ!áÜ% e¨S°#Ó6°s¸Ð;ˆLØ×Ñ˜|Ô,Ù $¡T¨,°q©/Ó%:Ó ;ˆH�WÑä×#Ñ#Ø˜
ñ

E
Ø.7ð

E
Ø;Cñ

E
ˆ
à�
‰
�aÖðC
!ôF

×	$Ñ	$Øñ

5Ø(ð

5Ø,3ñ

5€Bà ŸM™M¨4¯=©=¸4¿:¹:Ñ+EÐF€B‡O�O×Ñ‘aÐØ ŸM™M¨4¯=©=¸4¿;¹;Ñ+FÐG€B‡O�O×Ñ‘aÐÙØ
�‰”R—U‘U—\‘\ +Ó.Ô/Ø
�‰�DÔØ
�‰�DÔØ×јÔä	×	%Ñ	% fÓ	-€Bà
ò
ˆ
Ø�‰�qÕð
ð	×ÑÔÜ$ R¨Ó,ÐØÐóc
ó—eZ
dZd
„Zy)rWcó —|
|_||_
y©
N)Úlinesru)ÚselfrŠrus   r…Ú__init__zStreamplotSet.__init__ûs€ØˆŒ
؈�r†N)Ú__name__Ú
__module__Ú__qualname__rŒ©r†r…rWrWùs„ór†rWcóJ—eZ
dZd
Zd„Zd„Zd„Zd„Zd„Zdd„
Z	d„Z
dd	„
Zd
„Zy)
ra
    Map representing different coordinate systems.

    Coordinate definitions:

    * axes-coordinates goes from 0 to 1 in the domain.
    * data-coordinates are specified by the input x-y coordinates.
    * grid-coordinates goes from 0 to N and 0 to M for an N x M grid,
      where N and M match the shape of the input data.
    * mask-coordinates goes from 0 to N and 0 to M for an N x M mask,
      where N and M are user-specified to control the density of streamlines.

    This class also has methods for adding trajectories to the StreamMask.
    Before adding a trajectory, run `start_trajectory` to keep track of regions
    crossed by a given trajectory. Later, if you decide the trajectory is bad
    (e.g., if the trajectory is very short) just call `undo_trajectory`.
    cóP
—|
|_||_
|jd
z
|
jd
z
z|_|jd
z
|
jd
z
z|_d|jz|_d|j
z|_d|
jz|_	d|
jz|_y)Nrçð?)rcrdr7Úx_grid2maskr8Úy_grid2maskÚx_mask2gridÚy_mask2gridÚdxÚx_data2gridÚdyÚy_data2grid)r‹rcrds   r…rŒzDomainMap.__init__
s�€ØˆŒ	؈Œ	à ŸG™G a™K¨D¯G©G°a©KÑ8ˆÔØ ŸG™G a™K¨D¯G©G°a©KÑ8ˆÔà × 0Ñ 0Ñ0ˆÔØ × 0Ñ 0Ñ0ˆÔà §¡™<ˆÔØ §¡™<ˆÕr†cób—t
|
|jz«
t
||jz«
fS)
z;Return nearest space in mask-coords from given grid-coords.)Úroundr”r•©r‹ÚxiÚyis   r…Ú	grid2maskzDomainMap.grid2mask#
s-€ä�R˜$×*Ñ*Ñ*Ó+¬U°2¸×8HÑ8HÑ3HÓ-IÐIÐIr†có>—|
|jz||jzfSr‰)r–r—)r‹rlrms   r…r,zDomainMap.mask2grid'
ó#€Ø�D×$Ñ$Ñ$ b¨4×+;Ñ+;Ñ&;Ð;Ð;r†có>—|
|jz||jzfSr‰©r™r›)r‹ÚxdÚyds   r…r5zDomainMap.data2grid*
r£r†có>—|
|jz||jzfSr‰r¥)r‹rnros   r…r?zDomainMap.grid2data-
r£r†cóh—|j
|
|«\}}|jj|||«
yr‰)r¡rdÚ_start_trajectory©r‹rnrorbrlrms      r…Ústart_trajectoryzDomainMap.start_trajectory0
s-€Ø—‘  BÓ'‰ˆˆBØ�	‰	×#Ñ# B¨Ð,>Õ?r†cóT—|j
|
|«\}}||f|j_yr‰)r¡rdÚ_current_xy)r‹rnrorlrms     r…Úreset_start_pointzDomainMap.reset_start_point4
s&€Ø—‘  BÓ'‰ˆˆBØ!# R ˆ�	‰	Õr†có¬—|jj|
|«st‚
|j|
|«\}}|jj|||«
yr‰)rcÚwithin_gridÚInvalidIndexErrorr¡rdÚ_update_trajectoryr«s      r…Úupdate_trajectoryzDomainMap.update_trajectory8
sG€Ø�y‰y×$Ñ$ R¨Ô,Ü#Ð#Ø—‘  BÓ'‰ˆˆBØ�	‰	×$Ñ$ R¨Ð-?Õ@r†c
ó8—|jj«
yr‰)rdÚ_undo_trajectory©
r‹s
 r…Úundo_trajectoryzDomainMap.undo_trajectory>
s€Ø�	‰	×"Ñ"Õ$r†N©
T)
r�rŽr�Ú__doc__rŒr¡r,r5r?r¬r¯r´r¸r�r†r…rr
s7„ñò$(òJ
ò
<ò
<ò
<ó@
ò)óA
ó
%r†rcó,—eZ
dZd
Zd„Zed„«Zd„Zy)rz
Grid of data.có¦—t
j|
«
d
k(r
nLt
j|
«
dk(r)|
d}t
j||
«std«
‚
|}
ntd«
‚
t
j|«
d
k(r
nat
j|«
dk(r>t
j|«
}|d}t
j||«std«
‚
|}ntd«
‚
t
j
|
«
dkDj
«std«
‚
t
j
|«
dkDj
«std	«
‚
t|
«
|_t|«
|_	|
d
|
dz
|_
|d
|dz
|_|
d|_|d|_
|
d
|
dz
|_|d
|dz
|_t
jt
j
|
«
|j|jd
z
z«std«
‚
t
jt
j
|«
|j|jd
z
z«std«
‚
y)
NrrrzThe rows of 'x' must be equalz$'x' can have at maximum 2 dimensionsz The columns of 'y' must be equalz$'y' can have at maximum 2 dimensionsz'x' must be strictly increasingz'y' must be strictly increasingrz!'x' values must be equally spacedz!'y' values must be equally spaced)r$ÚndimÚallcloser'r@rFÚallÚlenr7r8r˜ršr1r3r2r4)r‹rNrOÚx_rowÚytÚy_cols      r…rŒz
Grid.__init__D
så
ۊ
�7‰7�1‹:˜Š?ØÜ
�W‰W�Q‹Z˜1Š_Ø�a‘DˆEÜ—;‘;˜u aÔ(Ü Ð!@ÓAÐA؉AäÐCÓDÐDä
�7‰7�1‹:˜Š?ØÜ
�W‰W�Q‹Z˜1Š_Ü—‘˜a“ˆBØ�q‘EˆEÜ—;‘;˜u bÔ)Ü Ð!CÓDÐD؉AäÐCÓDÐDä—‘˜
“
˜Q‘×#Ñ#Ô%ÜÐ>Ó?Ð?Ü—‘˜
“
˜Q‘×#Ñ#Ô%ÜÐ>Ó?Ð?ä�a“&ˆŒÜ�a“&ˆŒà�A‘$˜˜1™‘+ˆŒØ�A‘$˜˜1™‘+ˆŒà˜!™ˆŒ
ؘ!™ˆŒ
à�r‘U˜Q˜q™T‘\ˆŒ
ؘ‘e˜a 
™d‘lˆŒä�{‰{œ2Ÿ7™7 1›: t§z¡z°T·W±W¸q±[Ñ'AÔBÜÐ@ÓAÐAÜ�{‰{œ2Ÿ7™7 1›: t§{¡{°d·g±gÀ
±kÑ'BÔCÜÐ@ÓAÐAðD
r†c
ó2—|j|jfSr‰)r8r7r·s
 r…r&z
Grid.shapeq
s€à�w‰w˜Ÿ™ÐÐr†cóz—d
|
cxkx
r
|jdz
knc
x
r
d
|cxkx
r
|jdz
kSc
S)z9Return whether (*xi*, *yi*) is a valid index of the grid.rr)r7r8ržs   r…r±zGrid.within_gridu
s9€ð�BÖ%˜$Ÿ'™' A™+Ô%Ò@¨!¨rÖ*@°T·W±W¸q±[Ñ*@Ð@Ñ*@Ð@r†N)r�rŽr�rºrŒÚpropertyr&r±r�r†r…rrB
s&„Ùò+B
ðZ
ñ
 óð
 óA
r†rcó2—eZ
dZd
Zd„Zd„Zdd„
Zd„Zdd„
Zy)	raN

    Mask to keep track of discrete regions crossed by streamlines.

    The resolution of this grid determines the approximate spacing between
    trajectories. Streamlines are only allowed to pass through zeroed cells:
    When a streamline enters a cell, that cell is set to 1, and no new
    streamlines are allowed to enter.
    có¨
—	d
t
j|
d«zjt«
\|_|_|jdks|j
dkrt
d«
‚
t
j|j
|jf«
|_|jj|_	d|_
y#t$r}t
d«
|‚d}~w
wxYw
)Nérz,'density' must be a scalar or be of length 2rz'density' must be positive)r$Úbroadcast_toÚastypeÚintr7r8r'ÚzerosÚ_maskr&r®)r‹r[Úerrs   r…rŒzStreamMask.__init__†
s°€ð	+Ø "¤R§_¡_°W¸aÓ%@Ñ @×HÑHÌÓMÑˆDŒG�T”Wð�7‰7�QŠ;˜$Ÿ'™' Aš+ÜÐ9Ó:Ð:Ü—X‘X˜tŸw™w¨¯©Ð0Ó1ˆŒ
Ø—Z‘Z×%Ñ%ˆŒ
àˆÕøôò	+Üð
!ó
"Ø'*ð

+ûð	+ús‚9B7Â7	CÃCÃCcó —|j|
Sr‰)
rÎ)r‹Úargss  r…Ú__getitem__zStreamMask.__getitem__“
s€Ø�z‰z˜$ÑÐr†có8—g|_|j|
||«
y
)z%Start recording streamline trajectoryN)Ú_trajr³©r‹rlrmrbs    r…rªzStreamMask._start_trajectory–
s€àˆŒ
Ø×Ñ  BÐ(:Õ;r†c
óD—|jD]}
d
|j|
<Œy)z#Remove current trajectory from maskrN)rÔrÎ)r‹rps  r…r¶zStreamMask._undo_trajectory›
s"€à—‘ò
	ˆA؈D�J‰J�qŠMñ
	r†có¼—|j|
|fk7rK|||
fd
k(r8|jj||
f«

d|j||
f<|
|f|_y|rt‚
yy)zŽ
        Update current trajectory position in mask.

        If the new position has already been filled, raise `InvalidIndexError`.
        rrN)r®rÔr-rÎr²rÕs    r…r³zStreamMask._update_trajectory 
sk€ð×Ñ  B˜xÒ'Ø�B˜�F‰|˜qÒ Ø—
‘
×!Ñ! 2 r (Ô+Ø%&�—
‘
˜2˜r˜6Ñ"Ø$&¨ 8�Õ á%Ü+Ð+àð(r†Nr¹)	r�rŽr�rºrŒrÒrªr¶r³r�r†r…rr|
s „ñò ò
 ó<ò
ô
r†rc
ó—eZ
dZy
)r²N©r�rŽr�r�r†r…r²r²²
ó„Ør†r²c
ó—eZ
dZy
)ÚTerminateTrajectoryNrÙr�r†r…rÜrܶ
rÚr†rÜcó2
‡‡
‡‡‡‡‡	‡
‡—‰j
‰‰
«\ŠŠ
‰‰jjd
z
z}‰
‰jjd
z
z}tj
j
|dz|dzz«
Šˆˆˆˆ
fd„Š
ˆ
f
d„Š	dˆ	ˆˆ
ˆˆˆfd„	}|S)NrrcóÒ•—‰jj||
«st‚
t‰||
«}|d
k(r
t	«‚
d|z}t‰||
«}t‰	||
«}||z||zfS)Nrr“)rcr±ÚOutOfBoundsrIrÜ)
rŸr Úds_dtÚdt_dsÚuiÚvireÚspeedrYrZs
      €€€€r…Úforward_timez%_get_integrator.<locals>.forward_timeÇ
ssø€Ø�y‰y×$Ñ$ R¨Ô,ÜÐܘ5 " bÓ)ˆØ�AŠ:Ü%Ó'Ð'Ø�U‘
ˆÜ
˜
˜2˜rÓ
"ˆÜ
˜
˜2˜rÓ
"ˆØ�E‰z˜2 ™:Ð%Ð%r†có(•
—‰||
«\}}||fSr‰r�)rŸr ÚdxiÚdyirås    €r…Ú
backward_timez&_get_integrator.<locals>.backward_timeÒ
s!ø€Ù  BÓ'‰ˆˆS؈t�c�TˆzÐr†có�
•—d
g}}	‰j
||
|«
‰
dvr#t||
‰‰‰|«\}}||z
}||ddd…z
}‰
dvr2‰j||
«
t||
‰‰	‰|«\}}||z
}||ddz
}|‰kDr,t	j
|t	jd«
«dS‰j«
y#t$r
YywxYw
)	a¢

        Return x, y grid-coordinates of trajectory based on starting point.

        Integrate both forward and backward in time from starting point in
        grid coordinates.

        Integration is terminated when a trajectory reaches a domain boundary
        or when it crosses into an already occupied cell in the StreamMask. The
        resulting trajectory is None if it is shorter than `minlength`.
        gN)rr
r)rrr)rrr)r¬r²Ú_integrate_rk12r¯r$Úbroadcast_arraysÚemptyr¸)
Úx0Úy0rbÚstotalÚxy_trajr{Úxytrérerårrar_s
       €€€€€€r…rjz"_get_integrator.<locals>.integrateÖ
s
ø€ð˜b�ˆð	Ø×!Ñ! " bÐ*<Ô=ð!Ð$8Ñ8Ü$ R¨¨T°=À)Ø%7ó
9‰FˆAˆsà�a‰KˆFØ�s™4˜R˜4‘yÑ ˆGà Ð$7Ñ7Ø×"Ñ" 2 rÔ*Ü$ R¨¨T°<ÀØ%7ó
9‰FˆAˆsà�a‰KˆFØ�s˜1˜2�wÑˆGà�IÒÜ×&Ñ& w´·±¸Ó0@ÓAÀ!ÑDÐDà× Ñ Ô"Øøô'!ò
	Ùð
	ús‡B9Â9	CÃ
Cr¹)r5rcr7r8r$r(Úsqrt)rYrZrer_rarÚu_axÚv_axrjréråräs``````   @@@r…r*r*½
s†ÿø€ð�>‰>˜!˜QÓ�D€A€qð
�—	‘	—‘˜qÑ Ñ!€DØ�—	‘	—‘˜qÑ Ñ!€DÜ�E‰E�J‰J�t˜q‘y 4¨1¡9Ñ,Ó-€E÷	&ô÷#ò#ðJ
Ðr†c
ó—eZ
dZy
)rßNrÙr�r†r…rßrßþ
rÚr†rßcóH—d
}t
d|jjzd|jjzd«}|}d}	|}
|
}g}		|jj|
|«r|j
|
|f«

nt‚
||
|«\}
}||
||
zz|||zz«\}}||
z}||z}|dz|
|zz}|dz||zz}|jj\}}tj||z
|dz
z||z
|dz
z«}||kr0|
|z
}
||z
}	|j|
||«
|	|z|kDr	|	|fS|	|z
}	|dk(r|}nt
|d|z||zdzz«}�
Œ#t$r
|rt|||«\}}|	|z
}	Y|	|fSt$r
Y|	|fSwxYw
#t$r
Y|	|fSwxYw
)a
    2nd-order Runge-Kutta algorithm with adaptive step size.

    This method is also referred to as the improved Euler's method, or Heun's