def __init__(
self,
min=(0, 0), # minimum coordinates
max=(1, 1), # maximum coordinates
division=(4, 4), # cell divisions
dirnames=('x', 'y', 'z')): # names of the directions
"""
Initialize a BoxGrid by giving domain range (minimum and
maximum coordinates: min and max tuples/lists/arrays)
and number of cells in each space direction (division tuple/list/array).
The dirnames tuple/list holds the names of the coordinates in
the various spatial directions.
>>> g = UniformBoxGrid(min=0, max=1, division=10)
>>> g = UniformBoxGrid(min=(0,-1), max=(1,1), division=(10,4))
>>> g = UniformBoxGrid(min=(0,0,-1), max=(2,1,1), division=(2,3,5))
"""
# Allow int/float specifications in one-dimensional grids
# (just turn to lists for later multi-dimensional processing)
if isinstance(min, (int, float)):
min = [min]
if isinstance(max, (int, float)):
max = [max]
if isinstance(division, (int, float)):
division = [division]
if isinstance(dirnames, str):
dirnames = [dirnames]
self.nsd = len(min)
# strip dirnames down to right space dim (in case the default
# with three components were unchanged by the user):
dirnames = dirnames[:self.nsd]
# check consistent lengths:
for a in max, division:
if len(a) != self.nsd:
raise ValueError(
'Incompatible lengths of arguments to constructor'\
' (%d != %d)' % (len(a), self.nsd))
self.min_coor = array(min, float)
self.max_coor = array(max, float)
self.dirnames = dirnames
self.division = division
self.coor = [None] * self.nsd
self.shape = [0] * self.nsd
self.delta = zeros(self.nsd)
for i in range(self.nsd):
self.delta[i] = \
(self.max_coor[i] - self.min_coor[i])/float(self.division[i])
self.shape[i] = self.division[i] + 1 # no of grid points
self.coor[i] = \
linspace(self.min_coor[i], self.max_coor[i], self.shape[i])
self._more_init()
def __init__(self,
min=(0,0), # minimum coordinates
max=(1,1), # maximum coordinates
division=(4,4), # cell divisions
dirnames=('x', 'y', 'z')): # names of the directions
"""
Initialize a BoxGrid by giving domain range (minimum and
maximum coordinates: min and max tuples/lists/arrays)
and number of cells in each space direction (division tuple/list/array).
The dirnames tuple/list holds the names of the coordinates in
the various spatial directions.
>>> g = UniformBoxGrid(min=0, max=1, division=10)
>>> g = UniformBoxGrid(min=(0,-1), max=(1,1), division=(10,4))
>>> g = UniformBoxGrid(min=(0,0,-1), max=(2,1,1), division=(2,3,5))
"""
# Allow int/float specifications in one-dimensional grids
# (just turn to lists for later multi-dimensional processing)
if isinstance(min, (int,float)):
min = [min]
if isinstance(max, (int,float)):
max = [max]
if isinstance(division, (int,float)):
division = [division]
if isinstance(dirnames, str):
dirnames = [dirnames]
self.nsd = len(min)
# strip dirnames down to right space dim (in case the default
# with three components were unchanged by the user):
dirnames = dirnames[:self.nsd]
# check consistent lengths:
for a in max, division:
if len(a) != self.nsd:
raise ValueError(
'Incompatible lengths of arguments to constructor'\
' (%d != %d)' % (len(a), self.nsd))
self.min_coor = array(min, float)
self.max_coor = array(max, float)
self.dirnames = dirnames
self.division = division
self.coor = [None]*self.nsd
self.shape = [0]*self.nsd
self.delta = zeros(self.nsd)
for i in range(self.nsd):
self.delta[i] = \
(self.max_coor[i] - self.min_coor[i])/float(self.division[i])
self.shape[i] = self.division[i] + 1 # no of grid points
self.coor[i] = \
linspace(self.min_coor[i], self.max_coor[i], self.shape[i])
self._more_init()
def _add_bar_graph(self, item, shading='faceted'):
if DEBUG:
print "Adding a bar graph"
# get data:
x = squeeze(item.getp('xdata'))
y = squeeze(item.getp('ydata'))
# get line specifiactions:
marker, color, style, width = self._get_linespecs(item)
edgecolor = item.getp('edgecolor')
if not edgecolor:
edgecolor = 'k' # use black for now
# FIXME: edgecolor should be same as ax.getp('fgcolor') by default
facecolor = item.getp('facecolor')
if not facecolor:
facecolor = color
opacity = item.getp('material').getp('opacity')
if opacity is None:
opacity = 1.0
if y.ndim == 1:
y = reshape(y,(len(y),1))
nx, ny = shape(y)
step = item.getp('barstepsize')/10
center = floor(ny/2)
start = -step*center
stop = step*center
if not ny%2:
start += step/2
stop -= step/2
a = linspace(start,stop,ny)
barwidth = item.getp('barwidth')/10
hold_state = self._g.ishold()
self._g.hold(True)
colors = PlotProperties._colors + \
list(matplotlib.colors.cnames.values())
for j in range(ny):
y_ = y[:,j]
x_ = array(list(range(nx))) + a[j] - barwidth/2
if not facecolor:
c = colors[j]
else:
c = facecolor
self._g.bar(x_, y_, width=barwidth, color=c,
ec=edgecolor, alpha=opacity)
self._g.hold(hold_state)
barticks = item.getp('barticks')
if barticks is None:
barticks = x
if item.getp('rotated_barticks'):
self._g.xticks(list(range(len(x))), barticks, rotation=90)
else:
self._g.xticks(list(range(len(x))), barticks)
def gridline_slice(self, start_coor, direction=0, end_coor=None):
"""
Compute start and end indices of a line through the grid,
and return a tuple that can be used as slice for the
grid points along the line.
The line must be in x, y or z direction (direction=0,1 or 2).
If end_coor=None, the line ends where the grid ends.
start_coor holds the coordinates of the start of the line.
If start_coor does not coincide with one of the grid points,
the line is snapped onto the grid (i.e., the line coincides with
a grid line).
Return: tuple with indices and slice describing the grid point
indices that make up the line, plus a boolean "snapped" which is
True if the original line did not coincide with any grid line,
meaning that the returned line was snapped onto to the grid.
>>> g2 = UniformBoxGrid.init_fromstring('[-1,1]x[-1,2] [0:3]x[0:4]')
>>> print g2.coor
[array([-1. , -0.33333333, 0.33333333, 1. ]),
array([-1. , -0.25, 0.5 , 1.25, 2. ])]
>>> g2.gridline_slice((-1, 0.5), 0)
((slice(0, 4, 1), 2), False)
>>> g2.gridline_slice((-0.9, 0.4), 0)
((slice(0, 4, 1), 2), True)
>>> g2.gridline_slice((-0.2, -1), 1)
((1, slice(0, 5, 1)), True)
"""
start_cell, start_distance, start_match, start_nearest = \
self.locate_cell(start_coor)
# If snapping the line onto to the grid is not desired, the
# start_cell and start_match lists must be used for interpolation
# (i.e., interpolation is needed in the directions i where
# start_match[i] is False).
start_snapped = start_nearest[:]
if end_coor is None:
end_snapped = start_snapped[:]
end_snapped[direction] = self.division[
direction] # highest legal index
else:
end_cell, end_distance, end_match, end_nearest = \
self.locate_cell(end_coor)
end_snapped = end_nearest[:]
# recall that upper index limit must be +1 in a slice:
line_slice = start_snapped[:]
line_slice[direction] = \
slice(start_snapped[direction], end_snapped[direction]+1, 1)
# note that if all start_match are true, then the plane
# was not snapped
return tuple(line_slice), not array(start_match).all()
def gridline_slice(self, start_coor, direction=0, end_coor=None):
"""
Compute start and end indices of a line through the grid,
and return a tuple that can be used as slice for the
grid points along the line.
The line must be in x, y or z direction (direction=0,1 or 2).
If end_coor=None, the line ends where the grid ends.
start_coor holds the coordinates of the start of the line.
If start_coor does not coincide with one of the grid points,
the line is snapped onto the grid (i.e., the line coincides with
a grid line).
Return: tuple with indices and slice describing the grid point
indices that make up the line, plus a boolean "snapped" which is
True if the original line did not coincide with any grid line,
meaning that the returned line was snapped onto to the grid.
>>> g2 = UniformBoxGrid.init_fromstring('[-1,1]x[-1,2] [0:3]x[0:4]')
>>> print g2.coor
[array([-1. , -0.33333333, 0.33333333, 1. ]),
array([-1. , -0.25, 0.5 , 1.25, 2. ])]
>>> g2.gridline_slice((-1, 0.5), 0)
((slice(0, 4, 1), 2), False)
>>> g2.gridline_slice((-0.9, 0.4), 0)
((slice(0, 4, 1), 2), True)
>>> g2.gridline_slice((-0.2, -1), 1)
((1, slice(0, 5, 1)), True)
"""
start_cell, start_distance, start_match, start_nearest = \
self.locate_cell(start_coor)
# If snapping the line onto to the grid is not desired, the
# start_cell and start_match lists must be used for interpolation
# (i.e., interpolation is needed in the directions i where
# start_match[i] is False).
start_snapped = start_nearest[:]
if end_coor is None:
end_snapped = start_snapped[:]
end_snapped[direction] = self.division[direction] # highest legal index
else:
end_cell, end_distance, end_match, end_nearest = \
self.locate_cell(end_coor)
end_snapped = end_nearest[:]
# recall that upper index limit must be +1 in a slice:
line_slice = start_snapped[:]
line_slice[direction] = \
slice(start_snapped[direction], end_snapped[direction]+1, 1)
# note that if all start_match are true, then the plane
# was not snapped
return tuple(line_slice), not array(start_match).all()
def _add_bars(self, name, item, shading='faceted'):
if DEBUG:
print("Adding a bar graph")
# get data:
x = item.getp('xdata')
y = item.getp('ydata')
# get line specifiactions:
marker, color, style, width = self._get_linespecs(item)
if y.ndim == 1:
y = reshape(y, (len(y), 1))
nx, ny = shape(y)
barticks = item.getp('barticks')
if barticks is None:
barticks = list(range(nx))
xtics = ', '.join(['"%s" %d' % (m, i)
for i, m in enumerate(barticks)])
if item.getp('rotated_barticks'):
pass
barwidth = item.getp('barwidth') / 10
edgecolor = item.getp('edgecolor')
if not edgecolor:
edgecolor = 'black' # use black for now
# FIXME: edgecolor should be same as ax.getp('fgcolor') by default
else:
edgecolor = self._colors.get(edgecolor, 'black')
if shading == 'faceted':
pass
else:
pass
facecolor = item.getp('facecolor')
if not facecolor:
facecolor = color
facecolor = self._colors.get(facecolor, 'blue') # use blue as default
step = item.getp('barstepsize') / 10
center = floor(ny / 2)
start = -step * center
stop = step * center
if not ny % 2:
start += step / 2
stop -= step / 2
a = linspace(start, stop, ny)
self._g.configure(barmode="overlap")
data = []
for j in range(ny):
y_ = y[:, j]
x_ = array(list(range(nx))) + a[j]
curvename = '%s_bar%s' % (name, j)
if not item.getp('linecolor') and not item.getp('facecolor'):
color = 'black'
else:
color = facecolor
self._g.bar_create(curvename,
xdata=tuple(x_),
ydata=tuple(y_),
barwidth=barwidth,
fg=color)