[Yt-svn] yt-commit r1113 - in branches/grid-optimization: . yt/lagos
mturk at wrangler.dreamhost.com
mturk at wrangler.dreamhost.com
Thu Jan 15 08:39:38 PST 2009
Author: mturk
Date: Thu Jan 15 08:39:36 2009
New Revision: 1113
URL: http://yt.spacepope.org/changeset/1113
Log:
Reduced number of grid methods, but unfortunately ALSO introduced problems wiht
dxs and dds. Hopefully those can be worked out soon...
Added:
branches/grid-optimization/ (props changed)
- copied from r1112, /trunk/
Modified:
branches/grid-optimization/yt/lagos/BaseDataTypes.py
branches/grid-optimization/yt/lagos/BaseGridType.py
branches/grid-optimization/yt/lagos/EnzoFields.py
branches/grid-optimization/yt/lagos/FieldInfoContainer.py
Modified: branches/grid-optimization/yt/lagos/BaseDataTypes.py
==============================================================================
--- /trunk/yt/lagos/BaseDataTypes.py (original)
+++ branches/grid-optimization/yt/lagos/BaseDataTypes.py Thu Jan 15 08:39:36 2009
@@ -106,7 +106,7 @@
"""
_grids = None
_num_ghost_zones = 0
- _con_args = []
+ _con_args = ()
def __init__(self, pf, fields, **kwargs):
"""
@@ -375,7 +375,7 @@
class AMROrthoRayBase(AMR1DData):
_key_fields = ['x','y','z','dx','dy','dz']
_type_name = "ortho_ray"
- _con_args = ['axis', 'coords']
+ _con_args = ('axis', 'coords')
def __init__(self, axis, coords, fields=None, pf=None, **kwargs):
"""
Dimensionality is reduced to one, and an ordered list of points at an
@@ -421,7 +421,7 @@
class AMRRayBase(AMR1DData):
_type_name = "ray"
- _con_args = ['start_point', 'end_point']
+ _con_args = ('start_point', 'end_point')
def __init__(self, start_point, end_point, fields=None, pf=None, **kwargs):
"""
We accept a start point and an end point and then get all the data
@@ -473,8 +473,7 @@
mask = na.zeros(grid.ActiveDimensions, dtype='int')
import RTIntegrator as RT
RT.VoxelTraversal(mask, grid.LeftEdge, grid.RightEdge,
- na.array([grid.dx, grid.dy, grid.dz]),
- self.center, self.vec)
+ grid.dds, self.center, self.vec)
return mask
class AMR2DData(AMRData, GridPropertiesMixin, ParallelAnalysisInterface):
@@ -617,7 +616,7 @@
_top_node = "/Slices"
_type_name = "slice"
- _con_args = ['axis', 'coord']
+ _con_args = ('axis', 'coord')
#@time_execution
def __init__(self, axis, coord, fields = None, center=None, pf=None,
node_name = False, source = None, **kwargs):
@@ -706,7 +705,7 @@
def _generate_grid_coords(self, grid):
xaxis = x_dict[self.axis]
yaxis = y_dict[self.axis]
- ds, dx, dy = grid['dds'][self.axis], grid['dds'][xaxis], grid['dds'][yaxis]
+ ds, dx, dy = grid.dds[self.axis], grid.dds[xaxis], grid.dds[yaxis]
wantedIndex = int(((self.coord-grid.LeftEdge[self.axis])/ds))
sl = [slice(None), slice(None), slice(None)]
sl[self.axis] = slice(wantedIndex, wantedIndex + 1)
@@ -733,7 +732,7 @@
def _get_data_from_grid(self, grid, field):
# So what's our index of slicing? This is what we need to figure out
# first, so we can deal with our data in the fastest way.
- dx = grid['dds'][self.axis]
+ dx = grid.dds[self.axis]
wantedIndex = int(((self.coord-grid.LeftEdge[self.axis])/dx))
sl = [slice(None), slice(None), slice(None)]
sl[self.axis] = slice(wantedIndex, wantedIndex + 1)
@@ -770,7 +769,7 @@
_top_node = "/CuttingPlanes"
_key_fields = AMR2DData._key_fields + ['pz','pdz']
_type_name = "cutting"
- _con_args = ['normal', 'center']
+ _con_args = ('normal', 'center')
def __init__(self, normal, center, fields = None, node_name = None,
**kwargs):
"""
@@ -830,16 +829,16 @@
# This is slow. Suggestions for improvement would be great...
ss = grid.ActiveDimensions
D = na.ones(ss) * self._d
- x = grid.LeftEdge[0] + grid.dx * \
+ x = grid.LeftEdge[0] + grid.dds[0] * \
(na.arange(grid.ActiveDimensions[0], dtype='float64')+0.5)
- y = grid.LeftEdge[1] + grid.dy * \
+ y = grid.LeftEdge[1] + grid.dds[1] * \
(na.arange(grid.ActiveDimensions[1], dtype='float64')+0.5)
- z = grid.LeftEdge[2] + grid.dz * \
+ z = grid.LeftEdge[2] + grid.dds[2] * \
(na.arange(grid.ActiveDimensions[2], dtype='float64')+0.5)
D += (x * self._norm_vec[0]).reshape(ss[0],1,1)
D += (y * self._norm_vec[1]).reshape(1,ss[1],1)
D += (z * self._norm_vec[2]).reshape(1,1,ss[2])
- diag_dist = na.sqrt(na.sum(grid['dds']**2.0))
+ diag_dist = na.sqrt(na.sum(grid.dds**2.0))
cm = (na.abs(D) <= 0.5*diag_dist) # Boolean
return cm
@@ -892,7 +891,7 @@
_top_node = "/Projections"
_key_fields = AMR2DData._key_fields + ['weight_field']
_type_name = "proj"
- _con_args = ['axis', 'field', 'weight_field']
+ _con_args = ('axis', 'field', 'weight_field')
def __init__(self, axis, field, weight_field = None,
max_level = None, center = None, pf = None,
source=None, node_name = None, field_cuts = None, **kwargs):
@@ -1027,7 +1026,7 @@
field_data *= convs[...,na.newaxis]
mylog.info("Level %s done: %s final", \
level, coord_data.shape[1])
- dx = grids_to_project[0]['dds'][self.axis] # this is our dl
+ dx = grids_to_project[0].dds[self.axis] # this is our dl
return coord_data, dx, field_data
def __combine_grids_on_level(self, level):
@@ -1071,7 +1070,7 @@
args += self.__retval_coords[grid2.id] + [self.__retval_fields[grid2.id]]
args += self.__retval_coords[grid1.id] + [self.__retval_fields[grid1.id]]
# Refinement factor, which is same in all directions
- args.append(int(grid2.dx / grid1.dx))
+ args.append(int(grid2['dx'] / grid1['dx']))
args.append(na.ones(args[0].shape, dtype='int64'))
kk = PointCombine.CombineGrids(*args)
goodI = args[-1].astype('bool')
@@ -1218,7 +1217,6 @@
self.center = center
self.set_field_parameter("center",center)
self.coords = None
- self.dx = None
self._grids = None
def _generate_coords(self):
@@ -1242,7 +1240,7 @@
@restore_grid_state
def _generate_grid_coords(self, grid, field=None):
pointI = self._get_point_indices(grid)
- dx = na.ones(pointI[0].shape[0], 'float64') * grid.dx
+ dx = na.ones(pointI[0].shape[0], 'float64') * grid.dds[0]
tr = na.array([grid['x'][pointI].ravel(), \
grid['y'][pointI].ravel(), \
grid['z'][pointI].ravel(), \
@@ -1417,7 +1415,7 @@
for things like selection along a baryon field.
"""
_type_name = "extracted_region"
- _con_args = ['_base_region', '_indices']
+ _con_args = ('_base_region', '_indices')
def __init__(self, base_region, indices, force_refresh=True, **kwargs):
cen = base_region.get_field_parameter("center")
AMR3DData.__init__(self, center=cen,
@@ -1508,7 +1506,7 @@
We can define a cylinder (or disk) to act as a data object.
"""
_type_name = "disk"
- _con_args = ['center', '_norm_vec', '_radius', '_height']
+ _con_args = ('center', '_norm_vec', '_radius', '_height')
def __init__(self, center, normal, radius, height, fields=None,
pf=None, **kwargs):
"""
@@ -1571,7 +1569,7 @@
AMRRegions are rectangular prisms of data.
"""
_type_name = "region"
- _con_args = ['center', 'left_edge', 'right_edge']
+ _con_args = ('center', 'left_edge', 'right_edge')
def __init__(self, center, left_edge, right_edge, fields = None,
pf = None, **kwargs):
"""
@@ -1610,7 +1608,7 @@
AMRRegions are rectangular prisms of data.
"""
_type_name = "periodic_region"
- _con_args = ['center', 'left_edge', 'right_edge']
+ _con_args = ('center', 'left_edge', 'right_edge')
def __init__(self, center, left_edge, right_edge, fields = None,
pf = None, **kwargs):
"""
@@ -1695,7 +1693,7 @@
A sphere of points
"""
_type_name = "sphere"
- _con_args = ['center', 'radius']
+ _con_args = ('center', 'radius')
def __init__(self, center, radius, fields = None, pf = None, **kwargs):
"""
The most famous of all the data objects, we define it via a
@@ -1743,7 +1741,7 @@
"""
_spatial = True
_type_name = "covering_grid"
- _con_args = ['level', 'left_edge', 'right_edge', 'ActiveDimensions']
+ _con_args = ('level', 'left_edge', 'right_edge', 'ActiveDimensions')
def __init__(self, level, left_edge, right_edge, dims, fields = None,
pf = None, num_ghost_zones = 0, use_pbar = True, **kwargs):
"""
@@ -1756,11 +1754,12 @@
self.right_edge = na.array(right_edge)
self.level = level
self.ActiveDimensions = na.array(dims)
- self.dx, self.dy, self.dz = (self.right_edge-self.left_edge) \
- / self.ActiveDimensions
- self.data["dx"] = self.dx
- self.data["dy"] = self.dy
- self.data["dz"] = self.dz
+ dds = (self.right_edge-self.left_edge) \
+ / self.ActiveDimensions
+ self.dds = dds
+ self.data["dx"] = dds[0]
+ self.data["dy"] = dds[1]
+ self.data["dz"] = dds[2]
self._num_ghost_zones = num_ghost_zones
self._use_pbar = use_pbar
self._refresh_data()
@@ -1784,9 +1783,9 @@
def _refresh_data(self):
AMR3DData._refresh_data(self)
- self['dx'] = self.dx * na.ones(self.ActiveDimensions, dtype='float64')
- self['dy'] = self.dy * na.ones(self.ActiveDimensions, dtype='float64')
- self['dz'] = self.dz * na.ones(self.ActiveDimensions, dtype='float64')
+ self['dx'] = self.dds[0] * na.ones(self.ActiveDimensions, dtype='float64')
+ self['dy'] = self.dds[1] * na.ones(self.ActiveDimensions, dtype='float64')
+ self['dz'] = self.dds[2] * na.ones(self.ActiveDimensions, dtype='float64')
def get_data(self, field=None):
self._get_list_of_grids()
@@ -1797,8 +1796,16 @@
_fields_to_get = ensure_list(field)
fields_to_get = [f for f in _fields_to_get if f not in self.data]
if len(fields_to_get) == 0: return
+ new_fields = []
for field in fields_to_get:
- self[field] = na.zeros(self.ActiveDimensions, dtype='float64') -999
+ if not field in self.pf.hierarchy.field_list:
+ self._generate_field(field)
+ #self[field] = self.pf.field_info[field](self)
+ else:
+ self[field] = na.zeros(self.ActiveDimensions, dtype='float64') -999
+ new_fields.append(field)
+ fields_to_get = new_fields
+ if len(new_fields) == 0: return
mylog.debug("Getting fields %s from %s possible grids",
fields_to_get, len(self._grids))
if self._use_pbar: pbar = \
@@ -1834,8 +1841,8 @@
@restore_grid_state
def _get_data_from_grid(self, grid, fields):
ll = int(grid.Level == self.level)
- g_dx = na.array([grid.dx, grid.dy, grid.dz])
- c_dx = na.array([self.dx, self.dy, self.dz])
+ g_dx = grid.dds.ravel()
+ c_dx = self.dds.ravel()
g_fields = [grid[field] for field in ensure_list(fields)]
c_fields = [self[field] for field in ensure_list(fields)]
PointCombine.DataCubeRefine(
@@ -1845,8 +1852,8 @@
def _flush_data_to_grid(self, grid, fields):
ll = int(grid.Level == self.level)
- g_dx = na.array([grid.dx, grid.dy, grid.dz])
- c_dx = na.array([self.dx, self.dy, self.dz])
+ g_dx = grid.dds.ravel()
+ c_dx = self.dds.ravel()
g_fields = []
for field in ensure_list(fields):
if not grid.has_key(field): grid[field] = \
@@ -1868,21 +1875,23 @@
kwargs['num_ghost_zones'] = 0
AMRCoveringGridBase.__init__(self, *args, **kwargs)
if na.any(self.left_edge == self.pf["DomainLeftEdge"]):
- self.left_edge += self.dx
+ self.left_edge += self.dds
self.ActiveDimensions -= 1
if na.any(self.right_edge == self.pf["DomainRightEdge"]):
- self.right_edge -= self.dx
+ self.right_edge -= self.dds
self.ActiveDimensions -= 1
def _get_list_of_grids(self):
- if na.any(self.left_edge - self.dx < self.pf["DomainLeftEdge"]) or \
- na.any(self.right_edge + self.dx > self.pf["DomainRightEdge"]):
+ if na.any(self.left_edge - self.dds < self.pf["DomainLeftEdge"]) or \
+ na.any(self.right_edge + self.dds > self.pf["DomainRightEdge"]):
grids,ind = self.pf.hierarchy.get_periodic_box_grids(
- self.left_edge - self.dx, self.right_edge + self.dx)
+ self.left_edge - self.dds,
+ self.right_edge + self.dds)
ind = slice(None)
else:
grids,ind = self.pf.hierarchy.get_box_grids(
- self.left_edge - self.dx, self.right_edge + self.dx)
+ self.left_edge - self.dds,
+ self.right_edge + self.dds)
level_ind = na.where(self.pf.hierarchy.gridLevels.ravel()[ind] <= self.level)
sort_ind = na.argsort(self.pf.h.gridLevels.ravel()[ind][level_ind])
self._grids = self.pf.hierarchy.grids[ind][level_ind][(sort_ind,)]
@@ -1937,7 +1946,7 @@
# How do we find out the root grid base dx?
idims = na.array([3,3,3])
dx = na.minimum((self.right_edge-self.left_edge)/(idims-2),
- self.pf.h.grids[0].dx)
+ self.pf.h.grids[0]['dx'])
idims = na.floor((self.right_edge-self.left_edge)/dx) + 2
for ax in 'xyz': self['cd%s'%ax] = dx[0]
self[field] = na.zeros(idims,dtype='float64')-999
@@ -1953,7 +1962,7 @@
@restore_grid_state
def _get_data_from_grid(self, grid, fields):
fields = ensure_list(fields)
- g_dx = na.array([grid.dx, grid.dy, grid.dz])
+ g_dx = grid.dds
c_dx = na.array([self['cdx'],self['cdy'],self['cdz']])
g_fields = [grid[field] for field in fields]
c_fields = [self[field] for field in fields]
Modified: branches/grid-optimization/yt/lagos/BaseGridType.py
==============================================================================
--- /trunk/yt/lagos/BaseGridType.py (original)
+++ branches/grid-optimization/yt/lagos/BaseGridType.py Thu Jan 15 08:39:36 2009
@@ -34,7 +34,7 @@
_id_offset = 1
_type_name = 'grid'
- _con_args = ['id', 'filename']
+ _con_args = ('id', 'filename')
def __init__(self, id, filename=None, hierarchy = None):
self.data = {}
@@ -45,9 +45,6 @@
if (id % 1e4) == 0: mylog.debug("Prepared grid %s", id)
if hierarchy: self.hierarchy = weakref.proxy(hierarchy)
if filename: self.set_filename(filename)
- self.overlap_masks = [None, None, None]
- self._overlap_grids = [None, None, None]
- self._file_access_pooling = False
self.pf = self.hierarchy.parameter_file # weakref already
def _generate_field(self, field):
@@ -73,6 +70,8 @@
Returns a field or set of fields for a key or set of keys
"""
if not self.data.has_key(field):
+ if field in ('dx','dy','dz','dds'):
+ return self._dds[field]
if field in self.hierarchy.field_list:
conv_factor = 1.0
if self.pf.field_info.has_key(field):
@@ -100,13 +99,10 @@
# So first we figure out what the index is. We don't assume
# that dx=dy=dz , at least here. We probably do elsewhere.
id = self.id - self._id_offset
- self.dx = self.hierarchy.gridDxs[id,0]
- self.dy = self.hierarchy.gridDys[id,0]
- self.dz = self.hierarchy.gridDzs[id,0]
- self.data['dx'] = self.dx
- self.data['dy'] = self.dy
- self.data['dz'] = self.dz
- self.data['dds'] = na.array([self.dx, self.dy, self.dz])
+ self.dds = na.array([self.hierarchy.gridDxs[id,0],
+ self.hierarchy.gridDys[id,0],
+ self.hierarchy.gridDzs[id,0]])
+ self.data['dx'], self.data['dy'], self.data['dz'] = self.dds
self._corners = self.hierarchy.gridCorners[:,:,id]
def _generate_overlap_masks(self, axis, LE, RE):
@@ -170,15 +166,14 @@
# Note that to keep in line with Enzo, we have broken PEP-8
h = self.hierarchy # cache it
my_ind = self.id - self._id_offset
- self.Dimensions = h.gridDimensions[my_ind]
- self.StartIndices = h.gridStartIndices[my_ind]
- self.EndIndices = h.gridEndIndices[my_ind]
+ self.ActiveDimensions = h.gridEndIndices[my_ind] \
+ - h.gridStartIndices[my_ind] + 1
self.LeftEdge = h.gridLeftEdge[my_ind]
self.RightEdge = h.gridRightEdge[my_ind]
self.Level = h.gridLevels[my_ind,0]
- self.Time = h.gridTimes[my_ind,0]
+ # This might be needed for streaming formats
+ #self.Time = h.gridTimes[my_ind,0]
self.NumberOfParticles = h.gridNumberOfParticles[my_ind,0]
- self.ActiveDimensions = (self.EndIndices - self.StartIndices + 1)
self.Children = h.gridTree[my_ind]
pID = h.gridReverseTree[my_ind]
if pID != None and pID != -1:
@@ -211,7 +206,7 @@
"""
Returns center position of an *index*
"""
- pos = (index + 0.5) * self.dx + self.LeftEdge
+ pos = (index + 0.5) * self.dds + self.LeftEdge
return pos
def clear_all(self):
@@ -283,10 +278,11 @@
#@time_execution
def __fill_child_mask(self, child, mask, tofill):
- startIndex = na.maximum(0, na.rint((child.LeftEdge - self.LeftEdge)/self.dx))
- endIndex = na.minimum(na.rint((child.RightEdge - self.LeftEdge)/self.dx),
+ startIndex = na.maximum(0, na.rint(
+ (child.LeftEdge - self.LeftEdge)/self.dds))
+ endIndex = na.minimum(na.rint(
+ (child.RightEdge - self.LeftEdge)/self.dds),
self.ActiveDimensions)
- #startIndex + self.ActiveDimensions)
startIndex = na.maximum(0, startIndex)
mask[startIndex[0]:endIndex[0],
startIndex[1]:endIndex[1],
@@ -331,7 +327,7 @@
#print "Generating coords"
ind = na.indices(self.ActiveDimensions)
LE = na.reshape(self.LeftEdge,(3,1,1,1))
- self['x'], self['y'], self['z'] = (ind+0.5)*self.dx+LE
+ self['x'], self['y'], self['z'] = (ind+0.5)*self.dds+LE
__child_mask = None
__child_indices = None
@@ -345,8 +341,8 @@
smoothed=False):
# We will attempt this by creating a datacube that is exactly bigger
# than the grid by nZones*dx in each direction
- new_left_edge = self.LeftEdge - n_zones * self.dx
- new_right_edge = self.RightEdge + n_zones * self.dx
+ new_left_edge = self.LeftEdge - n_zones * self.dds
+ new_right_edge = self.RightEdge + n_zones * self.dds
# Something different needs to be done for the root grid, though
level = self.Level
if all_levels:
@@ -393,7 +389,6 @@
"""
#All of the field parameters will be passed to us as needed.
AMRGridPatch.__init__(self, id, filename, hierarchy)
- self._file_access_pooling = False
def _guess_properties_from_parent(self):
"""
@@ -406,17 +401,16 @@
rf = self.pf["RefineBy"]
my_ind = self.id - self._id_offset
le = self.LeftEdge
- self.dx = self.Parent.dx/rf
- self.dy = self.Parent.dy/rf
- self.dz = self.Parent.dz/rf
- ParentLeftIndex = na.rint((self.LeftEdge-self.Parent.LeftEdge)/self.Parent.dx)
+ self['dx'] = self.Parent['dx']/rf
+ self['dy'] = self.Parent['dy']/rf
+ self['dz'] = self.Parent['dz']/rf
+ ParentLeftIndex = na.rint((self.LeftEdge-self.Parent.LeftEdge)/self.Parent.dds)
self.start_index = rf*(ParentLeftIndex + self.Parent.get_global_startindex()).astype('int64')
- self.LeftEdge = self.Parent.LeftEdge + self.Parent.dx * ParentLeftIndex
- self.RightEdge = self.LeftEdge + \
- self.ActiveDimensions*na.array([self.dx,self.dy,self.dz])
- self.hierarchy.gridDxs[my_ind,0] = self.dx
- self.hierarchy.gridDys[my_ind,0] = self.dy
- self.hierarchy.gridDzs[my_ind,0] = self.dz
+ self.LeftEdge = self.Parent.LeftEdge + self.Parent.dds * ParentLeftIndex
+ self.RightEdge = self.LeftEdge + self.ActiveDimensions*self.dds
+ self.hierarchy.gridDxs[my_ind,0] = self['dx']
+ self.hierarchy.gridDys[my_ind,0] = self['dy']
+ self.hierarchy.gridDzs[my_ind,0] = self['dz']
self.hierarchy.gridLeftEdge[my_ind,:] = self.LeftEdge
self.hierarchy.gridRightEdge[my_ind,:] = self.RightEdge
self.hierarchy.gridCorners[:,:,my_ind] = na.array([ # Unroll!
@@ -442,9 +436,9 @@
if self.start_index != None:
return self.start_index
if self.Parent == None:
- start_index = self.LeftEdge / na.array([self.dx, self.dy, self.dz])
+ start_index = self.LeftEdge / self.dds
return na.rint(start_index).astype('int64').ravel()
- pdx = na.array([self.Parent.dx, self.Parent.dy, self.Parent.dz]).ravel()
+ pdx = self.Parent.dds
start_index = (self.Parent.get_global_startindex()) + \
na.rint((self.LeftEdge - self.Parent.LeftEdge)/pdx)
self.start_index = (start_index*self.pf["RefineBy"]).astype('int64').ravel()
@@ -467,7 +461,6 @@
_id_offset = 0
def __init__(self, LeftEdge, RightEdge, index, level, filename, offset, dimensions,start,stop,paranoia=False):
AMRGridPatch.__init__(self, index)
- self._file_access_pooling = False
self.filename = filename
self._offset = offset
self._paranoid = paranoia
@@ -482,7 +475,7 @@
self.Level = level
def get_global_startindex(self):
- return self.start + na.rint(self.pf["DomainLeftEdge"]/self.dx)
+ return self.start + na.rint(self.pf["DomainLeftEdge"]/self.dds)
def _prepare_grid(self):
"""
Modified: branches/grid-optimization/yt/lagos/EnzoFields.py
==============================================================================
--- /trunk/yt/lagos/EnzoFields.py (original)
+++ branches/grid-optimization/yt/lagos/EnzoFields.py Thu Jan 15 08:39:36 2009
@@ -163,7 +163,7 @@
data["particle_position_y"],
data["particle_position_z"], 3,
data["particle_mass"],
- blank, data.LeftEdge, data.dx)
+ blank, data.LeftEdge, data['dx'])
return blank
add_field("particle_density", function=_pdensity,
validators=[ValidateSpatial(0)], convert_function=_convertDensity)
Modified: branches/grid-optimization/yt/lagos/FieldInfoContainer.py
==============================================================================
--- /trunk/yt/lagos/FieldInfoContainer.py (original)
+++ branches/grid-optimization/yt/lagos/FieldInfoContainer.py Thu Jan 15 08:39:36 2009
@@ -116,7 +116,7 @@
self.ActiveDimensions = [nd,nd,nd]
self.LeftEdge = [0.0,0.0,0.0]
self.RightEdge = [1.0,1.0,1.0]
- self.dx = self.dy = self.dz = na.array([1.0])
+ self['dx'] = self['dy'] = self['dz'] = na.array([1.0])
self.fields = []
if pf is None:
pf = defaultdict(lambda: 1)
More information about the yt-svn
mailing list