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 update_data(self):
if not self._file_path.get():
return
attrs = ['scalars', 'vectors', 'tensors', 'normals',
't_coords', 'field_data']
reader = self.reader
for attr in attrs:
n = getattr(reader, 'number_of_%s_in_file' % attr)
method = getattr(reader, 'get_%s_name_in_file' % attr)
values = [method(x) for x in xrange(n)]
if values:
trait = Trait(values[0], TraitPrefixList(values))
else:
trait = Trait('', TraitPrefixList(['']))
self.add_trait('%s_name' % attr, trait)
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
class VTKFileReader(Source):
"""CitcomS VTK file reader.
"""
# The version of this class. Used for persistence.
__version__ = 0
# The list of file names for the timeseries.
file_list = List(Str, desc='a list of files belonging to a time series')
# The current timestep (starts with 0). This trait is a dummy
# and is dynamically changed when the `file_list` trait changes.
# This is done so the timestep bounds are linked to the number of
# the files in the file list.
timestep = Range(0, 0, desc='the current time step')
# A timestep view group that may be included by subclasses.
time_step_group = Group(Item(name='_file_path', style='readonly'),
Item(name='timestep', defined_when='len(object.file_list) > 1'))
# CitcomS mesh parameters
nx = Int()
ny = Int()
nz = Int()
radius_inner = Float()
#####################
# Private traits.
#####################
# The current file name. This is not meant to be touched by the user.
_file_path = Instance(FilePath, (), desc='the current file name')
##################################################
# Dynamic traits: These traits are dummies and are dynamically
# update depending on the contents of the file.
# The active scalar name.
scalars_name = Trait('', TraitPrefixList(['']))
# The active vector name.
vectors_name = Trait('', TraitPrefixList(['']))
# The active tensor name.
tensors_name = Trait('', TraitPrefixList(['']))
# The active normals name.
normals_name = Traits('', TraitPrefixList(['']))
# The active tcoord name.
t_coords_name = Trait('', TraitPrefixList(['']))
# The active field_data name.
field_data_name = Trait('', TraitPrefixList(['']))
##################################################
# The VTK data file reader.
reader = Instance(tvtk.DataSetReader, ())
# Our view.
view = View(Group(Include('time_step_group'),
Item(name='scalars_name'),
Item(name='vectors_name'),
Item(name='tensors_name'),
Item(name='normals_name'),
Item(name='t_coords_name'),
Item(name='field_data_name'),
Item(name='reader')))
####################################################
# `object` interface
####################################################
def __get_pure_state__(self):
d = super(VTKFileReader, self).__get_pure_state__()
# These are obtained dynamically, so don't pickle them.
for x in ['file_list', 'timestep']:
d.pop(x, None)
return d
def __set_pure_state__(self):
# The reader has its own file_name which needs to be fixed.
state.reader.file_name = state._file_path.abs_path
# Now call the parent class to setup everything.
# Use the saved path to initialize the file_list and timestep.
fname = state._file_path.abs_pth
if not isfile(fname):
msg = 'Could not find file at %s\n' % fname
msg += 'Please move the file there and try again.'
raise IOError, msg
self.initialize(fname)
# 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()
self.update()
# Call the parent method to do its thing. This will typically
# start all our children.
super(VTKFileReader, self).start()
def stop(self):
"""Invoked when this object is removed from the mayavi
pipeline.
"""
if not self.running:
return
# Call the parent method to do its thing.
super(VTKFileReader, self).start()
#############################
# `FileDataSource` interface
#############################
def update(self):
if not self._file_path.get():
return
reader = self.reader
reader.update()
self.render()
def update_data(self):
if not self._file_path.get():
return
attrs = ['scalars', 'vectors', 'tensors', 'normals',
't_coords', 'field_data']
reader = self.reader
for attr in attrs:
n = getattr(reader, 'number_of_%s_in_file' % attr)
method = getattr(reader, 'get_%s_name_in_file' % attr)
values = [method(x) for x in xrange(n)]
if values:
trait = Trait(values[0], TraitPrefixList(values))
else:
trait = Trait('', TraitPrefixList(['']))
self.add_trait('%s_name' % attr, trait)
#############################
# `TreeNodeObject` interface
#############################
def tno_get_label(self, node):
"""Gets the label to display for a specified object."""
fname = basename(self._file_path.get())
ret = "CitcomS VTK file (%s)" % fname
if len(self.file_list) > 1:
return ret + " (timeseries)"
else:
return ret
#############################
# `FileDataSource` interface
#############################
def initialize(self, base_file_name):
"""Given a single filename which may or may not be part of a
time series, this initializes the list of files. This method
need not be called to initialize the data.
"""
self.file_list = get_file_list(base_file_name)
# Read meta-information
meta = ""
try:
vtk = open(base_file_name, "r")
vtk.readline()
meta = vtk.readline()
except IOError:
print 'cannot open file'
else:
vtk.close()
try:
m = re.search('(?<=NX:)\d+', meta)
self.nx = int(m.group(0))
m = re.search('(?<=NY:)\d+', meta)
self.ny = int(m.group(0))
m = re.search('(?<=NZ:)\d+', meta)
self.nz = int(m.group(0))
m = re.search('(?<=Radius_Inner:)(\d+|.)+', meta)
self.radius_inner = float(m.group(0))
except ValueError:
print "Invalid meta information in file..."
if len(self.file_list) == 0:
self.file_list = [base_file_name]
try:
self.timestep = self.file_list.index(base_file_name)
except ValueError:
self.timestep = 0
###########################################################################
# Non-public interface
###########################################################################
def _file_list_changed(self, value):
# Change the range of the timestep suitably to reflect new list.
n_files = len(self.file_list)
timestep = min(self.timestep, n_files)
trait = Range(0, n_files-1, timestep)
self.add_trait('timestep', trait)
if self.timestep == timestep:
self._timestep_changed(timestep)
else:
self.timestep = timestep
def _file_list_items_changed(self, list_event):
self._file_list_changed(self.file_list)
def _timestep_changed(self, value):
file_list = self.file_list
if len(file_list):
self._file_path = FilePath(file_list[value])
else:
self._file_path = FilePath('')
def __file_path_changed(self, fpath):
value = fpath.get()
if not value
return
else:
self.reader.file_name = value
self.update_data()
self.update()
# Setup the outputs by resetting self.outputs. Changing
# the outputs automatically fires a pipeline_changed
# event.
try:
n = self.reader.number_of_outputs
except AttributeError: # for VTK >= 4.5
n = self.reader.number_of_output_ports
outputs = []
for i in range(n):
outputs.append(self.reader.get_output(i))
self.outputs = outputs
# Fire data_changed just in case the outputs are not
# really changed. This can happen if the dataset is of
# the same type as before.
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))
return
def _set_data_name(self, data_type, value):
if not value or not data_type:
return
reader = self.reader
setattr(reader, data_type, value)
self.update()
# Fire an event, so the changes propagate.
self.data_changed = True
def _scalars_name_changed(self, value):
self._set_data_name('scalars_name', value)
def _vectors_name_changed(self, value):
self._set_data_name('vectors_name', value)
def _tensors_name_changed(self, value):
self._set_data_name('tensors_name', value)
def _normals_name_changed(self, value):
self._set_data_name('normals_name', value)
def _t_coords_name_changed(self, value):
self._set_data_name('t_coords_name', value)
def _field_data_name_changed(self, value):
self._set_data_name('field_data_name', value)