o #0h>@s|dZddlmZmZmZddlZddlZddlm Z ddl m Z ddl m Z ddlmZddlmZddlZejdd d krCeZeZd d Zd9ddZddZd:ddZGdddeZd;ddZGdddeZGdddeZ GdddeZ!Gdd d eZ" " dd,d-Z%Gd.d/d/eZ&d>d0d1Z'd2d3Z(d;d4d5Z)d>d6d7Z*e+d8krddl,Z,e,-dSdS)?a Several tools for look-up tables management and interpolation Provides: - LUT class: Look-Up Tables extends ndarrays for generic look-up table management including dimensions description, binary operations, multi-dimensional interpolation, plotting, etc - Idx class: find the index of values, for LUT interpolation - MLUT class: Multiple Look-Up Tables groups several LUTs, provides I/O interfaces with multiple data types - merge: MLUT merging )print_functiondivisionabsolute_importN)interp1d)exists)remove) OrderedDict)filled)rcCst|dkr|St|dkr|S|d|dkr*|dgt|dd|ddS|d|ddvrK|d|ddvrFtd||t||S|dgt|dd|S)zi Interleave 2 sequences (union, preserve order) ([1, 3, 4, 6], [2, 3, 6]) -> [1, 2, 3, 4, 6] rNz-sequences "{}" and "{}" cannot be interleaved)leninterleave_seq ValueErrorformat)pqrZ/Users/jing/Downloads/radiative_transfer_demo/ARTDECO/artdeco/pyartdeco/f2py_utils/luts.pyrs  $ rBcCs>dD]}t|dkrd|||fS|d}qd|d|fS)N)ZKiZMiZGiZTiPiZEiZZig@z %3.1f%s%sz%.1f%s%sZYi)abs)numsuffixunitrrr sizeof_fmt1s   rcs tjfdd|DS)z} Returns uniques elements from a sequence, whist preserving its order http://stackoverflow.com/questions/480214/ cs g|] }|vs|s|qSrr.0xseenZseen_addrr ?s zuniq..)setadd)seqrr runiq8sr&c Cs|jdksJt|dkrt|d|dg}n.d|d|dd}d|d|dd}tt|d|dd|dd|}|durQt||}|dur[t||}|S) z9 calculate n+1 bin edges from n bin centers in x r ?r rg@N)ndimr nparrayappendmaximumminimum)rminmaxretfirstlastrrr bin_edgesBs ,  r5c@s4eZdZdZdHddZdIddZdJdd Zd d ZdJd d ZddZ dKddZ ddZ ddZ ddZ ddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2ZdLd3d4ZdId5d6Zd7d8Zd9d:Z  dMd;d<Z   dNd>d?Z d@dAZ!dBdCZ"dDdEZ#dFdGZ$dS)OLUTaQ Look-up table storage with generic multi-dimensional interpolation. Extends the __getitem__ method of ndarrays to float and float arrays (index tables with floats) The LUT axes can be optionally provided so that values can be interpolated into float indices in a first step, using the Idx class. Other features: * binary operations between LUTs and with scalars * automatic broadcasting: binary operations between LUTs with different axes the LUTs are broadcasted together according to their common axes * apply functions, dimension reduction (apply a function along a given axis) * equality testing * plotting Arguments: * data is a n-dimension array containing the LUT data * axes is a list representing each dimension, containing for each dimension: - a 1-d array or list containing the tabulated values of the dimension - or None, if there are no values associated with this dimension * names is an optional list of names for each axis (default: None) it is necessary for storing the LUT * attr is a dictionary of additional attributes, useful for merging LUTs * desc is a string describing the parameter stored (default None) when using save(), desc is used as the hdf dataset name to store the LUT Attributes: axes, shape, data, ndim, attrs, names, desc Example 1 --------- Basic usage, without axes and in 1D: >>> data = np.arange(10)**2 >>> L = LUT(data) >>> L[1], L[-1], L[::2] # standard indexing is possible (1, 81, array([ 0, 4, 16, 36, 64])) >>> L[1.5] # Indexing with a float: interpolation 2.5 >>> L[np.array([[0.5, 1.5], [2.5, 9.]])] # interpolate several values at once array([[ 0.5, 2.5], [ 6.5, 81. ]]) Example 2 --------- Interpolation of the atmospheric pressure >>> z = np.linspace(0, 120., 80) >>> P0 = np.linspace(980, 1030, 6) >>> Pdata = P0.reshape(1,-1)*np.exp(-z.reshape(-1,1)/8) # dimensions (z, P0) A 2D LUT with attached axes. Axes names can optionally be provided. >>> P = LUT(Pdata, axes=[z, P0], names=['z', 'P0']) >>> P[Idx(8.848), Idx(1013.)] # standard pressure at mount Everest 336.09126751112842 >>> z = np.random.rand(50, 50) # now z is a 2D array of elevations between 0 and 1 km >>> P0 = 1000+20*np.random.rand(50, 50) # and P0 is a 2D array of pressures at z=0 >>> P[Idx(z), Idx(P0)].shape # returns a 2D array of corresponding pressures (50, 50) In Idx, the values can optionally be passed using keyword notation. In this case, there is a verification that the argument corresponds to the right axis name. >>> P[:, Idx(1013., 'P0')].shape # returns the (shape of) standard vertical pressure profile (80,) NcCs`||_||_|durt|_n||_t|jj|_|j|_|dur)|jdg|_nZ||_t||jks5Jt|D]I\}}t |t j rV|jdksJJt||j|ksUJq9t |t rgt||j|ksfJq9|durlq9|ddjdkswJt||j|ksJq9|dur|jdg|_ n ||_ t||jksJ|jjtt jt jfvrd|_dSd|_dS)Nr z{:3g}z{})datadescrattrsr shaper*axes enumerate isinstancer+ndarraylistnamesdtypefloatfloat32float64 formatter)selfr7r;r@r8r9iaxrrr__init__s6      z LUT.__init__Fc s|durt|S|jdkr|r|Std|tdg|j}t|j}t|j}g|D]\}}t |t r<|}n t |t sEJd||jvrQ|j |}n |rTq0td||t |t rr| |j|} ||j|} n|} d} t| jdkrt |ts|nI||durd||<n>t |tr|||||<n0t| jdkr| dur| ||<n|jjdvr|||||<nd||<n tdt| j| ||<q0fd d t|D}fd d t|D}|t|} t| ||t|j|jd S) a returns a subset LUT of current LUT along several axes * d is a dictionary of {ax: value}, where: - ax is the name (string) or index (integer) of the axis to consider - value can be: * scalar integer (axis is removed) * float index (axis is removed with interpolation) * slice (axis is subsetted) * 1-d array (axis is subsetted) * Idx * ignore: if True, return full LUT if axis is not present in LUT Examples: lut.sub({'axis1': 1.5}) returns the lut stripped from 'axis1', for which we use the index 1.5 lut.sub({2: Idx(42.)}) lut.sub({'ax': arange(5)}) # first 5 values lut.sub({'z': slice(None,None,2)}) # every other value lut.sub({'wav': lut.axis('wav')<500.}) # array of booleans lut.sub({'wav': Idx(lambda x: x<500.)}) # select wav < 500 NrzCannot subset scalar LUT {}zax should be str or intzGsub is not possible on axis "{}" because this axis is not present in {}r )urGz)Cannot use a {}-dim array to subset a LUTcg|] \}}|vr|qSrrrrGaZdims_to_removerrr"zLUT.sub..crKrrrLrNrrr"rOr;r@r9r8) Subsetterr* Exceptionrslicer?r@r;itemsr=intstrindexIdx_baseapplyr+r,r-rAkindr<tupler6dictr9r8) rFdignorekeysr@r;rHviaxidxZnewaxr7rrNrsubs`                zLUT.subcCs`t|tr |j|}n t|tr|}ntd|r+|j|}t||g|j|gdS|j|S)z returns axis referred to by a (string or integer) aslut: False: returns the values True: returns axis a a LUT (containing itself as only axis) z.argument of LUT.axis() should be int or string)r;r@)r=rVr@rWrU TypeErrorr;r6)rFrMaslutrWr7rrraxiss    zLUT.axiscO|j|i|SNdescriberFargskwargsrrr print_info2zLUT.print_infoc Cs zdt|jt|j}Wnd}Ytddd|jd|jdu|jj|tt |jj D]@}|j |durBd}n|j |}|j |dur\td|||jj |q6td ||t |j ||j |d |j |d q6|rtd |j D] \}}td |d|q|S)z Prints the LUT informations arguments: show_attrs: show LUT attributes (default: False) returns self z between {:.3g} and {:.3g}rz LUT {}({}{}):z"{}" TFNNoNamez* Dim {} ({}): {} values, no axis attachedz$ Dim {} ({}): {} values in [{}, {}]rr( Attributes: :)rr+aminr7amaxprintr8rAxranger r:r@r;r9rT)rF show_attrsrngrGnamekr`rrrrj6s6    z LUT.describecCs|jjjdvr |j|St|ts|f}t|}t|}||jkr*td |j|t |D].}||}t|t r\|j d|j |fvrRd}t| ||j ||j ||j|||<q.d}g}t |D]F}||}t|tjr|jdkr|tj|dd|dur|j}qe||jksJd t|t|jqet|tr||qe|dqetd d g|jt|j}g} g} g} t |D]u}||}d } t|tjr |jtd td fvr d } |d} | | |jj|d kd 8<|| }|jdkr ||}nt|tr*d } t|} | |jj|d kr&| d 8} || }| r<| | | || |qt| }d}t d|D]<}d }t |D]'}d |>|@|?}| |}|rg||9}n|d |9}| |||| |<qQ|||jt|7}qI|S)a Get items from the LUT, with possible interpolation Indexing works mostly like a standard array indexing, with the following differences: - float indexes can be provided, they will result in an interpolation between bracketing integer indices for this dimension - float arrays can be provided, they will result in an interpolation between bracketing integer arrays for this dimension - Idx objects can be provided, they are first converted into indices - basic indexing and slicing, and advanced indexing (indexing with an ndarray of int or bool) can still be used (see http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html) - if arrays are passed as arguments, they must all have the same shape - Unlike ndarrays, the number of dimensions in keys should be identical to the dimension of the LUT >>> LUT(np.zeros((2, 2)))[:] Traceback (most recent call last): ... Exception: Incorrect number of dimensions in __getitem__ Returns: a scalar or ndarray )SUzDIncorrect number of dimensions in __getitem__ (expecting {}, got {})NzAError, wrong parameter passed at position {}, expected {}, got {}rrUrAzr- zeros_liker:rVrSzerosreshapeastyperBrU)rFr_NrGr|msgZ dims_arrayZindex0Zshp_resZinterpolate_axisZinf_listZx_list interpolateinfrnresultbcoefbbrrr __getitem__^s       &   "            zLUT.__getitem__TcCst|tsdSt|jD]*\}}|dur|j|durq |dus'|j|dur*dSt||j|s6dSq |jj|jjksAdS|rUt|j|jsMdS|j|jkrUdSdS)z Checks equality between two LUTs: - same axes - same shape - same values (if strict) FNT) r=r6r<r;r+allcloser7r:r9)rFotherstrictrGrHrrrequals$  z LUT.equalc Csgg}}g}t|j|j}t|D]G\}}||jvrA||j|j||td||jvr;|tdq|dq||j|j||d|tdqi} |jD]>} | |jvrgq_t|j| t j rt|j| t j szq_t |j| |j| sq_n |j| |j| krq_| | |j| iq_|j |j kr|j } nt|} t||jt||jt|||| | dS)z apply fn(self, other) where other is a LUT the result is determined by using common axes between self and other and using appropriate broadcasting NrP)rr@r<r-r;rWrSr9r=r+r>rupdater8rVr6r7r[) rFrfnshp1shp2r;r@rGrMr9r|r8rrr__binary_operation_lut__sH         zLUT.__binary_operation_lut__cCs"t||j||j|j|j|jdS)NrP)r6r7r;r@r9r8rFrrrrr__binary_operation_scalar__-s zLUT.__binary_operation_scalar__cCs"t|tr |||S|||Srh)r=r6rrrrrr__binary_operation__2s   zLUT.__binary_operation__cC||ddS)NcS||Srhrryrrr9zLUT.__add__..rrFrrrr__add__8z LUT.__add__cCr)NcSrrhrrrrrr<rzLUT.__radd__..rrrrr__radd__;rz LUT.__radd__cCr)NcSs||Srhrrrrrr?rzLUT.__sub__..rrrrr__sub__>rz LUT.__sub__cCr)NcSs||SrhrrrrrrBrzLUT.__rsub__..rrrrr__rsub__Arz LUT.__rsub__cCr)NcS||SrhrrrrrrErzLUT.__mul__..rrrrr__mul__Drz LUT.__mul__cCr)NcSrrhrrrrrrHrzLUT.__rmul__..rrrrr__rmul__Grz LUT.__rmul__cCr)NcS||SrhrrrrrrKrzLUT.__div__..rrrrr__div__Jrz LUT.__div__cCr)NcS||SrhrrrrrrNrzLUT.__rdiv__..rrrrr__rdiv__Mrz LUT.__rdiv__cCr)NcSrrhrrrrrrQrz!LUT.__truediv__..rrrrr __truediv__PrzLUT.__truediv__cCr)NcSrrhrrrrrrTrz"LUT.__rtruediv__..rrrrr __rtruediv__SrzLUT.__rtruediv__cC ||Srhrrrrr__eq__V z LUT.__eq__cC || Srhrrrrr__neq__Y z LUT.__neq__cCst}|jdur+tt|jD]}|j|}|j|}|dus#|dur$q|||q|j|j|j|j|j d| |j |S)z# convert to a MLUT Naxnamesr9) MLUTr;rxr r@add_axis add_datasetr8r7r9 set_attrs)rFmrGr{rfrrrto_mlut]s    z LUT.to_mlutcCs6|dur |jdur |j}t||j|j|j|j|dS)z returns a LUT whose content is obtained by applying function fn if desc is provided, use this description NrP)r8r6r7r;r@r9)rFrr8rrrrYts  z LUT.applycKszt|tr |j|}n|}|durLt|j}t|j}|||||jdkr8|s8||jfd|i|St ||jfd|i||||j |j dSt |t |j|ksYJt|jj } t|} t | | |<tj| |jjd} tdg|j} tdg|j} t| D]!\}}|| |<||k| |<||jt| fd|i|| t| <qt|j}| ||<t | ||j|j |j dS)a) apply function fn to a given axis fn: function to apply should be applicable to a numpy.ndarray and support argument axis (example: numpy.sum) axis: name (str) or index of axis grouping: iterable of same size as axis fn is applied by groups corresponding to identical values in grouping example: grouping = [0, 0, 0, 1, 1, 2] results in fn(3 first elements), fn(2 next), then fn(last) the axis of the reduced axis takes the values of grouping default None (apply to all elements, remove axis) as_lut: if axis reduction results in a scalar, returns a dimensionless LUT default False (returns a scalar) Nr rfrPr)r=rVr@rWr?r;popr*r7r6r9r8r r:r&r+rrArSr<r[)rFrrfgroupingZas_lutrmrWr;r@shpr~r7ind1ind2rGrJrrrreduces>        ( z LUT.reducecCst|tr |j|}t|tr|j|}gg}}t|jD]}||j|||j|q ||||||<||<||||||<||<t|j |||||j |j dS)z Swaps two axes of the LUT Arguments: axis1 and axis2 (int or str): the name or index of the axes to swap Returns: the swapped LUT rP) r=rVr@rWrxr*r-r;r6r7swapaxesr9r8)rFaxis1axis2r@r;rGrrrrs    z LUT.swapaxescOs|jdkr$|jdurt|j|j|Std|j|j|j|S|jdkr3|j|i||S|jdkrB|j|i||S|j|i||S)a Plot a 1 or 2-dimension LUT Note: in 2-dim, creates a new figure Arguments: * swap: swap x and y axes * show_grid * fmt: format for plotting 1d data Only in 2-dim: * vmin, vmax: color scale extent (default: from min/max) * cmap: colormap instance * index: index (or Idx instance) for plotting transect rNz{}: r r ) r*r8rwrErr7 _LUT__plot_1d _LUT__plot_2dplot_ndrkrrrplots     zLUT.plotc Ksddlm} m} m} m} m}ddl}|dur|j}|jjj dkr't ddS|j d}|dur7t |jd}|durHt|jt|j}|durYt|jt|j}|si|}|j}|jd}|j}n |j}|}|j}|jd}|dur||||dn|||||d| |||dur| ||dur|s| |||jkr|ddd d | ||r|jd d d }|ddSdS)z plot a 1-dimension LUT, returns self arguments: plot: custom plot function (defaults to plot) example: plot=semilogy r)xlabelylabelgridylimticklabel_formatNr}z'1D plot does not work for string arrays)labelrscir)r rfstyle scilimitsbestT)locfancyboxr')pylabrrrrrrr7rArwarningswarnr;ranger:r+ruisnanrvr@r8legend get_frame set_alpha)rF show_gridswapfmtrvminvmaxrrrmrrrrrplrHxxyyZxlabZylablegrrrZ __plot_1dsL        z LUT.__plot_1dk-c Ks4ddlm} |durt|jt|j}|dur(t|jt|j}|dur?| jj}| d| d| d|s[|j d|j d} } |j d|j d} }|j}n|j d|j d} } t|jdd}|j d|j d} }| durt|jd} | durt|jd} |dur| jddd\}}n | jddd d \}\}}t| } t| } t| | \}}| || j|||||d }| || t| t| t| t| g|gd }|dur|j}|dur|j|jd ddd| j|dd|d|dur| || || | nst|tr)|j }n| |}|!t| t| g||gd|j"dddd|sW|!| ||ddf|n |!| |dd|f|||| || || || |j| | |j||d|j"dddd|j#dddS)zU Plot a 2-dimension LUT, with optional transect returns self rNblackwhite0.5r )nrowsncolsr T)rrsharex)rr)gq= ףp?g?gQ?r'boldleft)g333333ÿ)weighthorizontalalignmentpositionbothvertical)extend orientationcaxw--rrrr)yminymaxr)hspace)$matplotlib.pyplotpyplotr+rur7rrvcmjet set_underset_overset_badr;r@raranger:subplotsr5meshgridsca pcolormeshrrfadd_axesr8 set_titlecolorbarrrr=Idxvaluerrsubplots_adjust)rFrrrrrcmaprWrrmpltrrZlab1Zlab2r7figax1ax2XYimZcbar_axr`rrrZ __plot_2d,s~            "      z LUT.__plot_2dcsxzddlm}m}m}m}m}ddlm}mWn t y#t dwg} gggt j D]Y} j | } j| } | } | durGd} | durW| d| d| d7} || dd }|dj| d d }d|_|d d }d|_|||| ||||gq3fdd}t j D]} | |d| |dq||| |dS)Nr)VBoxHBoxCheckbox IntSliderHTMLdisplay clear_outputzOIPython notebook widgets are required to plot a LUT with more than 2 dimensionsrq [{:.5g}, {:.5g}]r(F descriptionrr r0r1rrcsg}d}tjD]A}|j|_|j|_|jrB|j}||j|dkrAdj|||_q |td|d7}q |dkrc t |j idSt d|ddS)Nr  {:.5g}  r r z&Please select at least {} dimension(s)) rxr*rvisibler-r;rrSrcrr[rrw)r_r*rGrWrlZchksr#rmrFZsliderstextsrrrs"    "zLUT.plot_nd..updater) ipywidgetsrrrrr IPython.displayr"r# ImportErrorrRrxr*r@r;rr:r*r-on_trait_change)rFrlrmrrrrr r"widrGr{rHr8chkslidertextrrr+rrs>          z LUT.plot_ndcOt|g|Ri||Srh plot_polarrkrrrr7zLUT.plot_polarcOs"d|d<t|g|Ri||S)NTsemir6rkrrr plot_semisz LUT.plot_semicOr5rh) transect2Drkrrrr;r8zLUT.transect2D)NNNN)NFF)Trh)TFNNNNFN)rTFNNNNN)%__name__ __module__ __qualname____doc__rIrcrfrnrjrrrrrrrrrrrrrrrrrrrYrrrrrrr7r:r;rrrrr6VsP @ ' _ ( |8  8 ; [; r6FcCs&t|dr t||dSt||||dS)a Calculate the indices of values by interpolation in a LUT axis The index method is typically called when indexing a dimension of a LUT object by a Idx object. The round attribute (boolean) indicates whether the resulting index should be rounded to the closest integer. Idx value can be of several kinds: - scalar (int or float) => index return scalar float index - array-like => index return array-like float index - callable (ex: lambda x: x<5) => index returns callable applied to axis Example: find the float index of 35. in an array [0, 10, ..., 100] >>> Idx(35.).index(np.linspace(0, 100, 11)) array(3.5) Find the indices of several values in the array [0, 10, ..., 100] >>> Idx(np.array([32., 45., 72.])).index(np.linspace(0, 100, 11)) array([ 3.2, 4.5, 7.2]) Optionally, the name of the parameter can be provided as a keyword argument. Example: Idx(3., 'a') instead of Idx(3.) This allows verifying that the parameter is used in the right axis. Options: - fill_value are passed to interp1d (implies bounds_error=False) Special value for fill_value='extrema': fill with extrema values, don't extrapolate NOTE: this function is a factory that returns an Idx_* instance based on input type Method apply(axis): returns the Idx values applied to axis instead of their index __call__)r{)r{round fill_value)hasattr Idx_filterIdx_arrrr{rBrCrrrrs & rc@seZdZdZdddZdS)rXz$ Base class for Idx objects NFcCs(|dur||_||_||_||_dSdSrhrG)rFrr{rBrCrrrrIs  zIdx_base.__init__NFN)r=r>r?r@rIrrrrrXsrXc@s"eZdZdZddZdddZdS)rFz) Idx class for array-like values cCsFt|dkrtt|j|dstd|j|dS|jdkr+dt|df}nK|jdkrsdt|df}t|jt|krUt dt|jt||j t |jt |krrt dt |jt ||j n|j}|jdu}t |tt|||d |j}|jrt|tjr|t}|St|}|S) zK Return the floating point index of the values in the axis r rz+(Idx) Out of axis value (value={}, axis={})extremaz extrema,warnz5(Idx) Value {} is above the axis maximum {} (axis {})z5(Idx) Value {} is under the axis minimum {} (axis {})N) bounds_errorrC)r r+rr,rrrrCrvrrr{rurr rBr=r>rrU)rFrffvberesrrrrW s>     z Idx_arr.indexNcCs|jSrhr(rFrfrrrrY1sz Idx_arr.applyrhr=r>r?r@rWrYrrrrrF s$rFc@ eZdZdZddZddZdS)rEz+ Idx class for filtering functions cCrrhr(rNrrrrW8s zIdx_filter.indexcCs|||Srh)rWrNrrrrY=szIdx_filter.applyNrOrrrrrE4s rEc@rP)rQzb A conveniency class to use the syntax like: LUT.sub()[:,:,0] for subsetting LUTs cCs ||_dSrh)r6)rFr6rrrrIGrzSubsetter.__init__cCs|jtt|S)z# subset parent LUT )r6rcr\r<)rFr_rrrrJszSubsetter.__getitem__N)r=r>r?r@rIrrrrrrQAs rQ211212Tautoc 3 sddlm} m} ddlmm} ddlm}ddlm }ddl m }d}| r)d}|j d ks0J|du}|durE|r@| d d }n| d d }|d kr`d|j dvr^d|j dvr^d}nd}|r|jd|jd}}|j d|j d}}t|jdd}n|jd|jd}}|j d|j d}}|j}|durt|jt|j}|durt|jt|j}||kr|d8}|d7}||kr||}}|}|}t|t||d}|}| jddd| dd}| }Gdddt}Gfdddt}dkr,dkr,dkr,dkr,| d} | }!n|} |}!|dd}"|tjdd}#|"|#|}$|j|$d |d df|| ||!d!}%|j|||%d"}&||&|& d|&j!d#"d$|&j!d%"d&|&j!d$#d|&j!d&"d$|&j!d&j$ddd'|&j!d&j%"d&|&j!d&j&"d&|&j!d&jj'd(d)||&j(d#d$d*|&j!d#jj'd+d,||&j(d-d&d*|&)|$}'|&j*|'_*d.|&j*_+|r||}(|r|(, n|(,|(-|||(j.d/d0d1d2|( d| dur| j/} | 0d3| 1d4| 2d5t3t4|ddd6t4|\})}*tj56t|t7|B|}+|'j8|*|)|+| ||d7},|rt9|t:rVt;|<|=t>}-n|}-t?|-D]\}.}| rhd8|}/n|j@dd ||j@d}/tAddg||gg}0tAddg||/gg}1|'B|0dddf|0dddfd9|r|'jB|1dddf|1dddfd:d d;gd<|.d=}2|(B|||ddfd>|2|r|(B| ||/ddfd?|2q\|jC|,d@dAtD||dBdCdD|jEdur|&jF|jEdEdFdGdSdS)Ha Contour and eventually transect of 2D LUT on a semi polar plot, with dimensions (angle, radius) lut: 2D look-up table to display with axes (radius, angle) (unless swapped) angle is assumed to be in degrees and is not scaled index: index of the item to transect in the 'angle' dimension can be an Idx instance of several values or a list of indices if None (default), no transect vmin, vmax: range of values default None: determine min/max from values rect: subplot position of the main plot ('111' for example) sub: subplot position of the transect sym: the transect uses symmetrical axis (boolean) if None (default), use symmetry iff axis is 'zenith' swap: swap the order of the 2 axes to (radius, angle) if 'auto', searches for 'azi' in both axes names fig : destination figure. If None (default), create a new figure. cmap: color map semi: polar by default, otherwise semi polar if lut is computed for 360 deg r)figurerN)Affine2D) floating_axes) PolarAxesgv@gf@r )@rXfigsize)rXrSazir TFMbP?gV@rp)Z include_lastc@seZdZddZdS)zplot_polar..LocatorcWstgdddgS)N)r<Zr^?)r+r,rFrlrrrrAsz$plot_polar..Locator.__call__Nr=r>r?rArrrrLocators rfcseZdZfddZdS)zplot_polar..FormattercstddtdS)NcSs d|S)Nz{:.3g}rrrrrr z8plot_polar..Formatter.__call__..r^)mapr+linspacerdax2_maxax2_minrrrAsz&plot_polar..Formatter.__call__Nrerrlrr Formattersrog$@rbPrcr)Zextremes grid_locator1 grid_locator2tick_formatter1tick_formatter2) grid_helperrbottomrighttop) ticklabelsrg ףp= ?g\(\?) transformhavag?gQcenterg?rrrrrrrr')rrrr(wr) linewidth)r|rgrrrr[-z-- horizontalrgffffff?)rrticksshrinkr)g?g ףp= ?)rr)GrrTrZ$mpl_toolkits.axisartist.angle_helperZ axisartist angle_helpermatplotlib.transformsrUZmpl_toolkits.axisartistrVmatplotlib.projectionsrWr*r@lowerr;r+rr7rurrvZ LocatorDMSZ FormatterDMSobject translatescalepiPolarTransformZGridHelperCurveLinearZFloatingSubplot add_subplotrrfZset_axis_direction set_visibletoggleZmajor_ticklabelsrr4 transAxesZ get_aux_axespatchzorderset_xlimset_ylimrrainbowrrrr r5ma masked_whereisinfr r=rXrBrWrrUr<r:r,rrrkr8r)3lutrWrrrectrcsymrrrr9rTrrrUrVrWZPhimaxZshow_subrrname1name2r7 ax1_scaledlabel1Z ax2_scaledlabel2rqrsrfrorrrtZ tr_rotateZtr_scaletrruZax_polarZ aux_ax_polarax_cartrtZ masked_datarZindexesii mirror_indexZvertex0Zvertex1colorrrlrr7Qs     $                  &*  r7yr|rc Csddlm} |jdks J|dur| dd}|dkr1d|jd vr/d|jdvr/d }nd }|rR|jd |jd} } |jd |jd}}t|jdd }n|jd|jd } } |jd|jd }}|j}|dur|t |jt |j}|durt |jt |j}||kr|d 8}|d 7}||kr||}}| rd }d}| }|}t |t rtt|| }|jdd||jd}|r|jd |}n|jd|}t | }t | }|d|}||}|d |r|| |n|||||||jdddd|d |||j| ||ddf| |d|r?|j| ||ddf| |d|jdurM||jdSdS)a Transect of 2D LUT lut: 2D look-up table to display with axes (radius, angle) (unless swapped) angle is assumed to be in degrees and is not scaled index: index of the item to transect in the 'angle' dimension can be an Idx instance if None (default), no transect vmin, vmax: range of values default None: determine min/max from values sym: the transect uses symmetrical axis (boolean) if None (default), use symmetry if axis is 'zenith' swap: swap the order of the 2 axes to (radius, angle) if 'auto', searches for 'azi' in both axes names fig : destination figure. If None (default), create a new figure. color : color of the transect percent: if True set scale to 0 to 100% r)rTr N)rXg@rYrSr\r TFr]rgY@z {:7.2f}rrrr)r)rrTr*r@rr;r+rr7rurrvr=rXrUaroundrWr:rrrrrr set_xlabelrr8r)rrWrrrrrrcrpercentrrTrrrrr7rrrtitlernrmrrrrrr;#sh  $           r;csPt}|d}tdt|D]}|j||ddddsJq|jD] \}}|||q#g}g} |D]/}g}|D]} | j|} |durI|| } | |vrR|| q:|||||| |q4| D]}} t t t||| j } || j j}tj| |d}z|tj7}WnY|D]:} d}t|D]\}}| j|} |dur|| } |||| f7}q|| j jdkr|tdf7}| | j ||<q|| j}|dur|| |qh|| || |qh|jD]:\dt fd d |vrqttjrdt fd d |vrqndt fd d |vrq|q|S) aK Merge several luts Arguments: - M is a list of MLUT objects to merge - axes is a list of axes names to merge these names should be present in each LUT attribute - dtype is the data type of the new axes ex: dtype=float if None, no data type conversion Returns a MLUT for which each dataset has new axes as defined in list axes (list of strings) The attributes of the merged mlut consists of the common attributes with identical values. >>> np.random.seed(0) Example: merge two MLUTS (also using attribute to dataset promotion) >>> M = [] >>> for b in range(4): ... M1 = MLUT() ... M1.add_axis('ax1', np.arange(4)) ... M1.add_axis('ax2', np.arange(5)+10) ... M1.add_dataset('a', np.random.randn(4, 5), ['ax1', 'ax2']) ... M1.set_attrs({'b':b, 'c':b*10}) ... M1.promote_attr('b') # attribute 'b' is converted to a scalar dataset ... M.append(M1) >>> merged = merge(M, ['c']) >>> _=merged.print_info(show_self=False) Datasets: [0] a (float64 between -2.55 and 2.27), axes=('c', 'ax1', 'ax2') [1] b (float64 between 0 and 3), axes=('c',) Axes: [0] ax1: 4 values between 0 and 3 [1] ax2: 5 values between 10 and 14 [2] c: 4 values between 0 and 30 rr FT)content attributes show_diffNrrcs |jvSrhr9rh)r|rrrrizmerge..cst|jSrh)r+rr9rhr|r`rrrscs|jkSrhrrhrrrrs)rrxr rr;rTrr9r-datasetsr[rjr:r7rAr+rNaNr<rWr*rSr@rr=r>set_attr)Mr;rArr3rGaxnamerfZnewaxesZ newaxnamesZmlutrr{ new_shape_dtypenewdatarWjrMrrrrmergesj*         rc@seZdZdZddZddZddZdifd d Zd1d d Zd dZ ddZ  d2ddZ  d3ddZ d3ddZ ddZddZddZd4dd Zd!d"Zd#d$Zd%d&Zd5d'd(Zd)d*Zd+d,Zd6d-d.Zd7d/d0ZdS)8raJ A class to store and manage multiple look-up tables How to create a MLUT: >>> m = MLUT() >>> m.add_axis('a', np.linspace(100, 150, 5)) >>> m.add_axis('b', np.linspace(5, 8, 6)) >>> m.add_axis('c', np.linspace(0, 1, 7)) >>> np.random.seed(0) >>> m.add_dataset('data1', np.random.randn(5, 6), ['a', 'b']) >>> m.add_dataset('data2', np.random.randn(5, 6, 7), ['a', 'b', 'c']) >>> # Add a dataset without associated axes >>> m.add_dataset('data3', np.random.randn(10, 12)) >>> m.set_attr('x', 12) # set MLUT attributes >>> m.set_attrs({'y':15, 'z':8}) >>> _=m.print_info(show_self=False) Datasets: [0] data1 (float64 between -2.55 and 2.27), axes=('a', 'b') [1] data2 (float64 between -2.22 and 2.38), axes=('a', 'b', 'c') [2] data3 (float64 between -2.77 and 2.3), axes=(None, None) Axes: [0] a: 5 values between 100.0 and 150.0 [1] b: 6 values between 5.0 and 8.0 [2] c: 7 values between 0.0 and 1.0 Use bracket notation to extract a LUT Note that you can use a string or integer. data1 is the first dataset in this case, we could use m[0] >>> _=m['data1'].print_info() # or m[0] LUT "data1" (float64 between -2.55 and 2.27): Dim 0 (a): 5 values betweeen 100.0 and 150.0 Dim 1 (b): 6 values betweeen 5.0 and 8.0 cCst|_g|_t|_dSrh)rr;r7r9rFrrrrI s z MLUT.__init__cCsdd|jDS)z& returns a list of the datasets names cSg|]}|dqSrrrrrrr"*z!MLUT.datasets..r7rrrrr(roz MLUT.datasetscCs\t|tsJ||jvsJd|t|trt|}n|}|jdks'J||j|<dS)z Add an axis to the MLUT zAxis "{}" already in MLUTr N)r=rVr;rr?r+r,r*)rFr{rfrHrrrr,s  z MLUT.add_axisNcCs|dd|jDvsJd||durCt|t|jks Jt|D]\}}|dur-q$||jvr3q$|j|t|j|ksAJq$ndg|j}|j||||fdS)z Add a dataset to the MLUT name (str): name of the dataset dataset (np.array) axnames: list of (strings or None), or None attrs: dataset attributes cSrrrrrrrr"@rz$MLUT.add_dataset..zError, "{}" already in MLUTN)r7rr r:r<r;r*r-)rFr{datasetrr9rGrHrrrr8s"   zMLUT.add_datasetcCs|dur|j}|dus Jt|jD]S}|j|}|j|}||jvrP|durOt|j|jt|jksDJd||j|j|jt |j||sOJq|dur[|dusZJq|dure| ||q|j ||j |j|j d|S)z= Add a LUT to the MLUT returns self Nz+Inconsistent shapes for axis "{}": {} != {}r)r8rxr*r@r;r+r,r:rrrrr7r9)rFrr8rarrHrrradd_lutMs,      z MLUT.add_lutcCs~z t|tsJWntyt|ttfsJYnwz dd|jD|}Wn ty6td||w|j |dS)z remove a LUT cSrrrrrrrr"rrzMLUT.rm_lut..z{} is not in {}N) r= basestring NameErrorrVbytesr7rWrrRr)rFr{rWrrrrm_lutjs   z MLUT.rm_lutcCsPt}|D] }t|tsJq|D]}|||j|ddq|j|_|S)z The MLUT equivalent of LUT.sub returns a MLUT where each LUT is subsetted using dictionary d keys should only be strings values can be int, float, slice, Idx, array (bool or int) T)r^)rr=rVrrrcr9)rFr]rddrrrrcxs zMLUT.subFTcCst|r|r t|ntd|}t|d|||r%td||||dur@|dr1d}n|dr9d}ntd ||dkrO|j||||d dS|dkr^|j ||||d dStd |) z Save a MLUT to filename fmt: output format: hdf4, netcdf4, or None (determine from filename extension) zFile {} existsfilenamez Writing "{}" to "{}" ({} format)N.hdfhdf4.ncnetcdf40Cannot determine desired format of filename "{}") overwriteverbosecompressInvalid format {}) rrrRrsetattrrwendswithr_MLUT__save_netcdf4_MLUT__save_hdf)rFrrrrrexrrrsaves2      z MLUT.savecCsfddlm}||ddd}d}|jD]!\}} ||t| |j|| j|g|d} | dd| dd<q|jD]a\} } } }|rLt d | | j| j t t| D]0}| |dure|d7}d || |<| ||j vr|rwt d | ||| || j |qR|j| | j| |d} | || d | dd<q9|rt d t|j||j|dS) NrDatasetr~NETCDF4rg)zlib Write data "{}" ({}, {})r z dummy{:d}z Create dimension {}. Write {} attributes)netCDF4rr;rTcreateDimensionr createVariablerAr7rwrr:rx dimensions setncattsr9close)rFrrrrrrootZ dummycountrrHvarr{r7rrrGrrrZ__save_netcdf4s4     zMLUT.__save_netcdf4cCsddlm}m}ddlm}dd}td|jtd|jtd|j td |j td |j td |j td |j td |j td|j td|ji } |||j|jB} |jdur|jD]4\} } |rqtd| || | j} | | | | j}|r||jd|| dd|dd<|qc|jD]z\} }}}||}|rtd| |j|j| |j} |jdkr| | | d}t|ddn| | | |j}|r||jd|d|dd<|dgfvrt|ddtt|d|vrt d||D] \}}t|||q|q|r#tdt!|j"|j"D]"\}}z t| ||Wq(|yJt| t|t|Yq(w| #dS)z+ Save a MLUT to a hdf file r)SDSDC) HDF4ErrorcSsd|jtdkrt||dsJ|dS|jtdkr0t||ds+J|dS|S)Nuint64uint32int64int32)rAr+rrrrrrsafecasts  z!MLUT.__save_hdf..safecastrCrDrrrruint16int16uint8int8Nz Write axis "{}" in "{}" r)r lut:scalarTrue.r,z1Error writing {}, "dimensions" attribute conflictr)$pyhdf.SDrrZ pyhdf.errorrr+rAZFLOAT32ZFLOAT64ZUINT32ZINT32ZUINT16ZINT16ZUINT8ZINT8WRITEZCREATEr;rTrwrcreater:Z setcompressZ COMP_DEFLATEZ endaccessr7r*rjoinrjrVrRr r9end)rFrrrrrrrrZtypeconvhdfr{rHtypesdsr7rr9r|r`rrrZ __save_hdfsj                   zMLUT.__save_hdfcCs||j|<|S)z0 Set one attribute key -> value r)rFkeyrrrrr*s z MLUT.set_attrcCs|j||S)zK Set multiple attributes to attrs attributes: dict )r9r)rFrrrrr2s zMLUT.set_attrscOrgrhrirkrrrrn;rozMLUT.print_infoc Csd}|r tt|tdt|jD]\}\} } } } d} | dur-|r-| dtt| 7} |r7| d| j7} |rUt| tj rUzdt | t | }Wn d}Ynd}|rbdt | j }nd}td|| | j|| j| ||| j 7}|rt| dkrtd | D] \}}td ||qqtd t|jD]\}\} }td || t||d|d q|rtd|jD] \}}td|d|q|rtdt ||S)Nrz Datasets:rz, axes=z , shape={}z in [{:.3g}, {:.3g}]z, {}z [{}] {} ({}{})z Attributes:z {}: {}z Axes:z [{}] {}: {} values in [{}, {}]r(rrrsrtzTotal memory usage: {})rwrVr<r7r[rr:r=r+r>rurvrnbytesrAr rTr;r9)rFZ show_rangeZ show_selfryZ show_shapeZ show_axesZmemZ total_sizerGr{rr;r9ZaxdescrzZmemdescr|r`valuesrrrrj?sH  " $z MLUT.describec st}|jD]\}}|vr|||q|jD](\}}}}fdd|D} fddt||jD} |j||| | |dq|j |_ |S)z drop axes of size 1 example: m.dropaxis('a') # remove axis 'a' of size 1 m.dropaxis('a', 'b') # remove 'a' and 'b' csg|]}|vr|qSrrr ax_to_droprrr"ysz!MLUT.dropaxis..crKrr)rrsrrrr"zrOr) rr;rTrr7zipr:rrr9) rFrrrrHr{r7rrr;rrrrdropaxishs z MLUT.dropaxiscCs<t|tsJ||jvsJt|j|}|||dS)z: Create a new dataset from attribute name N)r=rVr9r+r,r)rFr{rrrr promote_attrszMLUT.promote_attrc Cst|ttfr+d}t|jD]\}\}}}}||kr|}nq|dkr*td|n t|tr3|}ntd|j|\}}}}|durGd} ng} |D]} | dusV| |jvr\| dqK| |j| qKt ||| ||dS)zE return the LUT corresponding to key (int or string) r(zCannot find dataset {}zFmulti-dimensional LUTs should only be indexed with strings or integersN)r8r7r;r@r9) r=rVunicoder<r7rRrrUr;r-r6) rFrrWrGr{_rrr9r;rHrrrrs,  zMLUT.__getitem__c Csd}t|ts|dt|7}t|dSd}t|j|jD]?}||jvs-||jvr6|d|7}d}|j|j|j|jkrK|d|7}d}t |j||j|s`|d|7}d}q!t| t| kr|d7}|d t| 7}|d t| 7}d}| D]}||j |||d s|d |||j||j7}d}q|rt|j |j D]2} | |j vs| |j vr|d | 7}d}q|j | |j | kr|d | |j | |j | 7}d}qq|r|st||S)z Test equality between two MLUTs Arguments: * show_diff: print their differences * content: check LUT content (otherwise only axes and shapes) * attributes: check global attributes z MLUTs diff:z other is not a MLUT ({})FTz axis {} missing in either z axis {} shape mismatch z axis {} is different z Datasets are different z -> {})rz, dataset {} differs (shapes are {} and {}) z& attribute {} missing in either MLUT z, value of attribute {} differs ({} and {}) )r=rrrVrwr#r;unionr:r+rrrr9r_) rFrrrrreqr|r{rMrrrrsR  z MLUT.equalcCrrhrrrrrrrz MLUT.__eq__cCrrhrrrrrrrz MLUT.__neq__cCs&|j|}|rt|||g|gdS|S)zd returns an axis if aslut: returns it as a LUT otherwise, as values )r8r7r;r@)r;r6)rFrrer7rrrrfs z MLUT.axisc sz"ddlm}m}m}m}m} m} m} ddlm ddl m } m Wn t y-tdwdur6g} iidvrEd}nd}dvrPd}nd }| d|d | d|d |d d d | d dd | dd d g D]}||d d |<t|jD]s\}}|durtd|vrq|j|}|}|dur|d|d|d7}||dd }|d|j|d d}d |_| dd}d |_| dd}t|d|| dd}t|d|| ||||||g|||||f|<qqor| d| dd| d|| d| dd| d|  f dd}dd}d d!}D] \}\}}}}}||d"||d"||||q7 D] }||d"qZD] }||d"qh| || |dS)#a3 display all datasets in the MLUT * datasets: list of datasets to display if None, display all datasets * extra_widgets: show extra widgets for: 1) interactive selection of datasets to display 2) choice of min/max values r)rrrrr  FloatTextButton)rfr!z4IPython notebook widgets are required to plot a MLUTNrrr r%z xmin/xmaxFxminxmaxz)Does not work with unnamed axes, sorry :/r$r(Tr'rr(r)r&r3+z AXES:zDATASETS:c sr# djd< djd< dj d_ dj d_D]\}\}}}}}|j|_|j|_|j|_|j|_q'D]}|jsKqCg}d}t|jD]:\} } | \}}}} } |jr|j} || |j| dkrd|j| | |_qV|td|d7}qV|dkr| t |j |d d  djr dj djd qCt d ||dqCdS) Nrrr rr r r^r)T)rr)rrz*{}: Please select at least {} dimension(s))rr*rTr<r@r-r;rrSrcrr[rrw) rMr2r3r4 button_minus button_plusr]r_r*rGr{r rW rlr;rfr#rZdstchk extra_widgetsrmrFZvminmaxrrr<sB    ( zMLUT.plot..updatecSs|jjd8_dSNr r3rrrrr decrementizMLUT.plot..decrementcSs|jjd7_dSrrrrrr incrementkrzMLUT.plot..incrementr)r-rrrrr r rrrfr.r"r#r/rRrr<r@r;rr:r*rr-insertrrTr0Zon_click)rFrrrlrmrrrrr r rr"r1rrr]rar{rHr8r2r3r4rrrrrrMZflrrrrs $               -      z MLUT.plotrh)NFFT)FFT)TTFFTF)TTFr<)NT)r=r>r?r@rIrrrrrrcrrrrrrnrjrrrrrrrfrrrrrrs8!  % &T ) 8  rcCst|dur|dr d}n|drd}ntd||dkr#t|S|dkr+t|S|dkr3t|Std|) zn Read a MLUT (multi-format) fmt: netcdf4, hdf4 or None (determine format from extension) Nrrrrrhdf5r)rrrread_mlut_netcdf4 read_mlut_hdfread_mlut_hdf5)rrrrr read_mlut|s  r!c Cst}ddlm}||ddd}|jD]}|ds0||jvr0|t|t|j|ddq|jD]2}||j vr.r)rrrr startswith variablesrrVr r;ncattrs getncattrrrr) rrrrdimvarnamerr9rMrrrrs&  "    , rcCsPddl}||d}|r||}n|}|dur t|d}n|}g}g} |D]l} | t|dvru|d| jdsItd| td|d| j d} t | t r`| d} n| d} | | | D]} || qlq(td | td ||dD]} td | qtd tt|}t}|D]}|d |d}|||qtt|D]g}||} |r|d| }n|d| d}i}|d| jdr|d| j d|d<|d| jdr|d| j d|d<|d| jdr|d| j d|d<|j| || ||dq|s&||S)a read a MLUT from a hdf5 file (filename) datasets: list of datasets to read: * None (default): read all datasets, including axes as indicated by the attribute 'dimensions' * a list of: - dataset names (string) - or a tuple (dataset_name, axes) where axes is a list of dimensions (strings), overriding the attribute 'dimensions' rNrr7rz*Missing -dimensions- Attr in dataset "{}" z"Missing dimensions Attr in datasetrzdataset "{}" not available.z#{} contains the following datasets:z *zMissing datasetrf. _FillValue add_offset scale_factorr)h5pyFiler?r_r9 __contains__rwrrRgetr=rdecodesplitr-r#rrrxr rr)rrlazygroupr,fff ls_datasetsZls_axisZ axis_datarraar]rrHrfidatar7r9rrrr sb        r cCs ddlm}||}g}g}|durtt|}n t|ts$Jd|D]g}t|tr7|\}}||} nd}||} | d} |dured| vre| d d}dd|D}d d|D}|durn| || } | } d | vr| d | d } || | || fq&d|vr|dd|vst} t|D]?}d d|D|d d|Dvr||vr||} | || qdd|D|}||\}} }}| || q|D]\}} }} d| vr| d| || || q| D] \}}| ||q| S)a read a MLUT from a hdf file (filename) datasets: list of datasets to read: * None (default): read all datasets, including axes as indicated by the attribute 'dimensions' * a list of: - dataset names (string) - or a tuple (dataset_name, axes) where axes is a list of dimensions (strings), overriding the attribute 'dimensions' r)rNz%datasets should be provided as a listrrcSsg|]}|qSr)striprrrrr"+ rz!read_mlut_hdf..cSsg|] }|dkr dn|qS)NoneNrrrrrr". rOrrcSrrrrrrrr"A rcSrrrrrrrr"D rcSrrrrrrrr"I r)rrrxr rr=r?r[selectinforr1rr/rrr-rrr#rrWrrTr)rrrrZls_axesr6rGr{r;rZsdsnamer7r9rrHr rr|r`rrrr s^             r__main__)r)NNrH) NNNrQrRTrSNNF) NNNTrSNrr|Frrh).r@ __future__rrrsysnumpyr+scipy.interpolateros.pathrosr collectionsrnumpy.mar r version_inforVr rrxrrr&r5rr6rrXrFrErQr7r;rrr!rr rr=doctesttestmodrrrrsd         - +   S hs  $ OR