U Y{j9@sxddlmZddlZddlmZmZddlmZddlm Z e dZ ddZ d ej d d fd d ZGdddeZdS))absolute_importN) exceptionsoptional_imports)utils) graph_objsnumpycCstdkrtdtt|dD]6}||d|||d|ddkr tdq tt|dD]6}||d|||d|ddkrhtdqhdS) as Streamline-specific validations Specifically, this checks that x and y are both evenly spaced, and that the package numpy is available. See FigureFactory.create_streamline() for params :raises: (ImportError) If numpy is not available. :raises: (PlotlyError) If x is not evenly spaced. :raises: (PlotlyError) If y is not evenly spaced. Fz.FigureFactory.create_streamline requires numpyrg-C6?z.x must be a 1 dimensional, evenly spaced arrayz.y must be a 1 dimensional, evenly spaced arrayN)np ImportErrorrangelenrZ PlotlyError)xyindexr`/var/www/html/bwave/python/venv/lib/python3.8/site-packages/plotly/figure_factory/_streamline.pyvalidate_streamline s ((rr g ףp= ?cKst||t||t||tj||dt|||||||\}} t|||||||\} } tjf|| | | dd|} | g} tj dd}tj | |dS)aa Returns data for a streamline plot. :param (list|ndarray) x: 1 dimensional, evenly spaced list or array :param (list|ndarray) y: 1 dimensional, evenly spaced list or array :param (ndarray) u: 2 dimensional array :param (ndarray) v: 2 dimensional array :param (float|int) density: controls the density of streamlines in plot. This is multiplied by 30 to scale similiarly to other available streamline functions such as matplotlib. Default = 1 :param (angle in radians) angle: angle of arrowhead. Default = pi/9 :param (float in [0,1]) arrow_scale: value to scale length of arrowhead Default = .09 :param kwargs: kwargs passed through plotly.graph_objs.Scatter for more information on valid kwargs call help(plotly.graph_objs.Scatter) :rtype (dict): returns a representation of streamline figure. Example 1: Plot simple streamline and increase arrow size >>> from plotly.figure_factory import create_streamline >>> import plotly.graph_objects as go >>> import numpy as np >>> import math >>> # Add data >>> x = np.linspace(-3, 3, 100) >>> y = np.linspace(-3, 3, 100) >>> Y, X = np.meshgrid(x, y) >>> u = -1 - X**2 + Y >>> v = 1 + X - Y**2 >>> u = u.T # Transpose >>> v = v.T # Transpose >>> # Create streamline >>> fig = create_streamline(x, y, u, v, arrow_scale=.1) >>> fig.show() Example 2: from nbviewer.ipython.org/github/barbagroup/AeroPython >>> from plotly.figure_factory import create_streamline >>> import numpy as np >>> import math >>> # Add data >>> N = 50 >>> x_start, x_end = -2.0, 2.0 >>> y_start, y_end = -1.0, 1.0 >>> x = np.linspace(x_start, x_end, N) >>> y = np.linspace(y_start, y_end, N) >>> X, Y = np.meshgrid(x, y) >>> ss = 5.0 >>> x_s, y_s = -1.0, 0.0 >>> # Compute the velocity field on the mesh grid >>> u_s = ss/(2*np.pi) * (X-x_s)/((X-x_s)**2 + (Y-y_s)**2) >>> v_s = ss/(2*np.pi) * (Y-y_s)/((X-x_s)**2 + (Y-y_s)**2) >>> # Create streamline >>> fig = create_streamline(x, y, u_s, v_s, density=2, name='streamline') >>> # Add source point >>> point = go.Scatter(x=[x_s], y=[y_s], mode='markers', ... marker_size=14, name='source point') >>> fig.add_trace(point) # doctest: +SKIP >>> fig.show() )density arrow_scalelines)r rmodeZclosest)Z hovermode)datalayout) rZvalidate_equal_lengthrZvalidate_positive_scalars _Streamlinesum_streamlinesget_streamline_arrowsrZScatterZLayoutZFigure)r ruvranglerkwargs streamline_x streamline_yZarrow_xZarrow_yZ streamlinerrrrrcreate_streamline's@I      r#c@sPeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dS)rzB Refer to FigureFactory.create_streamline() for docstring c Kst||_t||_t||_t||_||_||_td||_ |jd|jd|_ |jd|jd|_ |j|_ |j|_ t|j |j f|_t|jt|j d|_t|jt|j d|_g|_|j|jd|jd|_|j|jd|jd|_t|jd|jd|_|jt|j9_|jt|j9_g|_g|_||\} } |\} } dS)Nrr)r arrayr rrrrrintrdelta_xdelta_yval_xval_yZzerosblankr float spacing_x spacing_y trajectoriessqrtspeedst_xst_yget_streamlinesrr) selfr rrrrrrr r!r"arrows_xarrows_yrrr__init__s2     z_Streamline.__init__cCs$t||jdt||jdfS)zQ Set up positions for trajectories to be used with rk4 function. ?)r(r/r0)r7xiyirrr blank_possz_Streamline.blank_posc Cst|tjr&|t|_|t|_nt||_t||_||j|jf}||j|jdf}||jd|jf}||jd|jdf}||j}||j} |d|||} |d|||} | d| | | S)zK Set up for RK4 function, based on Bokeh's streamline code r) isinstancer ZndarrayZastyper(r rr+r,) r7ar<r=Za00Za01Za10Za11ZxtZytZa0Za1rrrvalue_ats      z_Streamline.value_atcsfdd}fdd}fddggfdd}||||\}}}||||\} } } || } | d d d |d d } | d d d |d d }t| d krd S| d kr܈||\}}d j||f<| |fStD]\}}d j||f<qd Sd S)z RK4 forward and back trajectories from the initial conditions. Adapted from Bokeh's streamline -uses Runge-Kutta method to fill x and y trajectories then checks length of traj (s in units of axes) csDdj||}j||}j||}||||fSNg?rAr3rrr<r=Zdt_dsZuivir7rrfsz$_Streamline.rk4_integrate..fcsHdj||}j||}j||}| || |fSrBrCrDrFrrgsz$_Streamline.rk4_integrate..gcsDd|kotjdknoBd|ko>tjdkSS)Nrr)r r r)r<r=rFrrz+_Streamline.rk4_integrate..csd}d}|}|}||\}}g} g} ||r| || |z||||\} } ||d|| |d|| \} }||d|| |d||\}}|||||||\}}Wntk rYqYnX||| d| d||d7}||| d|d||d7}||s8q||7}||\}}||ksd||krj||fdkrdj||f<|||}|}nq|dkr(qq(|| | fS)Ng{Gz?rr;r&g@r)r>append IndexErrorr-)x0y0rGZdsstotalr<r=xbybxf_trajyf_trajZk1xZk1yZk2xZk2yZk3xZk3yZk4xZk4yZnew_xbZnew_ybcheckr7Z xb_changesZ yb_changesrrrk4sD   &&" $$   z&_Streamline.rk4_integrate..rk4Nr%rg?r)r r>r-zip)r7rMrNrGrHrVZsfrRrSsbZxb_trajZyb_trajrOZx_trajZy_trajZinitxbZinitybrPrQrrTr rk4_integrates(   % z_Streamline.rk4_integratecCsj|dks$||jks$|dks$||jkr(dS|j||fdkrf|||j||j}|dk rf|j|dS)z Integrate trajectories :param (int) xb: results of passing xi through self.blank_pos :param (int) xy: results of passing yi through self.blank_pos Calculate each trajectory based on rk4 integrate method. rN)rr-rYr/r0r1rK)r7rPrQtrrrtrajs $z_Streamline.trajcs$tjdD]p}tjd|D]X}|||||jd||||jd|||q$qfddjD_fddjD_ttjD]*}j|j|<j|t j qttjD]*}j|j|<j|t j qdS)z= Get streamlines by building trajectory set. r&rcs*g|]"}t|djjdqS)r)r r'r)r .0rZrFrr 0sz/_Streamline.get_streamlines..cs*g|]"}t|djjdqS)rr)r r'r*rr\rFrrr^3sN) r rr[r1r4r5r tolistrKr nan)r7indentr<rrrFrr6%s$  z_Streamline.get_streamlinescCstt|j}tt|j}tt|j}tt|j}tt|jD]}|j|tt|j|d||<|j|tt|j|dd||<|j|tt|j|d||<|j|tt|j|dd||<qN||}||}t}tjdddt ||} tjf|| |j } | |j } t | |j } t | |j } t | |j }t | |j }tt|}tt|}tt|}tt|}tt|D]}||dkr(||| |||<||| |||<||||||<||||||<nP||| |||<||| |||<||||||<||||||<qtt|}tj|dd<t||||g}t|}|d}|}t||||g}t|}|d}|}||fS)a_ Makes an arrow for each streamline. Gets angle of streamline at 1/3 mark and creates arrow coordinates based off of user defined angle and arrow_scale. :param (array) st_x: x-values for all streamlines :param (array) st_y: y-values for all streamlines :param (angle in radians) angle: angle of arrowhead. Default = pi/9 :param (float in [0,1]) arrow_scale: value to scale length of arrowhead Default = .09 :rtype (list, list) arrows_x: x-values to create arrowhead and arrows_y: y-values to create arrowhead rignore)divideinvalidrNF)r emptyr r4r5r r(ZgeterrZseterrZarctanrcosrsinr`matrixr'flattenr_)r7Z arrow_end_xZ arrow_end_yZ arrow_start_xZ arrow_start_yrZdif_xZdif_yZorig_errZstreamline_angZang1Zang2Zseg1_xZseg1_yZseg2_xZseg2_yZpoint1_xZpoint1_yZpoint2_xZpoint2_yspacer8r9rrrr?sd$$        z!_Streamline.get_streamline_arrowscCs t|jg}t|jg}||fS)a Makes all streamlines readable as a single trace. :rtype (list, list): streamline_x: all x values for each streamline combined into single list and streamline_y: all y values for each streamline combined into single list )sumr4r5)r7r!r"rrrrs  z_Streamline.sum_streamlinesN) __name__ __module__ __qualname____doc__r:r>rArYr[r6rrrrrrrs!NOr) __future__rmathZplotlyrrZplotly.figure_factoryrZplotly.graph_objsrZ get_moduler rpir#objectrrrrrs     _