pyvisi/py_src/datacollector.py

"""
@author: John NGUI
"""

import vtk
import tempfile, os, sys
from constant import Source, VizType, ColorMode
try:
    import esys.escript 
except ImportError:
    print "Warning: importing esys.escript failed."

try:
     PYVISI_WORKDIR=os.environ['PYVISI_WORKDIR']
except KeyError:
     PYVISI_WORKDIR='.'
try:
     PYVISI_TEST_DATA_ROOT=os.environ['PYVISI_TEST_DATA_ROOT']
except KeyError:
     PYVISI_TEST_DATA_ROOT='.'
    
class DataCollector:
    """
    Class that defines a data collector. A data collector is used to read 
    data from an XML file or from an escript object directly.

    @attention: A DataCollector instance can only be used to specify one 
    scalar, vector and tensor attribute from a source at any one time. If a 
    second scalar, vector or tensor attribute needs to be specified from the 
    same source, a second DataCollector instance must be created. 

    @attention: When a series of XML files or escript objects are read 
    (using 'setFileName' or 'setData' in a for-loop), the 'setActiveScalar' / 
    'setActiveVector' / 'setActiveTensor' have to be called for each new file
    (provided a specific field needs to be loaded) as all active fields 
    specified from the previous file goes back to the default once a new file 
    is read.
    """

    def __init__(self, source = Source.XML):
        """
        Initialise the data collector.

        @type source: L{Source <constant.Source>} constant
        @param source: Source type
        """

        self.__source = source
        self.__count = 0 # Keeps track of the number of files/sources read.

        if(source == Source.XML): # Source is an XML file.
            self.__vtk_xml_reader = vtk.vtkXMLUnstructuredGridReader()
        # Source is a escript data object using a temp file in the background. 
        elif (self.__source == Source.ESCRIPT):
            self.__vtk_xml_reader = vtk.vtkXMLUnstructuredGridReader()
            # Create a temporary .xml file and retrieve its path.
            self.__tmp_file = tempfile.mkstemp(suffix=".xml")[1]

    def __del__(self):
        """
        Perform some clean up of the temporary file.
        """

        if (self.__source == Source.ESCRIPT):
            if os.access(self.__tmp_file,os.F_OK): os.unlink(self.__tmp_file)

    def setFileName(self, file_name):
        """
        Set the XML file name to read. 

        @type file_name: String
        @param file_name: Name of the file to read
        """

        if(self.__source == Source.XML):
            # Check whether the specified file exists, otherwise exit.
            if not(os.access(file_name, os.F_OK)):
                raise IOError("ERROR: '%s' file does NOT exists." % file_name)      

            self.__vtk_xml_reader.SetFileName(file_name)
            # Update must be called after SetFileName to make the reader 
            # up-to-date. Otherwise, some output values may be incorrect.
            self.__vtk_xml_reader.Update() 
            self.__output = self.__vtk_xml_reader.GetOutput()
            self.__get_attribute_lists()
            
            # Count has to be larger than zero because when setFileName is 
            # called for the first time, the data set mapper has not yet been
            # instantiated. Therefore, the range of the mapper can only be
            # updated after the first file/source has been read.
            if(self.__count > 0):
                self._updateRange()

            self.__count+=1

        else:
            raise ValueError("Source type %s does not support \
            'setFileName'\n" % self.__source)

    def setData(self,**args):
        """
        Create data using the <name>=<data> pairing. Assumption is made
        that the data will be given in the appropriate format.
        """

        if self.__source == Source.ESCRIPT:
            esys.escript.saveVTK(self.__tmp_file,**args)
            self.__vtk_xml_reader.SetFileName(self.__tmp_file)
            # Modified must be called for setData but NOT for
            # setFileName. If Modified is not called, only the first file 
            # will always be displayed. The reason Modified is used is 
            # because the same temporary file name is always used 
            # (previous file is overwritten). Modified MUST NOT be used in 
            # setFileName, it can cause incorrect output such as map.
            self.__vtk_xml_reader.Modified()
            # Update must be called after Modified. If Update is called before
            # Modified, then the first/second image(s) may not be updated
            # correctly.
            self.__vtk_xml_reader.Update()
            self.__output = self.__vtk_xml_reader.GetOutput()
            self.__get_attribute_lists()

            if(self.__count > 0):
                self._updateRange()

            self.__count+=1
        else:
            raise ValueError("Source type %s does not support 'setData'\n" \
                    % self.__source)

    def setActiveScalar(self, scalar):
        """
        Specify the scalar field to load. 

        @type scalar: String
        @param scalar: Scalar field to load from the file. 
        """
        
        # Check whether the specified scalar is available in either point
        # or cell data. If not available, program exits.

        # NOTE: This check is similar to the check used in _getScalarRange 
        # but this is used only when a scalar attribute has been specified.
        if scalar in self.__point_attribute['scalars']:
            self._getOutput().GetPointData().SetActiveScalars(scalar)
        elif scalar in self.__cell_attribute['scalars']:
            self._getOutput().GetCellData().SetActiveScalars(scalar)
        else:
            raise IOError("ERROR: No scalar called '%s' is available." % scalar)

    def setActiveVector(self, vector):
        """
        Specify the vector field to load.

        @type vector: String
        @param vector: Vector field to load from the file. 
        """
        
        # Check whether the specified vector is available in either point
        # or cell data. If not available, program exits.

        # NOTE: This check is similar to the check used in _getVectorRange 
        # but this is used only when a vector attribute has been specified.
        if vector in self.__point_attribute['vectors']:
            self._getOutput().GetPointData().SetActiveVectors(vector)
        elif vector in self.__cell_attribute['vectors']:
            self._getOutput().GetCellData().SetActiveVectors(vector)
        else:
            raise IOError("ERROR: No vector called '%s' is available." % vector)
            
    def setActiveTensor(self, tensor):
        """
        Specify the tensor field to load.

        @type tensor: String
        @param tensor: Tensor field to load from the file. 
        """

        # Check whether the specified tensor is available in either point
        # or cell data. If not available, program exits.

        # NOTE: This check is similar to the check used in _getTensorRange 
        # but this is used only when a tensor attribute has been specified.
        if tensor in self.__point_attribute['tensors']:
            self._getOutput().GetPointData().SetActiveTensors(tensor)
        elif tensor in self.__cell_attribute['tensors']:
            self._getOutput().GetCellData().SetActiveTensors(tensor)
        else:
            raise IOError("ERROR: No tensor called '%s' is available." % tensor)

    # 'object' is set to 'None' because some types of visualization have
    # two ranges that needs to be updated while others only have one.
    def _paramForUpdatingMultipleSources(self, viz_type, color_mode, mapper,
            object = None):
        """
        Parameters required to update the necessary data when two or more 
        files or escript objects are read.

        @type viz_type: : L{VizType <constant.VizType>} constant
        @param viz_type: Type if visualization 
        @type color_mode: L{ColorMode <constant.ColorMode>} constant
        @param color_mode: Type of color mode
        @type mapper: vtkDataSetMapper
        @param mapper: Mapped data
        @type object: vtkPolyDataAlgorithm (i.e. vtkContourFilter, vtkGlyph3D, \
                etc)
        @param object: Polygonal data
        """

        self.__viz_type = viz_type
        self.__color_mode = color_mode
        self.__mapper = mapper
        self.__object = object

    def _updateRange(self):
        """
        Update the necessary range(s) when two or more files or escript objects 
        are read.
        """

        if self.__viz_type == VizType.MAP or \
                self.__viz_type == VizType.ELLIPSOID or \
                self.__viz_type == VizType.CARPET:
            self.__mapper.SetScalarRange(self._getScalarRange())
        elif self.__viz_type == VizType.VELOCITY:
            if self.__color_mode == ColorMode.VECTOR:
                self.__object.SetRange(self._getVectorRange())
                self.__mapper.SetScalarRange(self._getVectorRange())
            elif self.__color_mode == ColorMode.SCALAR:
                self.__object.SetRange(self._getScalarRange())
                self.__mapper.SetScalarRange(self._getScalarRange())
        elif self.__viz_type == VizType.CONTOUR:
            self.__object.GenerateValues(
                    self.__object.GetNumberOfContours(),
                    self._getScalarRange()[0],
                    self._getScalarRange()[1])
            self.__mapper.SetScalarRange(self._getScalarRange())
        elif self.__viz_type == VizType.STREAMLINE:
            if self.__color_mode == ColorMode.VECTOR:
                self.__mapper.SetScalarRange(self._getVectorRange())
            elif self.__color_mode == ColorMode.SCALAR:
                self.__mapper.SetScalarRange(self._getScalarRange())

    def __get_array_type(self, arr):
        """
        Return whether an array type is scalar, vector or tensor by looking 
        at the number of components in the array.

        @type arr: vtkDataArray
        @param arr: An array from the source.
        @rtype: String
        @return: Array type ('scalar', vector' or 'tensor')
        """

        # Number of components in an array.
        num_components = arr.GetNumberOfComponents() 

        if num_components == 1:
            return 'scalars'
        elif num_components == 3:
            return 'vectors'
        elif num_components == 9:
            return 'tensors'

    def __get_attribute_list(self, data): 
        """
        Return the available scalar, vector and tensor attributes 
        (either point or cell data).

        @type data: vtkPointData or vtkCellData
        @param data: Available point data or cell data from the source
        @rtype: Dictionary
        @return: Dictionary containing the available scalar, vector and \
                tensor attributes
        """

        attribute = {'scalars':[], 'vectors':[], 'tensors':[]} 
        if data:
            num_arrays = data.GetNumberOfArrays() # Number of arrays.
            for i in range(num_arrays):
                name = data.GetArrayName(i) # Get an array name.
                type = self.__get_array_type(data.GetArray(i)) # Get array type.
                attribute[type].extend([name]) # Add array name to dictionary.

        return attribute

    def __get_attribute_lists(self):
        """
        Get all the available point and cell data attributes from the source.
        """

        # Get all the available point data attributes into a list.
        self.__point_attribute = \
                self.__get_attribute_list(self._getOutput().GetPointData())
        # Get all the available cell data attribute into another list.  
        self.__cell_attribute = \
                self.__get_attribute_list(self._getOutput().GetCellData())

    def _getScalarRange(self):
        """
        Return the scalar range.

        @rtype: Two column tuple containing numbers
        @return: Scalar range
        """

        # Check whether any scalar is available in either point or cell data. 
        # If not available, program exits.

        # NOTE: This check is similar to the check used in _setActiveScalar 
        # but this is used only when no scalar attribute has been specified.
        if(len(self.__point_attribute['scalars']) != 0):
            return self._getOutput().GetPointData().GetScalars().GetRange(-1)
        elif(len(self.__cell_attribute['scalars']) != 0):
            return self._getOutput().GetCellData().GetScalars().GetRange(-1)
        else:
            raise IOError("ERROR: No scalar is available.")

    def _getVectorRange(self):
        """
        Return the vector range.
    
        @rtype: Two column tuple containing numbers
        @return: Vector range
        """
        
        # Check whether any vector is available in either point or cell data. 
        # If not available, program exits.

        # NOTE: This check is similar to the check used in _setActiveVector 
        # but this is used only when no vector attribute has been specified.

        # NOTE: Generally GetRange(-1) returns the correct vector range. 
        # However, there are certain data sets where GetRange(-1) seems 
        # to return incorrect mimimum vector although the maximum vector is 
        # correct. As a result, the mimimum vector has been hard coded to 0.0
        # to accommodate for the incorrect cases.
        if(len(self.__point_attribute['vectors']) != 0):
            vector_range = \
                    self._getOutput().GetPointData().GetVectors().GetRange(-1)
            return (0.0, vector_range[1])
        elif(len(self.__cell_attribute['vectors']) != 0): 
            vector_range = \
                    self._getOutput().GetCellData().GetVectors().GetRange(-1)
            return (0.0, vector_range[1])
        else:
            print "\nERROR: No vector is available.\n"  
            sys.exit(0)

    def _getTensorRange(self):
        """
        Return the tensor range.

        @rtype: Two column tuple containing numbers
        @return: Tensor range
        """

        # Check whether any tensor is available in either point or cell data. 
        # If not available, program exits.

        # NOTE: This check is similar to the check used in _setActiveTensor 
        # but this is used only when no tensor attribute has been specified.
        if(len(self.__point_attribute['tensors']) != 0):
            return self._getOutput().GetPointData().GetTensors().GetRange(-1)
        elif(len(self.__cell_attribute['tensors']) != 0): 
            return self._getOutput().GetCellData().GetTensors().GetRange(-1)
        else:
            print "\nERROR: No tensor is available.\n"  
            sys.exit(1)

    def _getOutput(self):
        """
        Return the output of the data collector.

        @rtype: vtkUnstructuredGrid
        @return: Unstructured grid
        """

        return self.__output

