o d8@sxddlmZddlZddlmZmZddlmZddlm Z e dZ ddZ d ej d d fd d ZGdddeZdS))absolute_importN) exceptionsoptional_imports)utils) graph_objsnumpycCstdurtdtt|dD]}||d|||d|ddkr+tdqtt|dD]}||d|||d|ddkrOtdq4dS) 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 ImportErrorrangelenr PlotlyError)xyindexrf/var/www/html/visualizacion-main/env/lib/python3.10/site-packages/plotly/figure_factory/_streamline.pyvalidate_streamline s ((rr g ףp= ?cKst||t||t||tj||dt|||||||\}} t|||||||\} } tjd|| | | 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)rrmodeclosest) hovermode)datalayoutNr) rvalidate_equal_lengthrvalidate_positive_scalars _Streamlinesum_streamlinesget_streamline_arrowsrScatterLayoutFigure)rruvranglerkwargs streamline_x streamline_yarrow_xarrow_y 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 arrayrrr%r&r'rintrdelta_xdelta_yval_xval_yzerosblankr float spacing_x spacing_y trajectoriessqrtspeedst_xst_yget_streamlinesr r!) selfrrr%r&rr'rr(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. ?)r3r;r<)rCxiyirrr blank_poss$z_Streamline.blank_posc Cst|tjr|t|_|t|_n t||_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 ndarrayastyper3rrr6r7) rCarHrIa00a01a10a11xtyta0a1rrrvalue_ats      z_Streamline.value_atcsfdd}fdd}fddggfdd}||||\}}}||||\} } } || } | d d d |d d } | d d d |d d }t| d krWd S| d krn||\}}d j||f<| |fStD] \}}d j||f<qsd 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?rWr?r%r&rHrIdt_dsuivirCrrfsz$_Streamline.rk4_integrate..fcsHdj||}j||}j||}| || |fSrXrYrZr^rrgsz$_Streamline.rk4_integrate..gcsDd|kotjdkno!d|kotjdkSS)Nrr)r rr)rHrIr^rrsDz+_Streamline.rk4_integrate..csd}d}|}|}||\}}g} g} ||r| || |z>|||\} } ||d|| |d|| \} }||d|| |d||\}}|||||||\}}Wn tyjYniw||| d| d||d7}||| d|d||d7}||sn>||7}||\}}||ks||krɈj||fdkrdj||f<|||}|}nn |dkrn||s|| | fS)Ng{Gz?rrGr1g@r)rJappend IndexErrorr9)x0y0r_dsstotalrHrIxbybxf_trajyf_trajk1xk1yk2xk2yk3xk3yk4xk4ynew_xbnew_ybcheckrC xb_changes yb_changesrrrk4sH   &&" $$    z&_Streamline.rk4_integrate..rk4Nr0rg?r)r rJr9zip)rCrdrer_r`rzsfrjrksbxb_trajyb_trajrgx_trajy_trajinitxbinitybrhrirrvr rk4_integrates(   % z_Streamline.rk4_integratecCsr|dks||jks|dks||jkrdS|j||fdkr5|||j||j}|dur7|j|dSdSdS)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)rr9rr;r<r=rb)rCrhritrrrtrajs$ z_Streamline.trajcs$tjdD]8}tjd|D],}|||||jd||||jd|||qqfddjD_fddjD_ttjD]}j|j|<j|t j q]ttjD]}j|j|<j|t j qzdS)z= Get streamlines by building trajectory set. r1rcs*g|]}t|djjdqS)r)r r2r4r.0rr^rr 0z/_Streamline.get_streamlines..cs*g|]}t|djjdqS)rr)r r2r5rrr^rrr3rN) r rrr=r@rAr tolistrbr nan)rCindentrHrrr^rrB%s(  z_Streamline.get_streamlinescCstt|j}tt|j}tt|j}tt|j}tt|jD]N}|j|tt|j|d||<|j|tt|j|dd||<|j|tt|j|d||<|j|tt|j|dd||<q'||}||}t}tjdddt ||} tjdi|| |j } | |j } t | |j } t | |j } t | |j }t | |j }tt|}tt|}tt|}tt|}tt|D]Z}||dkr||| |||<||| |||<||||||<||||||<q||| |||<||| |||<||||||<||||||<qtt|}tj|dd<t||||g}|d}|}t||||g}|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)divideinvalidrNFr)r emptyr r@rAr r3geterrseterrarctanr'cosrsinrr2flattenr)rC arrow_end_x arrow_end_y arrow_start_x arrow_start_yrdif_xdif_yorig_errstreamline_angang1ang2seg1_xseg1_yseg2_xseg2_ypoint1_xpoint1_ypoint2_xpoint2_yspacerDrErrrr!?s`$$     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 )sumr@rA)rCr)r*rrrr s  z_Streamline.sum_streamlinesN) __name__ __module__ __qualname____doc__rFrJrWrrrBr!r rrrrrs!N Mr) __future__rmathplotlyrrplotly.figure_factoryrplotly.graph_objsr get_moduler rpir.objectrrrrrs      _