euGrid
index
/users/schrei_f/src/py4CAtS/aux/euGrid.py

euGrid
 
Read command argument and try to generate a numpy array defining an equidistant/uniform grid.
 
Usage:
 
  euGrid [options] gridSpec
 
  gridSpec can be
  *  an integer
  *  a plain ascii file (grid will be read from first column (# 0, default))
  *  a numpy expression, e.g. "arange(10)" or "linspace(10.,20.)"
  *  a string in the format 'start[step1]stop1[step2]stop' etc to set up an piecewise equidistant/uniform grid.
  NOTE:  except for the first two cases enclose gridSpec in quotes to prevent any 'misinterpretation' by the unix shell
 
Options:
 
  -h               help
  -c     char      comment character(s) used in input,output file (default '#')
  -o     string    output file for saving of grid
  -C     int       number of column to read from file (numpy convention;  default: 0 ---> first column)
  -r               reverse (flip) grid points up <--> down
 --scale float     multiplication factor for grid  (default:  1)
 --shift float     additive constant to shift the grid  (default:  0)
                   NOTE:  scaling is done before shifting !

 
Modules
       
numpy

 
Functions
       
arange(...)
arange([start,] stop[, step,], dtype=None)
 
Return evenly spaced values within a given interval.
 
Values are generated within the half-open interval ``[start, stop)``
(in other words, the interval including `start` but excluding `stop`).
For integer arguments the function is equivalent to the Python built-in
`range <http://docs.python.org/lib/built-in-funcs.html>`_ function,
but returns an ndarray rather than a list.
 
When using a non-integer step, such as 0.1, the results will often not
be consistent.  It is better to use ``linspace`` for these cases.
 
Parameters
----------
start : number, optional
    Start of interval.  The interval includes this value.  The default
    start value is 0.
stop : number
    End of interval.  The interval does not include this value, except
    in some cases where `step` is not an integer and floating point
    round-off affects the length of `out`.
step : number, optional
    Spacing between values.  For any output `out`, this is the distance
    between two adjacent values, ``out[i+1] - out[i]``.  The default
    step size is 1.  If `step` is specified as a position argument,
    `start` must also be given.
dtype : dtype
    The type of the output array.  If `dtype` is not given, infer the data
    type from the other input arguments.
 
Returns
-------
arange : ndarray
    Array of evenly spaced values.
 
    For floating point arguments, the length of the result is
    ``ceil((stop - start)/step)``.  Because of floating point overflow,
    this rule may result in the last element of `out` being greater
    than `stop`.
 
See Also
--------
linspace : Evenly spaced numbers with careful handling of endpoints.
ogrid: Arrays of evenly spaced numbers in N-dimensions.
mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
 
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0.,  1.,  2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])
euGrid(gridSpec, commentChar='#', column=0, scale=None, shift=None, reverse=False, verbose=False)
Parse "gridSpec" and return a numpy array defining a (monotone) grid.
 
gridSpec can be
*  an integer
*  a plain ascii file (grid will be read from first (default) column)
*  a numpy expression, e.g. 'arange(10)' or 'linspace(10.,20.)'
*  a string in the format 'start[step1]stop1[step2]stop' etc to set up a piecewise equidistant/uniform grid
   Example: '0[1]10[2.5]20[5]50'   --->   returns a grid with 21 points.
 
Further arguments:
------------------
commentChar:   The character used to indicate the start of comments in the data file
column:        number of column to read from file (default 0 = very first column)
scale:         a scaling factor (default None)
shift:         a constant to be added (default None)
               NOTE:  the grid is first scaled, then shifted
reverse:       flag to flip "up/down"
verbose:       flag (default False)
is_uniform(xGrid, eps=0.001, verbose=0)
Compute grid point spacing and return a flag True/False if xGrid is uniform/equidistant or not.
If verbose, return a string if uniform, otherwise print info and return an empty string.
parseGridSpec(gridSpec)
Set up a piecewise equidistant/uniform grid (altitude) specified in format 'start[step1]stop1[step2]stop' or similar.
 
Example:  "0[1]10[2]20[2.5]30[5]50" returns an array with 24 grid points.