iWvdZddlZddlZddlZddlZddlmZddlmZddlmZdZ Gdd e Z d Z dS) a Core functionality for storing n-D grids ======================================== The :mod:`core` module contains classes and functions that are independent of the grid data format. In particular this module contains the :class:`Grid` class that acts as a universal constructor for specific formats:: g = Grid(**kwargs) # construct g.export(filename, format) # export to the desired format Some formats can also be read:: g = Grid() # make an empty Grid g.load(filename) # populate with data from filename Classes ------- .. autoclass:: Grid :members: :undoc-members: :show-inheritance: Functions --------- .. autofunction:: ndmeshgrid N)OpenDX)gOpenMol)mrcc6 |jS#t$r|cYSwxYw)zJAccess the underlying ndarray of a Grid object or return the object itself)gridAttributeError)xs W/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/gridData/core.py_gridr 2s2v s  ceZdZdZdZ d4dZedZejdZd Z d Z d Z ed Z d5d Z d5dZd5dZd5dZd5dZd6dZd5dZd5dZ d7dZd8dZdZd9dZdZdZd:dZdZd;dZd Zd!Zd"Z d#Z!d$''   %-$8b ",F)"&  $$$ ) )c$ii.. #4yyHH  )$$$#HHH$# ( O` aaaaa 4&%@@@@@+  s6C1B?3 C?CCCCC0/C0c|jS)zOrder of the B-spline interpolation of the data. 3 = cubic; 4 & 5 are also supported Only choose values that are acceptable to :func:`scipy.ndimage.spline_filter`! See Also -------- interpolated )r&r/s r r3zGrid.interpolation_spline_order s 00c<||_|dS)aSetting the ``interpolation_spline_order`` updates :func:`interpolated` Because we cache the interpolation function, we need to rebuild the cache whenever the interpolation order changes: this is handled by :meth:`_update` N)r&_update)r/r s r r3zGrid.interpolation_spline_orders-.) r8c |j}n#t$rYnwxYw||}t|}|j|}|||S)a/Resample data to a new grid with edges *edges*. This method creates a new grid with the data from the current grid resampled to a regular grid specified by `edges`. The order of the interpolation is set by :attr:`Grid.interpolation_spline_order`: change the value *before* calling :meth:`resample`. Parameters ---------- edges : tuple of arrays or Grid edges of the new grid or a :class:`Grid` instance that provides :attr:`Grid.edges` Returns ------- Grid a new :class:`Grid` with the data interpolated over the new grid cells Examples -------- Providing `edges` (a tuple of three arrays, indicating the boundaries of each grid cell):: g = grid.resample(edges) As a convenience, one can also supply another :class:`Grid` as the argument for this method :: g = grid.resample(othergrid) and the edges are taken from :attr:`Grid.edges`. )r0r _midpoints ndmeshgrid interpolated __class__)r/r0 midpoints coordinatesnewgrids r resamplez Grid.resample%soL KEE    D OOE**  ), #$#[1~~gu---s  c \t|dkrtdtj|tj|z dtj|zz }|t|z }tj|}|dddf|dddfz tjdtj |dddf|dddfz |z z }dtj |dddf|dddfz |z z}dt|dddfd|zz |dddfd|zz|D}| |S) aResample to a new regular grid. Parameters ---------- factor : float The number of grid cells are scaled with `factor` in each dimension, i.e., ``factor * N_i`` cells along each dimension i. Must be positive, and cannot result in fewer than 2 cells along a dimension. Returns ------- interpolated grid : Grid The resampled data are represented on a :class:`Grid` with the new grid cell sizes. See Also -------- resample .. versionchanged:: 0.6.0 Previous implementations would not alter the range of the grid edges being resampled on. As a result, values at the grid edges would creep steadily inward. The new implementation recalculates the extent of grid edges for every resampling. rzFactor must be positiveNrc `g|]+\}}}tj||t|d,S)T)numendpoint)numpylinspaceint).0startstopNs r z(Grid.resample_factor..sLdddL\UTXZ[tQ$GGGdddr8?) float ValueErrorrJarray _max_edges _min_edges _len_edgesr<maximumfloorroundziprC)r/factorspacing newspacing smidpoints edgelengthr0s r resample_factorzGrid.resample_factorUs> ==A  677 7;t0011EK@Q@Q4R4RRu{4??#4#45557uV}}, [!2!233 !B'*QQQT*::u} u{Jqqq"u- 111a40@@JNOO@Q@QR  KAAArE*Z1-==K L LM dd`c qqq!t sZ/ /AAArE1BS:EU1UWaacacddd}}U###r8cptjttd|j|_||j|_tjttd|j|_|j | |_ dSdS)acompute/update all derived data Can be called without harm and is idem-potent. Updates these attributes and methods: :attr:`origin` the center of the cell with index 0,0,0 :attr:`midpoints` centre coordinate of each grid cell :meth:`interpolated` spline interpolation function that can generated a value for coordinate cJ|d|dz t|dz z S)NrErr)lenes r zGrid._update..s!1R51Q4.s QqTr8N) rJrUlistmapr0r2r<r@r1r%_interpolationFunctionFactoryr7s r r:z Grid._updates[ 77 D D"F"FGG 44k$s>>4>'J'J"K"KLL   *"&"D"D"F"FD    + *r8cP|j||_|jS)aB-spline function over the data grid(x,y,z). The :func:`interpolated` function allows one to obtain data values for any values of the coordinates:: interpolated([x1,x2,...],[y1,y2,...],[z1,z2,...]) -> F[x1,y1,z1],F[x2,y2,z2],... The interpolation order is set in :attr:`Grid.interpolation_spline_order`. The interpolated function is computed once and is cached for better performance. Whenever :attr:`~Grid.interpolation_spline_order` is modified, :meth:`Grid.interpolated` is recomputed. The value for unknown data is set in :attr:`Grid.interpolation_cval` (TODO: also recompute when ``interpolation_cval`` value is changed.) Example ------- Example usage for resampling:: XX, YY, ZZ = numpy.mgrid[40:75:0.5, 96:150:0.5, 20:50:0.5] FF = interpolated(XX, YY, ZZ) Note ---- Values are interpolated with a spline function. It is possible that the spline will generate values that would not normally appear in the data. For example, a density is non-negative but a cubic spline interpolation can generate negative values, especially at the boundary between 0 and high values. Internally, the function uses :func:`scipy.ndimage.map_coordinates` with ``mode="constant"`` whereby interpolated values outside the interpolated grid are determined by filling all values beyond the edge with the same constant value, defined by the :attr:`interpolation_cval` parameter, which when not set defaults to the minimum value in the interpolated grid. .. versionchanged:: 0.6.0 Interpolation outside the grid is now performed with ``mode="constant"`` rather than ``mode="nearest"``, eliminating extruded volumes when interpolating beyond the grid. )r%rnr7s r r>zGrid.interpolateds+`   &"&"D"D"F"FD ""r8c2||j}fd|DS)Nc&g|] }|Srjrj)rMrgfuncs r rQz#Grid._map_edges..s!'''AQ'''r8r0)r/rrr0s ` r _map_edgeszGrid._map_edgess) =JE''''''''r8c2|d|S)Nc2d|dd|ddzzS)NrRrErrjrfs r rhz!Grid._midpoints..s#2#122)?r8rs)rtr/r0s r r<zGrid._midpointss??uMMMr8c:|t|SNrs)rtrerws r rXzGrid._len_edgesss%000r8cD|tj|Sry)rtrJminrws r rWzGrid._min_edgesuy666r8cD|tj|Sry)rtrJmaxrws r rVzGrid._max_edgesr|r8Tc|r|j}n|j}|utj|}|ddddvr4tj|dddd}n|ddd}|}|s|j}||vr5td|| |S)Nr)gzrz.File format {} not available, choose one of {}) rr#ospathsplitextupperdefault_formatrTformatkeys)r/r4rexport availablesplitteds r _guess_formatzGrid._guess_formats  &II I  w''11H{122(** g..x{;;A>qrrB &qk!""o !''))  .-K i ' '@GG!1!13344 4r8cH|j|||dS)NTrr)rrr/r4rs r _get_exporterzGrid._get_exporters2t11(>I9= 2 ? ?@ @r8cH|j|||dS)NFr)r#rrs r _get_loaderzGrid._get_loaders0}T//>? ?r8c|6tj||_||_|dS$!tjtjt |jkrtdjdkr1tj rtj |jznAjdkrtdt |jkrtdfdt|jD|_tj||_|dStd||)Nz6Dimension of origin is not the same as grid dimension.rjrz(Non-rectangular grids are not supported.z5delta should be scalar or array-like oflen(grid.ndim)cng|]1\}}|tj|dzdz |zz2S)rrR)rJarange)rMdimrkr2r1s r rQzGrid._load..sV???$c1!+ <A..4c BC???r8zWrong/missing data to set up Grid. Use Grid() or Grid(grid=, edges=) or Grid(grid=, origin=(x0, y0, z0), delta=(dx, dy, dz)): grid={0} edges={1} origin={2} delta={3})rJ asanyarrayrr0r:rendim TypeErrorshapeisrealonesNotImplementedError enumeraterTr)r/rr0r$r1r2s ``r r.z Grid._loads  (..DIDJ LLNNNNN  E$5%f--F$U++E6{{di''LNNN{b  U\%%8%8  49--5a)>@@@Uty((!1222?????(1$*(=(=???DJ(..DI LLNNNNN:;A&%;0;0 11 1r8ct|}tj|st t jd||||}|||dS)zLoad saved grid and edges from `filename` The :meth:`load` method calls the class's constructor method and completely resets all values, based on the loaded data. zfile not foundrrN)r)rrexistsr,errnoENOENTr)r/r4rrloaders r r-z Grid.load,sq x==w~~h'' D%,(8(CC C!!( !DDx+<======r8c t|d5}tj|}dddn #1swxYwY||d|d|ddS)Nrrr0r$rr0r$)r*pickler-r.)r/r4kwargsfsaveds r r"zGrid._load_python;s (D ! ! #QKNNE # # # # # # # # # # # # # # # f w!*-  / / / / /s 266c tj||}|\}}||||j|j|_dS)z&Initializes Grid from a MRC/CCP4 file.rrN)rr histogramddr.r$headercopy _mrc_header)r/r4rrmrcfilerr0s r rzGrid._load_mrcBsd'(6GHHH))++ e EDM BBB#>..00r8c tjd}|||\}}||||jdS)z$Initializes Grid from a OpenDX file.rrN)rfieldreadrr.r$)r/r4rdxrr0s r r z Grid._load_dxKsT \!__ nn&& e EDM BBBBBr8c tj}|||\}}||||jdS)z'Initialize Grid from gOpenMol plt file.rN)rPltrrr.r$)r/r4rgrr0s r r!zGrid._load_pltRsP LNN xmmoo e EDM BBBBBr8"cnt|}|||}||||dS)aexport density to file using the given format. The format can also be deduced from the suffix of the filename although the `file_format` keyword takes precedence. The default format for :meth:`export` is 'dx'. Use 'dx' for visualization. Implemented formats: dx :mod:`OpenDX` mrc :mod:`mrc` MRC/CCP4 format pickle pickle (use :meth:`Grid.load` to restore); :meth:`Grid.save` is simpler than ``export(format='python')``. Parameters ---------- filename : str name of the output file file_format : {'dx', 'pickle', 'mrc', None} (optional) output file format, the default is "dx" type : str (optional) for DX, set the output DX array type, e.g., "double" or "float". By default (``None``), the DX type is determined from the numpy dtype of the array of the grid (and this will typically result in "double"). .. versionadded:: 0.4.0 typequote : str (optional) For DX, set the character used to quote the type string; by default this is a double-quote character, '"'. Custom parsers like the one from NAMD-GridForces (backend for MDFF) expect no quotes, and typequote='' may be used to appease them. .. versionadded:: 0.5.0 rtype typequoteN)r)r)r/r4rrrexporters r rz Grid.exportYsEXx==%%hK%HH ::::::r8c t|j|j|j}t |d5}t j||t jddddS#1swxYwYdS)zPickle the Grid object The object is dumped as a dictionary with grid and edges: This is sufficient to recreate the grid object with ``__init__()``. rwbN)dictrr0r$r*rdumpHIGHEST_PROTOCOL)r/r4rdatars r rzGrid._export_pythons $*t}MMM (D ! ! :Q Ka!8 9 9 9 : : : : : : : : : : : : : : : : : :s!A  A$'A$c tj|\}}|dz}gd}|jr|d|jD]E}|dt |zdzt |j|zF|dt tjd|j j |j |j tj d|j j tjd |j ||  } tjd | | } |dkr||z}| |dS)aTExport the density grid to an OpenDX file. The file format is the simplest regular grid array and it is also understood by VMD's and Chimera's DX reader; PyMOL requires the dx `type` to be set to "double". For the file format see http://opendx.sdsc.edu/docs/html/pages/usrgu068.htm#HDREDF z.dx)zvarying, then y, then finally x, i.e. z is the innermost loop.z-Meta data stored with the python Grid object:z z = z<(Note: the VMD dx-reader chokes on comments below this line)rrFrr) positions connectionsrdensity) componentscommentsz.gzN)rrrr$appendr)rr gridpositionsrrr1r2gridconnectionsrUrwrite) r/r4rrrrootextrkrrs r rzGrid._export_dxsfG$$X.. c%<NNN = M OOK L L L L LA OOECFFNU2Sq9I5J5JJ K K K K J L L L*1diot{+/:77.q$)/BBaKKK    \) X N N N %<<czH r8c tj}|j|_t j|j|_|j|_d|_t|dr |j |_ | |dS)aExport the density grid to an MRC/CCP4 file. The MRC2014 file format is used via the mrcfile library. Parameters ---------- filename : str Output filename **kwargs Additional keyword arguments (currently ignored) Notes ----- * Only orthorhombic unit cells are supported * If the Grid was loaded from an MRC file, the original header information (including axis ordering) is preserved * For new grids, standard ordering (mapc=1, mapr=2, maps=3) is used .. versionadded:: 1.1.0 rrN) rrrrUrJdiagr2r1rankhasattrrrr)r/r4rmrc_files r rzGrid._export_mrcss,799DJ//+  4 ' ' /".HO x     r8c4||ddS)aSave a grid object to `filename` and add ".pickle" extension. Internally, this calls ``Grid.export(filename, format="python")``. A grid can be regenerated from the saved data with :: g = Grid(filename="grid.pickle") .. note:: The pickle format depends on the Python version and therefore it is not guaranteed that a grid saved with, say, Python 2.7 can also be read with Python 3.5. The OpenDX format is a better alternative for portability. rrN)r)r/r4s r savez Grid.saves H( 33333r8c#Ktj|jjD](}|jtj|z|jzV)dS)zReturns the coordinates of the centers of all grid cells as an iterator. See Also -------- :func:`numpy.ndindex` N)rJndindexrrr2rUr1)r/idxs r centersz Grid.centerssV=11 > >C*u{3///$+= = = = = > >r8c8t|tr2tdt|j|jD}nA t j|j|j|jjk}n#t$rd}YnwxYw|stddS)aCheck if `other` can be used in an arithmetic operation. `other` is compatible if 1) `other` is a scalar or an array-like broadcastable to the grid 2) `other` is a grid defined on the same edges In order to make `other` compatible, resample it on the same grid as this one using :meth:`resample`. Parameters ---------- other : Grid or float or int Another object to be used for standard arithmetic operations with this :class:`Grid` Raises ------ TypeError if not compatible See Also -------- :meth:`resample` c3FK|]\}}tj||VdSN)rJallcloserM other_edge self_edges r z(Grid.check_compatible..sF  )J z955      r8FzThe argument cannot be arithmetically combined with the grid. It must be broadcastable to the grid's shape or a `Grid` with identical edges. Use `Grid.resample(other.edges)` to make a new grid that is compatible with `other`.T) r(rallr\r0rJ broadcastrrrTr)r/other is_compatibles r check_compatiblezGrid.check_compatibles4 eT " " &  -0dj-I-I   MM  & % 5 A A G49? Z  & & & %  & ,+,, , ts -A77 BBc8 ddl ||j}|j|j}| |}n#t $r|}YnwxYw j|||j |j d fd}|S)a0Returns a function F(x,y,z) that interpolates any values on the grid. _interpolationFunctionFactory(self,spline_order=3,cval=None) --> F *cval* is set to :meth:`Grid.grid.min`. *cval* cannot be chosen too large or too small or NaN because otherwise the spline interpolation breaks down near that region and produces wild oscillations. .. Note:: Only correct for equally spaced values (i.e. regular edges with constant delta). .. SeeAlso:: http://www.scipy.org/Cookbook/Interpolation rN)orderc6tj||z |z Sr)rJ atleast_1d)cnewc0dcs r _transformz6Grid._interpolationFunctionFactory.._transformQs$T**R/25 5r8ctjfdttD}j|ddS)aGB-spline function over the data grid(x,y,z). interpolatedF([x1,x2,...],[y1,y2,...],[z1,z2,...]) -> F[x1,y1,z1],F[x2,y2,z2],... Example usage for resampling:: >>> XX,YY,ZZ = numpy.mgrid[40:75:0.5, 96:150:0.5, 20:50:0.5] >>> FF = _interpolationFunction(XX,YY,ZZ) cNg|]!}|||"Srjrj)rMirrArx0s r rQzMGrid._interpolationFunctionFactory..interpolatedF..^s?###aKNBqE2a599###r8Fconstant) prefiltermodecval)rJrUrangerendimagemap_coordinates)rA _coordinatesrcoeffsrrscipyrs` r interpolatedFz9Grid._interpolationFunctionFactory..interpolatedFTs!;#######5J!J!D"D"###$$L=001=;@6@6: 1<< .lsQ77.Z  Ii' ) )777777r8)r(rrJrrr1r\r0r/rs r __eq__z Grid.__eq__gs%&& 5y J$) #%%). LDK '*)*)-2Y77  777.. r8c.|| Sr)rrs r __ne__z Grid.__ne__ss;;u%%%%r8c||||jt|z|jSryrr?rr r0rs r __add__z Grid.__add__v; e$$$~~di%,,6dj~IIIr8c||||jt|z |jSryr rs r __sub__z Grid.__sub__zrr8c||||jt|z|jSryr rs r __mul__z Grid.__mul__~rr8c||||jt|z |jSryr rs r __truediv__zGrid.__truediv__rr8c||||jt|z|jSryr rs r __floordiv__zGrid.__floordiv__s; e$$$~~di5<<7tz~JJJr8c|||tj|jt ||jSry)rr?rJpowerrr r0rs r __pow__z Grid.__pow__sU e$$$~~ K e   *  r8c|||t||jz|jSryrr?r rr0rs r __radd__z Grid.__radd__; e$$$~~eEllTY6dj~IIIr8c|||t||jz |jSryrrs r __rsub__z Grid.__rsub__rr8c|||t||jz|jSryrrs r __rmul__z Grid.__rmul__rr8c|||t||jz |jSryrrs r __rtruediv__zGrid.__rtruediv__rr8c|||t||jz|jSryrrs r __rfloordiv__zGrid.__rfloordiv__s; e$$$~~eElldi7tz~JJJr8c|||tjt ||j|jSry)rr?rJrr rr0rs r __rpow__z Grid.__rpow__sU e$$$~~ Ke    *  r8cx |jj}n#t$rd}YnwxYwd|j|S)Nnoz<{0} with {1!r} bins>)rrr rr?)r/binss r __repr__z Grid.__repr__sN 9?DD   DDD &--dndCCCs  )NNNNNrNFr)NT)NNNNN)NF)F)NNr)Nr)NN)2__name__ __module__ __qualname____doc__rr5propertyr3setterrCrbr:r>rtr<rXrWrVrrrr.r-r"rr r!rrrrrrrrnrr r rrrrrrrr!r#r%r'r+rjr8r rr:sXXvNAE;<5:/A/A/A/Ab 1 1X 1 &  '& ......`2$2$2$hGGG,1#1#X1#f(((( NNNN111177777777(@@@@ ???? '1'1'1'1T > > > >///1111CCCCCC.;.;.;.;h:::&&&&P!!!!!!F444$ > > >***X::::x   &&&JJJJJJJJJJJJKKKJJJJJJJJJJJJKKKDDDDDr8rct|}ttt|}t|}d}|D]}||z}g}t |D]\}}dg|z}||||<t j||} t |D]"\} }| |kr| || } #| | t|S)aReturn a mesh grid for N dimensions. The input are N arrays, each of which contains the values along one axis of the coordinate system. The arrays do not have to have the same number of entries. The function returns arrays that can be fed into numpy functions so that they produce values for *all* points spanned by the axes *arrs*. Original from http://stackoverflow.com/questions/1827489/numpy-meshgrid-in-3d and fixed. .. SeeAlso: :func:`numpy.meshgrid` for the 2D case. r)axis) tuplerlrmrerrJrreshaperepeatr) arrslensrszsansrarrslcarr2js r r=r=s ;;D C  D d))C B  a CD//3cCiaA$$,,S11t__ / /EArAvv{{2A{.. 4 ::r8) r/rrrrJrrrr objectrr=rjr8r rBs@ y Dy Dy Dy Dy D6y Dy Dy Dx     r8