def calculate_eigenvectors_eigenvalues(self):
if not (self.active_tensor
in self.processed_tensors_for_eigenvectors_eigenvalues):
self.processed_tensors_for_eigenvectors_eigenvalues.append(
self.active_tensor)
input_grid = self.inputs[0].outputs[0]
tensor_field = array(
input_grid.point_data.get_array(self.active_tensor))
result = map(
lambda x: linalg.eig(
reshape(x, (self.dimensions, self.dimensions))),
tensor_field)
sorted_indices = map(lambda x: argsort(x[0]), result)
for i in range(self.dimensions):
eigenvalues = map(lambda x, y: x[0][y[i]], result,
sorted_indices)
eigenvectors = map(lambda x, y: x[1][y[i]], result,
sorted_indices)
eigenvalues_field = tvtk.FloatArray(name=self.active_tensor +
'_eigenvalues_' + ` i `)
eigenvalues_field.from_array(eigenvalues)
self.grid.point_data.add_array(eigenvalues_field)
eigenvectors_field = tvtk.FloatArray(name=self.active_tensor +
'_eigenvectors_' + ` i `)
eigenvectors_field.from_array(eigenvectors)
self.grid.point_data.add_array(eigenvectors_field)
def grad_curl(self, array, curl):
# Can't remove arrays by index - that's why I've given it a name
temp_name = 'a_temp_name_hopefully_nobody_will_ever_use'
temp_array = tvtk.FloatArray(name=temp_name)
temp_array.from_array(array)
self.grid.point_data.add_array(temp_array)
if (curl):
self.grid.point_data.set_active_vectors(temp_name)
else:
self.grid.point_data.set_active_scalars(temp_name)
cd = tvtk.CellDerivatives()
cd.input = self.grid
if (curl):
cd.vector_mode = 'compute_vorticity'
cd.update()
cp = tvtk.CellDataToPointData()
cp.input = cd.output
cp.update()
self.grid.point_data.remove_array(
'a_temp_name_hopefully_nobody_will_ever_use')
return cp.output.point_data.get_array('Vorticity')
def calculate_propotionaleigenvectors(self):
if not (self.active_tensor
in self.processed_tensors_for_proportionaleigenvectors):
self.processed_tensors_for_proportionaleigenvectors.append(
self.active_tensor)
self.calculate_edgelengths()
input_grid = self.inputs[0].outputs[0]
for i in range(self.dimensions):
eigenvectors = array(
self.grid.point_data.get_array(self.active_tensor +
'_eigenvectors_' + ` i `))
edgelengths = array(
self.grid.point_data.get_array(self.active_tensor +
'_edgelengths_' + ` i `))
proportionaleigenvectors = map(multiply, eigenvectors,
edgelengths)
proportionaleigenvectors_field = tvtk.FloatArray(
name=self.active_tensor + '_proportionaleigenvectors_' +
` i `)
proportionaleigenvectors_field.from_array(
proportionaleigenvectors)
self.grid.point_data.add_array(proportionaleigenvectors_field)
def AddScalarField(self, name, array):
"""Adds a scalar field with the specified name using the values from the array."""
# In vtktools.py the following used SetNumberOfValues=len(array)
data = tvtk.FloatArray(number_of_tuples=len(array), name=name)
for i in range(len(array)):
data.set_value(i, array[i])
pointdata = self.ugrid.point_data
pointdata.add_array(data)
pointdata.set_active_scalars(name)
def read(self, filename):
reader = VTKDataReader()
data = reader.read(filename)
cells = data['cells']
vertices = data['vertices']
(ncells, ncorners) = cells.shape
(nvertices, spaceDim) = vertices.shape
vtkData = tvtk.UnstructuredGrid()
vtkData.points = vertices
assert(spaceDim == 3)
assert(ncorners == 3)
cellType = tvtk.Triangle().cell_type
vtkData.set_cells(cellType, cells)
# Displacement vector
displacement = data['vertex_fields']['displacement']
array = tvtk.FloatArray()
array.from_array(displacement.squeeze())
array.name = "Displacement (m)"
vtkData.point_data.vectors = array
vtkData.point_data.vectors.name = "Displacement (m)"
# Compute velocity magnitude
velocity = data['vertex_fields']['velocity']
velocityLog = ((velocity[:,0]**2 +
velocity[:,1]**2 +
velocity[:,2]**2)**0.5)
array = tvtk.FloatArray()
array.from_array(velocityLog.squeeze())
array.name = "Velocity (m/s)"
vtkData.point_data.scalars = array
vtkData.point_data.scalars.name = "Velocity (m/s)"
return vtkData
def AddVectorField(self, name, array):
"""Adds a vector field with the specified name using the values from the array."""
n = array.size
# In vtktools.py the following used SetNumberOfValues=n
data = tvtk.FloatArray(number_of_components=array.shape[1],
number_of_tuples=n,
name=name)
for i in range(n):
data.set_value(i, array.reshape(n)[i])
pointdata = self.ugrid.point_data
pointdata.add_array(data)
pointdata.set_active_vectors(name)
def calculate_edgelengths(self):
if not (self.active_tensor in self.processed_tensors_for_edgelengths):
self.processed_tensors_for_edgelengths.append(self.active_tensor)
input_grid = self.inputs[0].outputs[0]
for i in range(self.dimensions):
eigenvalues = array(
self.grid.point_data.get_array(self.active_tensor +
'_eigenvalues_' + ` i `))
edgelengths = map(lambda x: 1 / sqrt(x), eigenvalues)
edgelengths_field = tvtk.FloatArray(name=self.active_tensor +
'_edgelengths_' + ` i `)
edgelengths_field.from_array(edgelengths)
self.grid.point_data.add_array(edgelengths_field)
def _add_attribute_array(self, attribute_array, i, type):
"""
Adds the given attribute array to either point_data or
cell_data of the unstructured grid.
"""
attribute_array_name = 'Attribute %i' % i
if (type == 'cell'): # .ele file attributes are of type Int
tvtk_attribute_array = tvtk.IntArray(name=attribute_array_name)
attribute_array = map(int, attribute_array)
else: # .node file attributes are of type Float
tvtk_attribute_array = tvtk.FloatArray(name=attribute_array_name)
tvtk_attribute_array.from_array(attribute_array)
getattr(self._grid, '%s_data' % type).add_array(tvtk_attribute_array)
getattr(self, '_%s_scalars_list' % type).append(attribute_array_name)
if (i == 0):
self._set_data_name(type, 'Attribute 0')
def test_array_conversion(self):
"""Test if Numeric/VTK array conversion works."""
# This is only a simple test.
data = numpy.array(
[[0, 0, 0, 10], [1, 0, 0, 20], [0, 1, 0, 20], [0, 0, 1, 30]], 'f')
triangles = numpy.array([[0, 1, 3], [0, 3, 2], [1, 2, 3], [0, 2, 1]])
points = data[:, :3]
temperature = data[:, -1]
mesh = tvtk.PolyData()
mesh.points = points
mesh.polys = triangles
mesh.point_data.scalars = temperature
# Test if a normal float array also works.
temp = tvtk.FloatArray()
temp.from_array(temperature)
mesh.point_data.scalars = temp
def make_data():
points = N.array(
[
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[0, 0, 1], # tets
[1, 0, 0],
[2, 0, 0],
[1, 1, 0],
[1, 0, 1],
[2, 0, 0],
[3, 0, 0],
[2, 1, 0],
[2, 0, 1],
],
'f')
tets = N.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
tet_type = tvtk.Tetra().cell_type
ug = tvtk.UnstructuredGrid(points=points)
ug.set_cells(tet_type, tets)
# Setup the point attributes.
temp = N.random.random(12)
v = N.random.randn(12, 3)
ten = N.random.randn(12, 9)
a = tvtk.FloatArray(name='p')
a.from_array(N.random.randn(12))
ug.point_data.add_array(a)
ug.point_data.scalars = temp
ug.point_data.scalars.name = 't'
ug.point_data.vectors = v
ug.point_data.vectors.name = 'v'
ug.point_data.tensors = ten
ug.point_data.tensors.name = 'ten'
# Setup the cell attributes.
temp = N.random.random(3)
v = N.random.randn(3, 3)
ten = N.random.randn(3, 9)
ug.cell_data.scalars = temp
ug.cell_data.scalars.name = 't'
ug.cell_data.vectors = v
ug.cell_data.vectors.name = 'v'
ug.cell_data.tensors = ten
ug.cell_data.tensors.name = 'ten'
return ug
def test_data_array(self):
"""Test if vtkDataArrays behave in a Pythonic fashion."""
# Check a 3D array.
f = tvtk.FloatArray()
a = numpy.array([[0., 0, 0], [1, 1, 1]])
f.from_array(a)
self.assertEqual(f.number_of_components, 3)
self.assertEqual(f.number_of_tuples, 2)
self.assertEqual(mysum(f.to_array() - a), 0)
for i, j in zip(a, f):
self.assertEqual(mysum(i - j), 0.0)
self.assertEqual(f[0], (0.0, 0.0, 0.0))
self.assertEqual(f[-1], (1., 1., 1.))
self.assertEqual(repr(f), '[(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)]')
f.append((2, 2, 2))
f.extend([[3, 3, 3], [4, 4, 4]])
self.assertEqual(len(f), 5)
self.assertEqual(f.number_of_components, 3)
self.assertEqual(f.number_of_tuples, 5)
f[1] = [-1, -1, -1]
self.assertEqual(f[1], (-1.0, -1.0, -1.0))
self.assertRaises(IndexError, f.__getitem__, 100)
self.assertRaises(IndexError, f.__setitem__, 100, 100)
# Check a 5D arrray
a = numpy.array([[0., 0, 0, 0, 0], [1, 1, 1, 1, 1]])
f.from_array(a)
self.assertEqual(mysum(f.to_array() - a), 0.0)
for i, j in zip(a, f):
self.assertEqual(mysum(i - j), 0.0)
self.assertEqual(f[0], (0.0, 0.0, 0.0, 0.0, 0.0))
self.assertEqual(f[-1], (1., 1., 1., 1., 1.))
self.assertEqual(
repr(f), '[(0.0, 0.0, 0.0, 0.0, 0.0), (1.0, 1.0, 1.0, 1.0, 1.0)]')
f.append((2, 2, 2, 2, 2))
f.extend([[3, 3, 3, 3, 3], [4, 4, 4, 4, 4]])
self.assertEqual(len(f), 5)
self.assertEqual(f.number_of_components, 5)
self.assertEqual(f.number_of_tuples, 5)
self.assertEqual(f[-1], (4., 4., 4., 4., 4.))
f[1] = [-1, -1, -1, -1, -1]
self.assertEqual(f[1], (-1.0, -1.0, -1.0, -1.0, -1.0))
self.assertRaises(IndexError, f.__getitem__, 100)
self.assertRaises(IndexError, f.__setitem__, 100, 100)
def draw_height_quantity(self, quantityName):
"""Use the vtkPolyData and prepare/update the rest of the VTK
rendering pipeline.
"""
if quantityName in self.vtk_mappers:
mapper = self.vtk_mappers[quantityName]
else:
mapper = self.vtk_mappers[quantityName] = vtkPolyDataMapper()
mapper.SetInput(self.vtk_polyData[quantityName])
mapper.Update()
if quantityName not in self.vtk_actors:
actor = self.vtk_actors[quantityName] = vtkActor()
actor.SetMapper(mapper)
self.vtk_renderer.AddActor(actor)
else:
actor = self.vtk_actors[quantityName]
if quantityName in self.colours_height:
colour = self.colours_height[quantityName]
if type(colour) == TupleType:
if type(colour[0]) == FunctionType:
# It's a function, so take colour[1] as the
# lower bound on the scalar range and
# colour[2] as the upper bound on the scalar
# range.
scalars = tvtk.FloatArray()
list(
map(scalars.InsertNextValue,
colour[0](self.build_quantity_dict())))
self.vtk_polyData[quantityName].GetPointData().SetScalars(
scalars)
mapper.SetScalarRange(colour[1:])
mapper.Update()
else:
# It's a 3-tuple representing an RGB value.
actor.GetProperty().SetColor(colour)
else:
actor.GetProperty().SetColor(0.5, 0.5, 0.5)
else:
actor.GetProperty().SetColor(0.5, 0.5, 0.5)
class CitcomSHDFUgrid:
"""This Class converts CitcomS hdf files to tvtk UnstructuredGrid Dataset Objects """
data = None
_nx = None
_ny = None
_nz = None
_nx_redu = None
_ny_redu = None
_nz_redu = None
_radius_inner = None
_radius_outer = None
timesteps = None
frequency = None
progress = 0
#Global because a Unstructured Grid can only hold one scalar value at a time
#but our hdf file reader plugin wants to be able to read both
__vtkordered_visc = tvtk.FloatArray()
__vtkordered_temp = tvtk.FloatArray()
def vtk_iter(self,nx,ny,nz):
"""Iterator for CitcomDataRepresentation(yxz) to VTK(xyz)"""
for i in xrange(nx):
for j in xrange(ny):
for k in xrange(nz):
yield k + nz * i + nz * nx * j
def reduce_iter(self,n,nredu):
"""Iterator to reduce the CitcomS grid"""
i=0
n_f=float(n)
nredu_f=float(nredu)
fl=(n_f-1)/nredu_f
redu = 0
for i in xrange(nredu+1):
yield int(round(redu))
redu = redu + fl
def velocity2cart(self,vel_colat,vel_long,r, x, y, z):
"""Converts vectors in spherical to cartesian coordiantes"""
x1 = r*sin(x)*cos(y)+vel_colat*cos(x)*cos(y)-vel_long*sin(y)
y1 = r*sin(x)*sin(y)+vel_colat*cos(x)*sin(y)+vel_long*cos(y)
z1 = r*cos(x)-vel_colat*sin(x)
return x1, y1, z1
#Converts Spherical to Cartesian Coordinates
def RTF2XYZ(self,thet, phi, r):
"""Converts points from spherical to cartesian coordinates"""
x = r * sin(thet) * cos(phi)
y = r * sin(thet) * sin(phi)
z = r * cos(thet)
return x, y, z
def __citcom2vtk(self,t,f,nproc_surf,nx_redu,ny_redu,nz_redu):
"""Method to convert one timestep from a hdf file to a Vtk file. This Method is used
by the method initialize. Initialize reads the necessary meta information from the hdf file"""
hexagrid = tvtk.UnstructuredGrid()
hexagrid.allocate(1,1)
vtkordered_velo = tvtk.FloatArray()
nx = self._nx
ny = self._ny
nz = self._nz
counter = 0
el_nx_redu = nx_redu + 1
el_ny_redu = ny_redu + 1
el_nz_redu = nz_redu + 1
ordered_points = [] #reset Sequences for points
ordered_temperature = []
ordered_velocity = []
ordered_viscosity = []
for capnr in xrange(nproc_surf):
cap = f.root._f_getChild("cap%02d" % capnr)
temp_coords = [] # reset Coordinates, Velocity, Temperature Sequence
temp_vel = []
temp_temp = []
temp_visc = []
#Information from hdf
hdf_coords = cap.coord[:]
hdf_velocity = cap.velocity[t]
hdf_temperature = cap.temperature[t]
hdf_viscosity = cap.viscosity[t]
#Create Iterator to change data representation
nx_redu_iter = self.reduce_iter(nx,nx_redu)
ny_redu_iter = self.reduce_iter(ny,ny_redu)
nz_redu_iter = self.reduce_iter(nz,nz_redu)
#vtk_i = self.vtk_iter(el_nx_redu,el_ny_redu,el_nz_redu)
# read citcom data - zxy (z fastest)
for j in xrange(el_ny_redu):
j_redu = ny_redu_iter.next()
nx_redu_iter = self.reduce_iter(nx,nx_redu)
for i in xrange(el_nx_redu):
i_redu = nx_redu_iter.next()
nz_redu_iter = self.reduce_iter(nz,nz_redu)
for k in xrange(el_nz_redu):
k_redu = nz_redu_iter.next()
colat, lon, r = map(float,hdf_coords[i_redu,j_redu,k_redu])
x_coord, y_coord, z_coord = self.RTF2XYZ(colat,lon,r)
ordered_points.append((x_coord,y_coord,z_coord))
ordered_temperature.append(float(hdf_temperature[i_redu,j_redu,k_redu]))
ordered_viscosity.append(float(hdf_viscosity[i_redu,j_redu,k_redu]))
vel_colat, vel_lon , vel_r = map(float,hdf_velocity[i_redu,j_redu,k_redu])
x_velo, y_velo, z_velo = self.velocity2cart(vel_colat,vel_lon,vel_r, colat,lon , r)
ordered_velocity.append((x_velo,y_velo,z_velo))
##Delete Objects for GC
del hdf_coords
del hdf_velocity
del hdf_temperature
del hdf_viscosity
#Create Connectivity info
if counter==0:
i=1 #Counts X Direction
j=1 #Counts Y Direction
k=1 #Counts Z Direction
for n in xrange((el_nx_redu*el_ny_redu*el_nz_redu)-(el_nz_redu*el_nx_redu)):
if (i%el_nz_redu)==0: #X-Values!!!
j+=1 #Count Y-Values
if (j%el_nx_redu)==0:
k+=1 #Count Z-Values
if i%el_nz_redu!=0 and j%el_nx_redu!=0: #Check if Box can be created
#Get Vertnumbers
n0 = n+(capnr*(el_nx_redu*el_ny_redu*el_nz_redu))
n1 = n0+el_nz_redu
n2 = n1+el_nz_redu*el_nx_redu
n3 = n0+el_nz_redu*el_nx_redu
n4 = n0+1
n5 = n4+el_nz_redu
n6 = n5+el_nz_redu*el_nx_redu
n7 = n4+el_nz_redu*el_nx_redu
#Created Polygon Box
hexagrid.insert_next_cell(12,[n0,n1,n2,n3,n4,n5,n6,n7])
i+=1
#Store Arrays in Vtk conform Datastructures
self.__vtkordered_temp.from_array(ordered_temperature)
self.__vtkordered_visc.from_array(ordered_viscosity)
vtkordered_velo.from_array(ordered_velocity)
self.__vtkordered_temp.name = 'Temperature'
self.__vtkordered_visc.name = 'Viscosity'
hexagrid.point_data.scalars = self.__vtkordered_temp
vtkordered_velo.name = 'Velocity'
hexagrid.point_data.vectors = vtkordered_velo
hexagrid.points = ordered_points
self.progress += 1
return hexagrid
def initialize(self,filename,timestep,nx_redu,ny_redu,nz_redu):
"""Call this method to convert a Citcoms Hdf file to a Vtk file"""
#Read meta-inforamtion
hdf=tables.openFile(filename,'r')
self._nx = int(hdf.root.input._v_attrs.nodex)
self._ny = int(hdf.root.input._v_attrs.nodey)
self._nz = int(hdf.root.input._v_attrs.nodez)
#Clip against boundaries
if nx_redu>=0 or nx_redu>=self._nx:
nx_redu = self._nx-1
if ny_redu==0 or ny_redu>=self._ny:
ny_redu = self._ny-1
if nz_redu==0 or nz_redu>=self._nz:
nz_redu = self._nz-1
#Make reduction factors global
self._nx_redu = nx_redu
self._ny_redu = ny_redu
self._nz_redu = nz_redu
#Number of Timesteps in scene
self.timesteps = int(hdf.root.time.nrows)
#Number of caps
nproc_surf = int(hdf.root.input._v_attrs.nproc_surf)
#Store the Inner Radius. Import if we want to create a core
self._radius_inner = self._radius_inner = float(hdf.root.input._v_attrs.radius_inner)
#start computation
hexgrid = self.__citcom2vtk(timestep,hdf,nproc_surf,nx_redu,ny_redu,nz_redu)
hdf.close()
self.progress = -1
return hexgrid
def get_vtk_viscosity(self):
return self.__vtkordered_visc
def get_vtk_temperature(self):
return self.__vtkordered_temp
def field_operation(self, operation, input_arrays, output_array):
scalar_op = False # Operation on scalars only?
vector_op = False # Operation on vectors only?
custom_fn = False # Custom Python function defined?
multiple_inputs = True # Operation with multiple inputs?
if (operation == 'Sum'):
self.check_min_input_size(input_arrays, 2)
function = lambda x: add.reduce(x)
elif (operation == 'Multiply'):
self.check_min_input_size(input_arrays, 2)
function = lambda x: multiply.reduce(x)
elif (operation == 'Dot product'):
vector_op = True
self.check_exact_input_size(input_arrays, 2)
function = lambda x: map(dot, x[0], x[1])
elif (operation == 'Cross product'):
vector_op = True
self.check_exact_input_size(input_arrays, 2)
function = lambda x: cross(x[0], x[1])
elif (operation == 'Python function'):
custom_fn = True
try:
function = lambda inputs: eval(self.custom_function)
except:
raise Exception, 'There is an error in your custom Python function.'
else:
multiple_inputs = False
if (operation == 'Reciprocal'):
function = lambda x: 1 / x
elif (operation == 'Exponential'):
function = lambda x: exp(x)
elif (operation == 'Natural log'):
function = lambda x: log(x)
elif (operation == 'Step'):
function = lambda x: map(lambda x: (x > 0) + 0, x)
elif (operation == 'Scale/Offset'):
function = lambda x: x
elif (operation == 'd/dx'):
scalar_op = True
function = lambda x: self.derivative(x, 0)
elif (operation == 'd/dy'):
scalar_op = True
function = lambda x: self.derivative(x, 1)
elif (operation == 'd/dz'):
scalar_op = True
function = lambda x: self.derivative(x, 2)
elif (operation == 'Curl'):
vector_op = True
function = lambda x: self.grad_curl(x, True)
elif (operation == 'Grad'):
scalar_op = True
function = lambda x: self.grad_curl(x, False)
elif (operation == 'Div'):
vector_op = True
function = self.divergence
elif (operation == 'Normalize'):
vector_op = True
function = lambda x: map(multiply, x, 1 / array(
map(linalg.norm, x)))
elif (operation == '2-norm'):
vector_op = True
function = lambda x: map(linalg.norm, x)
elif (operation == 'x-component'):
vector_op = True
function = lambda x: self.get_axis(x, 0)
elif (operation == 'y-component'):
vector_op = True
function = lambda x: self.get_axis(x, 1)
elif (operation == 'z-component'):
vector_op = True
function = lambda x: self.get_axis(x, 2)
else:
raise Exception, 'Undefined operation.'
self.check_exact_input_size(input_arrays, 1)
# Retrieve array data
input_data = self.retrieve_arrays(input_arrays, scalar_op, vector_op)
if (multiple_inputs):
if (custom_fn):
try:
result = function(input_data)
except:
raise Exception, 'There is an error in your custom Python function.'
else:
result = function(input_data)
else:
result = function(input_data[0])
output_array_name = output_array[0]
scale_factor = output_array[1]
offset = output_array[2]
# Scale and offset result array if necessary
if (scale_factor != 1.0 or offset != 0.0):
result = array(result) * scale_factor + offset
# Store result (replaces array with name output_array_name if it exists)
output_array = tvtk.FloatArray(name=output_array_name)
output_array.from_array(result)
self.grid.point_data.add_array(output_array)
self.pipeline_changed = True
class CitcomSHDFFileReader(Source):
"""This source manages a CitcomS Hdf file given to it. """
# The version of this class. Used for persistence.
__version__ = 0
# The VTK dataset to manage.
data = Instance(tvtk.DataSet)
# Class to convert Hdf to Vtk Unstructured Grid Objects
citcomshdftougrid = CitcomSHDFUgrid()
current_timestep = Int(0)
#To support changing the Scalar values in Mayavi2
temperature = Instance(tvtk.FloatArray())
viscosity = Instance(tvtk.FloatArray())
#Resolution comming from Hdf file
nx = Int()
ny = Int()
nz = Int()
#Current reduced resolution. User defined
nx_redu = Int()
ny_redu = Int()
nz_redu = Int()
#Number of timesteps in Hdf
timesteps = Int()
#Button to trigger the process of reading a timestep
read_timestep = Button('Read timestep')
filename = Str()
########################################
# Dynamic traits: These traits are dummies and are dynamically
# updated depending on the contents of the file.
# The active point scalar name.
point_scalars_name = Trait('', TraitPrefixList(['']))
# The active point vector name.
point_vectors_name = Trait('', TraitPrefixList(['']))
# The active point tensor name.
point_tensors_name = Trait('', TraitPrefixList(['']))
# The active cell scalar name.
cell_scalars_name = Trait('', TraitPrefixList(['']))
# The active cell vector name.
cell_vectors_name = Trait('', TraitPrefixList(['']))
# The active cell tensor name.
cell_tensors_name = Trait('', TraitPrefixList(['']))
########################################
# Our view.
view = View(
Group(
Item(name='current_timestep'),
Item(name='nx_redu'),
Item(name='ny_redu'),
Item(name='nz_redu'),
Item(name='read_timestep', style='simple', label='Simple'),
Item(name='point_scalars_name'),
Item(name='point_vectors_name'),
Item(name='point_tensors_name'),
Item(name='cell_scalars_name'),
Item(name='cell_vectors_name'),
Item(name='cell_tensors_name'),
), )
######################################################################
# `object` interface
######################################################################
#Invoked during process of saving the visualization to a file
def __get_pure_state__(self):
d = super(CitcomSHDFFileReader, self).__get_pure_state__()
output = "Filename: " + self.filename + "NX:%d NY:%d NZ:%d" % (
self.nx_redu, self.ny_redu, self.nz_redu)
z = gzip_string(output)
d['data'] = z
return d
#When the Visualisation is opened again this Method is called
def __set_pure_state__(self, state):
z = state.data
if z:
d = gunzip_string(z)
m = re.search('(?<=Filename:)\w+', header)
file_name = m.group(0)
m = re.search('(?<=NX:)\w+', d)
self.nx_redu = int(m.group(0))
m = re.search('(?<=NX:)\w+', d)
self.ny_redu = int(m.group(0))
m = re.search('(?<=NX:)\w+', d)
self.nz_redu = int(m.group(0))
if not isfile(file_name):
msg = 'Could not find file at %s\n' % file_name
msg += 'Please move the file there and try again.'
raise IOError, msg
self.filename = file_name
#self.data = self.citcomshdftougrid.initialize(self.filename,0,0,0,0,False,False)
f = tables.openFile(file_name, 'r')
self.nx = int(f.root.input._v_attrs.nodex)
self.ny = int(f.root.input._v_attrs.nodey)
self.nz = int(f.root.input._v_attrs.nodez)
self.timesteps = int(f.root.time.nrows)
f.close()
self.data = self.citcomshdftougrid.initialize(
self.filename, self.current_timestep, self.nx_redu,
self.ny_redu, self.nz_redu)
self.data_changed = True
self._update_data()
# Now set the remaining state without touching the children.
set_state(self, state, ignore=['children', '_file_path'])
# Setup the children.
handle_children_state(self.children, state.children)
# Setup the children's state.
set_state(self, state, first=['children'], ignore=['*'])
######################################################################
# `Base` interface
######################################################################
def start(self):
"""This is invoked when this object is added to the mayavi
pipeline.
"""
# Do nothing if we are already running.
if self.running:
return
# Update the data just in case.
self._update_data()
# Call the parent method to do its thing. This will typically
# start all our children.
super(CitcomSHDFFileReader, self).start()
def update(self):
"""Invoke this to flush data changes downstream."""
self.data_changed = True
def initialize(self, file_name):
"""This Methods initializes the reader and reads the meta-information from the Hdf file """
self.filename = file_name
#self.data = self.citcomshdftougrid.initialize(self.filename,0,0,0,0,False,False)
f = tables.openFile(file_name, 'r')
self.nx = int(f.root.input._v_attrs.nodex)
self.ny = int(f.root.input._v_attrs.nodey)
self.nz = int(f.root.input._v_attrs.nodez)
self.nx_redu = self.nx
self.ny_redu = self.ny
self.nz_redu = self.nz
self.timesteps = int(f.root.time.nrows)
f.close()
######################################################################
# `TreeNodeObject` interface
######################################################################
def tno_get_label(self, node):
""" Gets the label to display for a specified object.
"""
ret = "CitcomS HDF Data (uninitialized)"
if self.data:
typ = self.data.__class__.__name__
ret = "CitcomS HDF Data (%d)" % self.current_timestep
return ret
######################################################################
# Non-public interface
######################################################################
def _data_changed(self, data):
"""Invoked when the upsteam data sends an data_changed event"""
self._update_data()
self.outputs = [data]
self.data_changed = True
# Fire an event so that our label on the tree is updated.
self.trait_property_changed('name', '', self.tno_get_label(None))
##Callbacks for our traits
def _current_timestep_changed(self, new_value):
"""Callback for the current timestep input box"""
if new_value < 0:
self.current_timestep = 0
if new_value > self.timesteps:
self.current_timestep = self.timesteps - 1
def _read_timestep_fired(self):
"""Callback for the Button to read one timestep"""
self.data = self.citcomshdftougrid.initialize(self.filename,
self.current_timestep,
self.nx_redu,
self.ny_redu,
self.nz_redu)
self.temperature = self.citcomshdftougrid.get_vtk_temperature()
self.viscosity = self.citcomshdftougrid.get_vtk_viscosity()
##New Thread Code
#thread1 = CitcomSHdf2UGridThread()
#thread2 = CitcomSProgressBar()
#thread1.set_citcomsreader(self.filename,self.current_timestep,self.nx_redu,self.ny_redu,self.nz_redu,self.thread_callback)
#progress = thread1.get_ref()
#thread1.start()
#thread2.set_ref(progress)
#thread2.start()
self.data_changed = True
self._update_data()
def _nx_redu_changed(self, new_value):
"""callback for the nx_redu input box"""
if new_value < 1:
self.nx_redu = 1
if new_value > self.nx:
self.nx_redu = self.nx
def _ny_redu_changed(self, new_value):
"""callback for the ny_redu input box"""
if new_value < 1:
self.ny_redu = 1
if new_value > self.ny:
self.ny_redu = self.ny
def _nz_redu_changed(self, new_value):
"""callback for the nz_redu input box"""
if new_value < 1:
self.nz_redu = 1
if new_value > self.nz:
self.nz_redu = self.nz
def _point_scalars_name_changed(self, value):
if value == "Temperature":
self.data.point_data.scalars = self.temperature
if value == "Viscosity":
self.data.point_data.scalars = self.viscosity
self.data_changed = True
self._set_data_name('scalars', 'point', value)
def _point_vectors_name_changed(self, value):
self._set_data_name('vectors', 'point', value)
def _point_tensors_name_changed(self, value):
self._set_data_name('tensors', 'point', value)
########################Non Public##############################
def _set_data_name(self, data_type, attr_type, value):
if not value:
return
dataset = self.data
data = None
if attr_type == 'point':
data = dataset.point_data
elif attr_type == 'cell':
data = dataset.cell_data
meth = getattr(data, 'set_active_%s' % data_type)
meth(value)
self.update()
# Fire an event, so the changes propagate.
self.data_changed = True
def _update_data(self):
if not self.data:
return
else:
trait = Trait('Temperature',
TraitPrefixList('Temperature', 'Viscosity'))
self.add_trait('point_scalars_name', trait)
trait = Trait('Velocity', TraitPrefixList('Velocity'))
self.add_trait('point_vectors_name', trait)
def thread_callback(self, hexagrid, vtk_viscosity, vtk_temperature):
hexagrid.print_traits()
self.data = hexagrid
self.temperature = vtk_temperature
self.viscosity = vtk_temperature
def __citcom2vtk(self,t,f,nproc_surf,nx_redu,ny_redu,nz_redu):
"""Method to convert one timestep from a hdf file to a Vtk file. This Method is used
by the method initialize. Initialize reads the necessary meta information from the hdf file"""
hexagrid = tvtk.UnstructuredGrid()
hexagrid.allocate(1,1)
vtkordered_velo = tvtk.FloatArray()
nx = self._nx
ny = self._ny
nz = self._nz
counter = 0
el_nx_redu = nx_redu + 1
el_ny_redu = ny_redu + 1
el_nz_redu = nz_redu + 1
ordered_points = [] #reset Sequences for points
ordered_temperature = []
ordered_velocity = []
ordered_viscosity = []
for capnr in xrange(nproc_surf):
cap = f.root._f_getChild("cap%02d" % capnr)
temp_coords = [] # reset Coordinates, Velocity, Temperature Sequence
temp_vel = []
temp_temp = []
temp_visc = []
#Information from hdf
hdf_coords = cap.coord[:]
hdf_velocity = cap.velocity[t]
hdf_temperature = cap.temperature[t]
hdf_viscosity = cap.viscosity[t]
#Create Iterator to change data representation
nx_redu_iter = self.reduce_iter(nx,nx_redu)
ny_redu_iter = self.reduce_iter(ny,ny_redu)
nz_redu_iter = self.reduce_iter(nz,nz_redu)
#vtk_i = self.vtk_iter(el_nx_redu,el_ny_redu,el_nz_redu)
# read citcom data - zxy (z fastest)
for j in xrange(el_ny_redu):
j_redu = ny_redu_iter.next()
nx_redu_iter = self.reduce_iter(nx,nx_redu)
for i in xrange(el_nx_redu):
i_redu = nx_redu_iter.next()
nz_redu_iter = self.reduce_iter(nz,nz_redu)
for k in xrange(el_nz_redu):
k_redu = nz_redu_iter.next()
colat, lon, r = map(float,hdf_coords[i_redu,j_redu,k_redu])
x_coord, y_coord, z_coord = self.RTF2XYZ(colat,lon,r)
ordered_points.append((x_coord,y_coord,z_coord))
ordered_temperature.append(float(hdf_temperature[i_redu,j_redu,k_redu]))
ordered_viscosity.append(float(hdf_viscosity[i_redu,j_redu,k_redu]))
vel_colat, vel_lon , vel_r = map(float,hdf_velocity[i_redu,j_redu,k_redu])
x_velo, y_velo, z_velo = self.velocity2cart(vel_colat,vel_lon,vel_r, colat,lon , r)
ordered_velocity.append((x_velo,y_velo,z_velo))
##Delete Objects for GC
del hdf_coords
del hdf_velocity
del hdf_temperature
del hdf_viscosity
#Create Connectivity info
if counter==0:
i=1 #Counts X Direction
j=1 #Counts Y Direction
k=1 #Counts Z Direction
for n in xrange((el_nx_redu*el_ny_redu*el_nz_redu)-(el_nz_redu*el_nx_redu)):
if (i%el_nz_redu)==0: #X-Values!!!
j+=1 #Count Y-Values
if (j%el_nx_redu)==0:
k+=1 #Count Z-Values
if i%el_nz_redu!=0 and j%el_nx_redu!=0: #Check if Box can be created
#Get Vertnumbers
n0 = n+(capnr*(el_nx_redu*el_ny_redu*el_nz_redu))
n1 = n0+el_nz_redu
n2 = n1+el_nz_redu*el_nx_redu
n3 = n0+el_nz_redu*el_nx_redu
n4 = n0+1
n5 = n4+el_nz_redu
n6 = n5+el_nz_redu*el_nx_redu
n7 = n4+el_nz_redu*el_nx_redu
#Created Polygon Box
hexagrid.insert_next_cell(12,[n0,n1,n2,n3,n4,n5,n6,n7])
i+=1
#Store Arrays in Vtk conform Datastructures
self.__vtkordered_temp.from_array(ordered_temperature)
self.__vtkordered_visc.from_array(ordered_viscosity)
vtkordered_velo.from_array(ordered_velocity)
self.__vtkordered_temp.name = 'Temperature'
self.__vtkordered_visc.name = 'Viscosity'
hexagrid.point_data.scalars = self.__vtkordered_temp
vtkordered_velo.name = 'Velocity'
hexagrid.point_data.vectors = vtkordered_velo
hexagrid.points = ordered_points
self.progress += 1
return hexagrid
def screenshot(figure=None, mode='rgb', antialiased=False):
""" Return the current figure pixmap as an array.
**Parameters**
:figure: a figure instance or None, optional
If specified, the figure instance to capture the view of.
:mode: {'rgb', 'rgba'}
The color mode of the array captured.
:antialiased: {True, False}
Use anti-aliasing for rendering the screenshot.
Uses the number of aa frames set by
figure.scene.anti_aliasing_frames
**Notes**
On most systems, this works similarly to taking a screenshot of
the rendering window. Thus if it is hidden by another window, you
will capture the other window. This limitation is due to the
heavy use of the hardware graphics system.
**Examples**
This function can be useful for integrating 3D plotting with
Mayavi in a 2D plot created by matplotlib.
>>> from enthought.mayavi import mlab
>>> mlab.test_plot3d()
>>> arr = mlab.screenshot()
>>> import pylab as pl
>>> pl.imshow(arr)
>>> pl.axis('off')
>>> pl.show()
"""
if figure is None:
figure = gcf()
x, y = tuple(figure.scene.get_size())
# Try to lift the window
figure.scene._lift()
if mode == 'rgb':
out = tvtk.UnsignedCharArray()
shape = (y, x, 3)
pixel_getter = figure.scene.render_window.get_pixel_data
pg_args = (0, 0, x - 1, y - 1, 1, out)
elif mode == 'rgba':
out = tvtk.FloatArray()
shape = (y, x, 4)
pixel_getter = figure.scene.render_window.get_rgba_pixel_data
pg_args = (0, 0, x - 1, y - 1, 1, out)
else:
raise ValueError('mode type not understood')
if antialiased:
# save the current aa value to restore it later
old_aa = figure.scene.render_window.aa_frames
figure.scene.render_window.aa_frames = figure.scene.anti_aliasing_frames
figure.scene.render()
pixel_getter(*pg_args)
figure.scene.render_window.aa_frames = old_aa
figure.scene.render()
else:
pixel_getter(*pg_args)
# Return the array in a way that pylab.imshow plots it right:
out = out.to_array()
out.shape = shape
out = np.flipud(out)
return out
def test_set_scalars(self):
"""Test if SetScalars works without a segfault."""
mesh = tvtk.PolyData()
sc = tvtk.FloatArray()
# If this does not segfault, we are OK.
mesh.point_data.scalars = sc