1	ksteube	1147	"""
2			@author: John NGUI
3			"""
4
5			import vtk
6			import tempfile, os, sys
7			from constant import Source, VizType, ColorMode
8			try:
9			import esys.escript
10			except ImportError:
11			print "Warning: importing esys.escript failed."
12
13			try:
14			PYVISI_WORKDIR=os.environ['PYVISI_WORKDIR']
15			except KeyError:
16			PYVISI_WORKDIR='.'
17			try:
18			PYVISI_TEST_DATA_ROOT=os.environ['PYVISI_TEST_DATA_ROOT']
19			except KeyError:
20			PYVISI_TEST_DATA_ROOT='.'
21
22			class DataCollector:
23			"""
24			Class that defines a data collector. A data collector is used to read
25			data from an XML file or from an escript object directly.
26
27			@attention: A DataCollector instance can only be used to specify one
28			scalar, vector and tensor attribute from a source at any one time. If a
29			second scalar, vector or tensor attribute needs to be specified from the
30			same source, a second DataCollector instance must be created.
31
32			@attention: When a series of XML files or escript objects are read
33			(using 'setFileName' or 'setData' in a for-loop), the 'setActiveScalar' /
34			'setActiveVector' / 'setActiveTensor' have to be called for each new file
35			(provided a specific field needs to be loaded) as all active fields
36			specified from the previous file goes back to the default once a new file
37			is read.
38			"""
39
40			def __init__(self, source = Source.XML):
41			"""
42			Initialise the data collector.
43
44			@type source: L{Source <constant.Source>} constant
45			@param source: Source type
46			"""
47
48			self.__source = source
49			self.__count = 0 # Keeps track of the number of files/sources read.
50
51			if(source == Source.XML): # Source is an XML file.
52			self.__vtk_xml_reader = vtk.vtkXMLUnstructuredGridReader()
53			# Source is a escript data object using a temp file in the background.
54			elif (self.__source == Source.ESCRIPT):
55			self.__vtk_xml_reader = vtk.vtkXMLUnstructuredGridReader()
56			# Create a temporary .xml file and retrieve its path.
57			self.__tmp_file = tempfile.mkstemp(suffix=".xml")[1]
58
59			def __del__(self):
60			"""
61			Perform some clean up of the temporary file.
62			"""
63
64			if (self.__source == Source.ESCRIPT):
65			if os.access(self.__tmp_file,os.F_OK): os.unlink(self.__tmp_file)
66
67			def setFileName(self, file_name):
68			"""
69			Set the XML file name to read.
70
71			@type file_name: String
72			@param file_name: Name of the file to read
73			"""
74
75			if(self.__source == Source.XML):
76			# Check whether the specified file exists, otherwise exit.
77			if not(os.access(file_name, os.F_OK)):
78			raise IOError("ERROR: '%s' file does NOT exists." % file_name)
79
80			self.__vtk_xml_reader.SetFileName(file_name)
81			# Update must be called after SetFileName to make the reader
82			# up-to-date. Otherwise, some output values may be incorrect.
83			self.__vtk_xml_reader.Update()
84			self.__output = self.__vtk_xml_reader.GetOutput()
85			self.__get_attribute_lists()
86
87			# Count has to be larger than zero because when setFileName is
88			# called for the first time, the data set mapper has not yet been
89			# instantiated. Therefore, the range of the mapper can only be
90			# updated after the first file/source has been read.
91			if(self.__count > 0):
92			self._updateRange()
93
94			self.__count+=1
95
96			else:
97			raise ValueError("Source type %s does not support \
98			'setFileName'\n" % self.__source)
99
100			def setData(self,**args):
101			"""
102			Create data using the <name>=<data> pairing. Assumption is made
103			that the data will be given in the appropriate format.
104			"""
105
106			if self.__source == Source.ESCRIPT:
107			esys.escript.saveVTK(self.__tmp_file,**args)
108			self.__vtk_xml_reader.SetFileName(self.__tmp_file)
109			# Modified must be called for setData but NOT for
110			# setFileName. If Modified is not called, only the first file
111			# will always be displayed. The reason Modified is used is
112			# because the same temporary file name is always used
113			# (previous file is overwritten). Modified MUST NOT be used in
114			# setFileName, it can cause incorrect output such as map.
115			self.__vtk_xml_reader.Modified()
116			# Update must be called after Modified. If Update is called before
117			# Modified, then the first/second image(s) may not be updated
118			# correctly.
119			self.__vtk_xml_reader.Update()
120			self.__output = self.__vtk_xml_reader.GetOutput()
121			self.__get_attribute_lists()
122
123			if(self.__count > 0):
124			self._updateRange()
125
126			self.__count+=1
127			else:
128			raise ValueError("Source type %s does not support 'setData'\n" \
129			% self.__source)
130
131			def setActiveScalar(self, scalar):
132			"""
133			Specify the scalar field to load.
134
135			@type scalar: String
136			@param scalar: Scalar field to load from the file.
137			"""
138
139			# Check whether the specified scalar is available in either point
140			# or cell data. If not available, program exits.
141
142			# NOTE: This check is similar to the check used in _getScalarRange
143			# but this is used only when a scalar attribute has been specified.
144			if scalar in self.__point_attribute['scalars']:
145			self._getOutput().GetPointData().SetActiveScalars(scalar)
146			elif scalar in self.__cell_attribute['scalars']:
147			self._getOutput().GetCellData().SetActiveScalars(scalar)
148			else:
149			raise IOError("ERROR: No scalar called '%s' is available." % scalar)
150
151			def setActiveVector(self, vector):
152			"""
153			Specify the vector field to load.
154
155			@type vector: String
156			@param vector: Vector field to load from the file.
157			"""
158
159			# Check whether the specified vector is available in either point
160			# or cell data. If not available, program exits.
161
162			# NOTE: This check is similar to the check used in _getVectorRange
163			# but this is used only when a vector attribute has been specified.
164			if vector in self.__point_attribute['vectors']:
165			self._getOutput().GetPointData().SetActiveVectors(vector)
166			elif vector in self.__cell_attribute['vectors']:
167			self._getOutput().GetCellData().SetActiveVectors(vector)
168			else:
169			raise IOError("ERROR: No vector called '%s' is available." % vector)
170
171			def setActiveTensor(self, tensor):
172			"""
173			Specify the tensor field to load.
174
175			@type tensor: String
176			@param tensor: Tensor field to load from the file.
177			"""
178
179			# Check whether the specified tensor is available in either point
180			# or cell data. If not available, program exits.
181
182			# NOTE: This check is similar to the check used in _getTensorRange
183			# but this is used only when a tensor attribute has been specified.
184			if tensor in self.__point_attribute['tensors']:
185			self._getOutput().GetPointData().SetActiveTensors(tensor)
186			elif tensor in self.__cell_attribute['tensors']:
187			self._getOutput().GetCellData().SetActiveTensors(tensor)
188			else:
189			raise IOError("ERROR: No tensor called '%s' is available." % tensor)
190
191			# 'object' is set to 'None' because some types of visualization have
192			# two ranges that needs to be updated while others only have one.
193			def _paramForUpdatingMultipleSources(self, viz_type, color_mode, mapper,
194			object = None):
195			"""
196			Parameters required to update the necessary data when two or more
197			files or escript objects are read.
198
199			@type viz_type: : L{VizType <constant.VizType>} constant
200			@param viz_type: Type if visualization
201			@type color_mode: L{ColorMode <constant.ColorMode>} constant
202			@param color_mode: Type of color mode
203			@type mapper: vtkDataSetMapper
204			@param mapper: Mapped data
205			@type object: vtkPolyDataAlgorithm (i.e. vtkContourFilter, vtkGlyph3D, \
206			etc)
207			@param object: Polygonal data
208			"""
209
210			self.__viz_type = viz_type
211			self.__color_mode = color_mode
212			self.__mapper = mapper
213			self.__object = object
214
215			def _updateRange(self):
216			"""
217			Update the necessary range(s) when two or more files or escript objects
218			are read.
219			"""
220
221			if self.__viz_type == VizType.MAP or \
222			self.__viz_type == VizType.ELLIPSOID or \
223			self.__viz_type == VizType.CARPET:
224			self.__mapper.SetScalarRange(self._getScalarRange())
225			elif self.__viz_type == VizType.VELOCITY:
226			if self.__color_mode == ColorMode.VECTOR:
227			self.__object.SetRange(self._getVectorRange())
228			self.__mapper.SetScalarRange(self._getVectorRange())
229			elif self.__color_mode == ColorMode.SCALAR:
230			self.__object.SetRange(self._getScalarRange())
231			self.__mapper.SetScalarRange(self._getScalarRange())
232			elif self.__viz_type == VizType.CONTOUR:
233			self.__object.GenerateValues(
234			self.__object.GetNumberOfContours(),
235			self._getScalarRange()[0],
236			self._getScalarRange()[1])
237			self.__mapper.SetScalarRange(self._getScalarRange())
238			elif self.__viz_type == VizType.STREAMLINE:
239			if self.__color_mode == ColorMode.VECTOR:
240			self.__mapper.SetScalarRange(self._getVectorRange())
241			elif self.__color_mode == ColorMode.SCALAR:
242			self.__mapper.SetScalarRange(self._getScalarRange())
243
244			def __get_array_type(self, arr):
245			"""
246			Return whether an array type is scalar, vector or tensor by looking
247			at the number of components in the array.
248
249			@type arr: vtkDataArray
250			@param arr: An array from the source.
251			@rtype: String
252			@return: Array type ('scalar', vector' or 'tensor')
253			"""
254
255			# Number of components in an array.
256			num_components = arr.GetNumberOfComponents()
257
258			if num_components == 1:
259			return 'scalars'
260			elif num_components == 3:
261			return 'vectors'
262			elif num_components == 9:
263			return 'tensors'
264
265			def __get_attribute_list(self, data):
266			"""
267			Return the available scalar, vector and tensor attributes
268			(either point or cell data).
269
270			@type data: vtkPointData or vtkCellData
271			@param data: Available point data or cell data from the source
272			@rtype: Dictionary
273			@return: Dictionary containing the available scalar, vector and \
274			tensor attributes
275			"""
276
277			attribute = {'scalars':[], 'vectors':[], 'tensors':[]}
278			if data:
279			num_arrays = data.GetNumberOfArrays() # Number of arrays.
280			for i in range(num_arrays):
281			name = data.GetArrayName(i) # Get an array name.
282			type = self.__get_array_type(data.GetArray(i)) # Get array type.
283			attribute[type].extend([name]) # Add array name to dictionary.
284
285			return attribute
286
287			def __get_attribute_lists(self):
288			"""
289			Get all the available point and cell data attributes from the source.
290			"""
291
292			# Get all the available point data attributes into a list.
293			self.__point_attribute = \
294			self.__get_attribute_list(self._getOutput().GetPointData())
295			# Get all the available cell data attribute into another list.
296			self.__cell_attribute = \
297			self.__get_attribute_list(self._getOutput().GetCellData())
298
299			def _getScalarRange(self):
300			"""
301			Return the scalar range.
302
303			@rtype: Two column tuple containing numbers
304			@return: Scalar range
305			"""
306
307			# Check whether any scalar is available in either point or cell data.
308			# If not available, program exits.
309
310			# NOTE: This check is similar to the check used in _setActiveScalar
311			# but this is used only when no scalar attribute has been specified.
312			if(len(self.__point_attribute['scalars']) != 0):
313			return self._getOutput().GetPointData().GetScalars().GetRange(-1)
314			elif(len(self.__cell_attribute['scalars']) != 0):
315			return self._getOutput().GetCellData().GetScalars().GetRange(-1)
316			else:
317			raise IOError("ERROR: No scalar is available.")
318
319			def _getVectorRange(self):
320			"""
321			Return the vector range.
322
323			@rtype: Two column tuple containing numbers
324			@return: Vector range
325			"""
326
327			# Check whether any vector is available in either point or cell data.
328			# If not available, program exits.
329
330			# NOTE: This check is similar to the check used in _setActiveVector
331			# but this is used only when no vector attribute has been specified.
332
333			# NOTE: Generally GetRange(-1) returns the correct vector range.
334			# However, there are certain data sets where GetRange(-1) seems
335			# to return incorrect mimimum vector although the maximum vector is
336			# correct. As a result, the mimimum vector has been hard coded to 0.0
337			# to accommodate for the incorrect cases.
338			if(len(self.__point_attribute['vectors']) != 0):
339			vector_range = \
340			self._getOutput().GetPointData().GetVectors().GetRange(-1)
341			return (0.0, vector_range[1])
342			elif(len(self.__cell_attribute['vectors']) != 0):
343			vector_range = \
344			self._getOutput().GetCellData().GetVectors().GetRange(-1)
345			return (0.0, vector_range[1])
346			else:
347			print "\nERROR: No vector is available.\n"
348			sys.exit(0)
349
350			def _getTensorRange(self):
351			"""
352			Return the tensor range.
353
354			@rtype: Two column tuple containing numbers
355			@return: Tensor range
356			"""
357
358			# Check whether any tensor is available in either point or cell data.
359			# If not available, program exits.
360
361			# NOTE: This check is similar to the check used in _setActiveTensor
362			# but this is used only when no tensor attribute has been specified.
363			if(len(self.__point_attribute['tensors']) != 0):
364			return self._getOutput().GetPointData().GetTensors().GetRange(-1)
365			elif(len(self.__cell_attribute['tensors']) != 0):
366			return self._getOutput().GetCellData().GetTensors().GetRange(-1)
367			else:
368			print "\nERROR: No tensor is available.\n"
369			sys.exit(1)
370
371			def _getOutput(self):
372			"""
373			Return the output of the data collector.
374
375			@rtype: vtkUnstructuredGrid
376			@return: Unstructured grid
377			"""
378
379			return self.__output
380