from math import sqrt, sin, cos, radians
from string import upper
-import pvsimple as pv
+# Do not use pv as a short name.
+# It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call.
+# import pvsimple as pv
+import pvsimple as pvs
#try:
# # TODO(MZN): to be removed (issue with Point Sprite texture)
# #import paravisSM as sm
#except:
-# import paraview.simple as pv
+# import paraview.simple as pvs
# import paraview.servermanager as sm
# Globals
_current_bar = None
+_med_field_sep = '@@][@@'
# Enumerations
NODE = 0
CELL = 1
- _type2name = {NODE: 'OnPoint',
- CELL: 'OnCell'}
+ _type2name = {NODE: 'P1',
+ CELL: 'P0'}
- _name2type = {'OnPoint': NODE,
- 'OnCell': CELL}
+ _name2type = {'P1': NODE,
+ 'P0': CELL}
_type2pvtype = {NODE: 'POINT_DATA',
CELL: 'CELL_DATA'}
# Auxiliary functions
+
+def get_field_mesh_name(full_field_name):
+ """Return mesh name of the field by its full name."""
+ aList = full_field_name.split('/')
+ if len(aList) >= 2 :
+ field_name = full_field_name.split('/')[1]
+ return field_name
+
+
+def get_field_entity(full_field_name):
+ """Return entity type of the field by its full name."""
+ aList = full_field_name.split(_med_field_sep)
+ if len(aList) == 2 :
+ entity_name = full_field_name.split(_med_field_sep)[-1]
+ entity = EntityType.get_type(entity_name)
+ return entity
+
+
+def get_field_short_name(full_field_name):
+ """Return short name of the field by its full name."""
+ aList = full_field_name.split('/')
+ if len(aList) == 4 :
+ short_name_with_type = full_field_name.split('/')[-1]
+ short_name = short_name_with_type.split(_med_field_sep)[0]
+ return short_name
+
+
+def find_mesh_full_name(proxy, short_mesh_name):
+ """Return full mesh path by short mesh name, if found"""
+ proxy.UpdatePipeline()
+ all_mesh_names = get_mesh_full_names(proxy)
+ for name in all_mesh_names:
+ if short_mesh_name == get_field_short_name(name):
+ return name
+
+
def process_prs_for_test(prs, view, picture_name, show_bar=True):
"""Show presentation and record snapshot image.
os.makedirs(pic_dir)
# Save picture
- pv.WriteImage(file_name, view=view, Magnification=1)
+ pvs.WriteImage(file_name, view=view, Magnification=1)
def reset_view(view=None):
"""
if not view:
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
# Camera preferences
view.CameraFocalPoint = [0.0, 0.0, 0.0]
view.CameraParallelProjection = 1
view.ResetCamera()
- pv.Render(view=view)
+ pvs.Render(view=view)
def hide_all(view, to_remove=False):
"""Hide all representations in the view."""
if not view:
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
rep_list = view.Representations
for rep in rep_list:
rep.Visibility = 0
if to_remove:
view.Representations.remove(rep)
- pv.Render(view=view)
+ pvs.Render(view=view)
def display_only(prs, view=None):
"""Display only the given presentation in the view."""
- hide_all(view)
- if (hasattr(prs, 'Visibility') and prs.Visibility != 1):
- prs.Visibility = 1
- pv.Render(view=view)
+ if not view:
+ view = pvs.GetRenderView()
+
+ rep_list = view.Representations
+ for rep in rep_list:
+ if hasattr(rep, 'Visibility'):
+ rep.Visibility = (rep == prs)
+ pvs.Render(view=view)
def set_visible_lines(xy_prs, lines):
Data range as [min, max]
"""
+ proxy.UpdatePipeline()
entity_data_info = None
field_data = proxy.GetFieldDataInformation()
def get_bounds(proxy):
"""Get bounds of the proxy in 3D."""
+ proxy.UpdatePipeline()
dataInfo = proxy.GetDataInformation()
bounds_info = dataInfo.GetBounds()
return bounds_info
def get_x_range(proxy):
"""Get X range of the proxy bounds in 3D."""
+ proxy.UpdatePipeline()
bounds_info = get_bounds(proxy)
return bounds_info[0:2]
def get_y_range(proxy):
"""Get Y range of the proxy bounds in 3D."""
+ proxy.UpdatePipeline()
bounds_info = get_bounds(proxy)
return bounds_info[2:4]
def get_z_range(proxy):
"""Get Z range of the proxy bounds in 3D."""
+ proxy.UpdatePipeline()
bounds_info = get_bounds(proxy)
return bounds_info[4:6]
def is_planar_input(proxy):
"""Check if the given input is planar."""
+ proxy.UpdatePipeline()
bounds_info = get_bounds(proxy)
if (abs(bounds_info[0] - bounds_info[1]) <= FLT_MIN or
def is_data_on_cells(proxy, field_name):
"""Check the existence of a field on cells with the given name."""
+ proxy.UpdatePipeline()
cell_data_info = proxy.GetCellDataInformation()
return (field_name in cell_data_info.keys())
False: otherwise
"""
+ proxy.UpdatePipeline()
data_info = proxy.GetDataInformation()
nb_cells = data_info.GetNumberOfCells()
def get_orientation(proxy):
"""Get the optimum cutting plane orientation for Plot 3D."""
+ proxy.UpdatePipeline()
orientation = Orientation.XY
bounds = get_bounds(proxy)
def get_nb_components(proxy, entity, field_name):
"""Return number of components for the field."""
+ proxy.UpdatePipeline()
entity_data_info = None
field_data = proxy.GetFieldDataInformation()
def get_default_scale(prs_type, proxy, entity, field_name):
"""Get default scale factor."""
+ proxy.UpdatePipeline()
data_range = get_data_range(proxy, entity, field_name)
if prs_type == PrsTypeEnum.DEFORMEDSHAPE:
the calculator object.
"""
+ proxy.UpdatePipeline()
calculator = None
# Transform vector array to scalar array if possible
nb_components = get_nb_components(proxy, array_entity, array_name)
if (nb_components > 1):
- calculator = pv.Calculator(proxy)
+ calculator = pvs.Calculator(proxy)
attribute_mode = "Point Data"
if array_entity != EntityType.NODE:
attribute_mode = "Cell Data"
the calculator object.
"""
+ proxy.UpdatePipeline()
calculator = None
nb_components = get_nb_components(proxy, array_entity, array_name)
if nb_components == 2:
- calculator = pv.Calculator(proxy)
+ calculator = pvs.Calculator(proxy)
attribute_mode = "Point Data"
if array_entity != EntityType.NODE:
attribute_mode = "Cell Data"
Used in creation of mesh/submesh presentation.
"""
- ### Old API all_cell_types = proxy.CellTypes.Available
- all_cell_types = proxy.Entity.Available
- ### Old API proxy.CellTypes = all_cell_types
- proxy.Entity = all_cell_types
proxy.UpdatePipeline()
+ extractCT = pvs.ExtractCellType()
+ extractCT.AllGeoTypes = extractCT.GetProperty("GeoTypesInfo")[::2]
+ extractCT.UpdatePipelineInformation()
-def select_cells_with_data(proxy, on_points=None, on_cells=None):
+def select_cells_with_data(proxy, on_points=[], on_cells=[], on_gauss=[]):
"""Select cell types with data.
Only cell types with data for the given fields will be selected.
types with data for even one field (from available) will be selected.
"""
+ proxy.UpdatePipeline()
if not hasattr(proxy, 'Entity'):
- return
+ separator = proxy.GetProperty("Separator").GetData()
+
+ fields_info = proxy.GetProperty("FieldsTreeInfo")[::2]
+ arr_name_with_dis=[elt.split("/")[-1] for elt in fields_info]
+
+ proxy.AllArrays = []
+
+ fields = []
+ for name in on_gauss:
+ fields.append(name+separator+'GAUSS')
+ for name in on_cells:
+ fields.append(name+separator+'P0')
+ for name in on_points:
+ fields.append(name+separator+'P1')
+
+ field_list = []
+ for name in fields:
+ if arr_name_with_dis.count(name) > 0:
+ index = arr_name_with_dis.index(name)
+ field_list.append(fields_info[index])
+
+ proxy.AllArrays = field_list
+ proxy.UpdatePipeline()
+ return len(field_list) != 0
+
+ # TODO: VTN. Looks like this code is out of date.
#all_cell_types = proxy.CellTypes.Available
all_cell_types = proxy.Entity.Available
proxy.Entity = cell_types_on
proxy.UpdatePipeline()
-def if_possible(proxy, field_name, entity, prs_type):
+def if_possible(proxy, field_name, entity, prs_type, extrGrps=None):
"""Check if the presentation creation is possible on the given field."""
+ proxy.UpdatePipeline()
result = True
if (prs_type == PrsTypeEnum.DEFORMEDSHAPE or
prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP or
result = (entity == EntityType.CELL or
field_name in proxy.QuadraturePointArrays.Available)
elif (prs_type == PrsTypeEnum.MESH):
- result = len(get_group_names(proxy, field_name, entity)) > 0
+ result = len(get_group_names(extrGrps)) > 0
return result
title = "\n".join([title, vector_mode])
# Create scalar bar
- scalar_bar = pv.CreateScalarBar(Enabled=1)
+ scalar_bar = pvs.CreateScalarBar(Enabled=1)
scalar_bar.Orientation = 'Vertical'
scalar_bar.Title = title
scalar_bar.LookupTable = lookup_table
scalar_bar.LabelShadow = 1
# Add the scalar bar to the view
- pv.GetRenderView().Representations.append(scalar_bar)
+ pvs.GetRenderView().Representations.append(scalar_bar)
# Reassign the current bar
_current_bar = scalar_bar
def get_lookup_table(field_name, nb_components, vector_mode='Magnitude'):
"""Get lookup table for the given field."""
- lookup_table = pv.GetLookupTableForArray(field_name, nb_components)
+ lookup_table = pvs.GetLookupTableForArray(field_name, nb_components)
if vector_mode == 'Magnitude':
lookup_table.VectorMode = vector_mode
def get_group_short_name(full_group_name):
"""Return short name of the group by its full name."""
- aList = full_group_name.split('/')
- if len(aList) >= 4 :
- short_name = full_group_name.split('/')[3]
- return short_name
+ short_name = re.sub('^GRP_', '', full_group_name)
+ return short_name
-def get_mesh_names(proxy):
+def get_mesh_full_names(proxy):
"""Return all mesh names in the given proxy as a set."""
- groups = proxy.Groups.Available
- mesh_names = set([get_group_mesh_name(item) for item in groups])
-
- return mesh_names
+ proxy.UpdatePipeline()
+ fields = proxy.GetProperty("FieldsTreeInfo")[::2]
+ mesh_full_names = set([item for item in fields if get_field_mesh_name(item) == get_field_short_name(item)])
+ return mesh_full_names
-def get_group_names(proxy, mesh_name, entity, wo_nogroups=False):
- """Return full names of all groups of the given entity type
- from the mesh with the given name as a list.
+def get_group_names(extrGrps):
+ """Return full names of all groups of the given 'ExtractGroup' filter object.
"""
- groups = proxy.Groups.Available
-
- condition = lambda item: (get_group_mesh_name(item) == mesh_name and
- get_group_entity(item) == entity)
- group_names = [item for item in groups if condition(item)]
-
- if wo_nogroups:
- # Remove "No_Group" group
- not_no_group = lambda item: get_group_short_name(item) != "No_Group"
- group_names = filter(not_no_group, group_names)
-
+ group_names = filter(lambda x:x[:4]=="GRP_",list(extrGrps.GetProperty("GroupsFlagsInfo")[::2]))
return group_names
def get_time(proxy, timestamp_nb):
"""Get time value by timestamp number."""
+ proxy.UpdatePipeline()
# Check timestamp number
timestamps = []
elif (hasattr(proxy.Input, 'TimestepValues')):
timestamps = proxy.Input.TimestepValues.GetData()
- if ((timestamp_nb - 1) not in xrange(len(timestamps))):
+ length = len(timestamps)
+ if (timestamp_nb > 0 and (timestamp_nb - 1) not in xrange(length) ) or (timestamp_nb < 0 and -timestamp_nb > length):
raise ValueError("Timestamp number is out of range: " + str(timestamp_nb))
# Return time value
- return timestamps[timestamp_nb - 1]
-
+ if timestamp_nb > 0:
+ return timestamps[timestamp_nb - 1]
+ else:
+ return timestamps[timestamp_nb]
def create_prs(prs_type, proxy, field_entity, field_name, timestamp_nb):
"""Auxiliary function.
Set the presentation properties like visu.CreatePrsForResult() do.
"""
+ proxy.UpdatePipeline()
prs = None
if prs_type == PrsTypeEnum.SCALARMAP:
Scalar Map as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
if entity == EntityType.NODE:
select_cells_with_data(proxy, on_points=[field_name])
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Get Scalar Map representation object
- scalarmap = pv.GetRepresentation(proxy)
+ scalarmap = pvs.GetRepresentation(proxy)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Cut Planes as representation object.
"""
+ proxy.UpdatePipeline()
+ if entity == EntityType.NODE:
+ select_cells_with_data(proxy, on_points=[field_name])
+ else:
+ select_cells_with_data(proxy, on_cells=[field_name])
+
# Check vector mode
nb_components = get_nb_components(proxy, entity, field_name)
check_vector_mode(vector_mode, nb_components)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create slice filter
- slice_filter = pv.Slice(proxy)
+ slice_filter = pvs.Slice(proxy)
slice_filter.SliceType = "Plane"
# Set cut planes normal
slice_filter.SliceOffsetValues = positions
# Get Cut Planes representation object
- cut_planes = pv.GetRepresentation(slice_filter)
+ cut_planes = pvs.GetRepresentation(slice_filter)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
(Cut Lines as representation object, list of 'PlotOverLine') otherwise
"""
+ proxy.UpdatePipeline()
+ if entity == EntityType.NODE:
+ select_cells_with_data(proxy, on_points=[field_name])
+ else:
+ select_cells_with_data(proxy, on_cells=[field_name])
+
# Check vector mode
nb_components = get_nb_components(proxy, entity, field_name)
check_vector_mode(vector_mode, nb_components)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create base plane
- base_plane = pv.Slice(proxy)
+ base_plane = pvs.Slice(proxy)
base_plane.SliceType = "Plane"
# Set base plane normal
base_plane = proxy
# Create cutting planes
- cut_planes = pv.Slice(base_plane)
+ cut_planes = pvs.Slice(base_plane)
cut_planes.SliceType = "Plane"
# Set cutting planes normal and get positions
point2 = [bounds[1], bounds[3], bounds[5]]
# Create plot over line filter
- pol = pv.PlotOverLine(cut_planes,
+ pol = pvs.PlotOverLine(cut_planes,
Source="High Resolution Line Source")
- pv.RenameSource('Y' + str(index), pol)
+ pvs.RenameSource('Y' + str(index), pol)
pol.Source.Point1 = point1
pol.Source.Point2 = point2
pol.UpdatePipeline()
cut_planes.UpdatePipeline()
# Get Cut Lines representation object
- cut_lines = pv.GetRepresentation(cut_planes)
+ cut_lines = pvs.GetRepresentation(cut_planes)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Cut Segment as 3D representation object.
"""
+ proxy.UpdatePipeline()
+ if entity == EntityType.NODE:
+ select_cells_with_data(proxy, on_points=[field_name])
+ else:
+ select_cells_with_data(proxy, on_cells=[field_name])
+
# Check vector mode
nb_components = get_nb_components(proxy, entity, field_name)
check_vector_mode(vector_mode, nb_components)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create plot over line filter
- pol = pv.PlotOverLine(proxy, Source="High Resolution Line Source")
+ pol = pvs.PlotOverLine(proxy, Source="High Resolution Line Source")
pol.Source.Point1 = point1
pol.Source.Point2 = point2
pol.UpdatePipeline()
# Get Cut Segment representation object
- cut_segment = pv.GetRepresentation(pol)
+ cut_segment = pvs.GetRepresentation(pol)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Vectors as representation object.
"""
+ proxy.UpdatePipeline()
+ if entity == EntityType.NODE:
+ select_cells_with_data(proxy, on_points=[field_name])
+ else:
+ select_cells_with_data(proxy, on_cells=[field_name])
+
# Check vector mode
nb_components = get_nb_components(proxy, entity, field_name)
check_vector_mode(vector_mode, nb_components)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
source = proxy
# Cell centers
if is_data_on_cells(proxy, field_name):
- cell_centers = pv.CellCenters(source)
+ cell_centers = pvs.CellCenters(source)
cell_centers.VertexCells = 1
source = cell_centers
source = calc
# Glyph
- glyph = pv.Glyph(source)
+ glyph = pvs.Glyph(source)
glyph.Vectors = vector_array
glyph.ScaleMode = 'vector'
glyph.MaskPoints = 0
glyph.UpdatePipeline()
# Get Vectors representation object
- vectors = pv.GetRepresentation(glyph)
+ vectors = pvs.GetRepresentation(glyph)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Defromed Shape as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
if entity == EntityType.NODE:
select_cells_with_data(proxy, on_points=[field_name])
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Do merge
- source = pv.MergeBlocks(proxy)
+ source = pvs.MergeBlocks(proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData()
+ cell_to_point = pvs.CellDatatoPointData()
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
warp_vector.ScaleFactor = def_scale
# Get Deformed Shape representation object
- defshape = pv.GetRepresentation(warp_vector)
+ defshape = pvs.GetRepresentation(warp_vector)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Defromed Shape And Scalar Map as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
on_points = []
on_cells = []
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Set scalar field by default
scalar_field_entity = scalar_entity
scalar_field = field_name
# Do merge
- source = pv.MergeBlocks(proxy)
+ source = pvs.MergeBlocks(proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
warp_vector.ScaleFactor = def_scale
# Get Defromed Shape And Scalar Map representation object
- defshapemap = pv.GetRepresentation(warp_vector)
+ defshapemap = pvs.GetRepresentation(warp_vector)
# Get lookup table
lookup_table = get_lookup_table(scalar_field, nb_components, vector_mode)
Plot 3D as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
if entity == EntityType.NODE:
select_cells_with_data(proxy, on_points=[field_name])
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Do merge
- merge_blocks = pv.MergeBlocks(proxy)
+ merge_blocks = pvs.MergeBlocks(proxy)
merge_blocks.UpdatePipeline()
poly_data = None
radians(angle1), radians(angle2))
# Create slice filter
- slice_filter = pv.Slice(merge_blocks)
+ slice_filter = pvs.Slice(merge_blocks)
slice_filter.SliceType = "Plane"
# Set cutting plane normal
use_normal = 0
# Geometry filter
if not poly_data or poly_data.GetDataInformation().GetNumberOfCells() == 0:
- geometry_filter = pv.GeometryFilter(merge_blocks)
+ geometry_filter = pvs.GeometryFilter(merge_blocks)
poly_data = geometry_filter
use_normal = 1 # TODO(MZN): workaround
if is_data_on_cells(poly_data, field_name):
# Cell data to point data
- cell_to_point = pv.CellDatatoPointData(poly_data)
+ cell_to_point = pvs.CellDatatoPointData(poly_data)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by scalar
- warp_scalar = pv.WarpByScalar(source)
+ warp_scalar = pvs.WarpByScalar(source)
warp_scalar.Scalars = scalars
warp_scalar.Normal = normal
warp_scalar.UseNormal = use_normal
if (is_contour):
# Contours
- contour = pv.Contour(warp_scalar)
+ contour = pvs.Contour(warp_scalar)
contour.PointMergeMethod = "Uniform Binning"
contour.ContourBy = ['POINTS', field_name]
scalar_range = get_data_range(proxy, entity,
source = contour
# Get Plot 3D representation object
- plot3d = pv.GetRepresentation(source)
+ plot3d = pvs.GetRepresentation(source)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Iso Surfaces as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
if entity == EntityType.NODE:
select_cells_with_data(proxy, on_points=[field_name])
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Do merge
- source = pv.MergeBlocks(proxy)
+ source = pvs.MergeBlocks(proxy)
# Transform cell data into point data if necessary
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Contour filter settings
- contour = pv.Contour(source)
+ contour = pvs.Contour(source)
contour.ComputeScalars = 1
contour.ContourBy = contour_by
contour.Isosurfaces = surfaces
# Get Iso Surfaces representation object
- isosurfaces = pv.GetRepresentation(contour)
+ isosurfaces = pvs.GetRepresentation(contour)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Gauss Points as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
- if entity == EntityType.NODE:
- select_cells_with_data(proxy, on_points=[field_name])
- else:
- select_cells_with_data(proxy, on_cells=[field_name])
+ on_gauss = select_cells_with_data(proxy, on_gauss=[field_name])
+ if not on_gauss:
+ if entity == EntityType.NODE:
+ select_cells_with_data(proxy, on_points=[field_name])
+ else:
+ select_cells_with_data(proxy, on_cells=[field_name])
# Check vector mode
nb_components = get_nb_components(proxy, entity, field_name)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
+ pvs.GetRenderView().ViewTime = time_value
proxy.UpdatePipeline(time=time_value)
source = proxy
- # Quadrature point arrays
- qp_arrays = proxy.QuadraturePointArrays.Available
-
# If no quadrature point array is passed, use cell centers
- if field_name in qp_arrays:
- generate_qp = pv.GenerateQuadraturePoints(source)
- generate_qp.SelectSourceArray = ['CELLS', 'ELGA_Offset']
+ if on_gauss:
+ generate_qp = pvs.GenerateQuadraturePoints(source)
+ generate_qp.QuadratureSchemeDef = ['CELLS', 'ELGA@0']
source = generate_qp
else:
# Cell centers
- cell_centers = pv.CellCenters(source)
+ cell_centers = pvs.CellCenters(source)
cell_centers.VertexCells = 1
source = cell_centers
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
source = warp_vector
# Get Gauss Points representation object
- gausspnt = pv.GetRepresentation(source)
+ gausspnt = pvs.GetRepresentation(source)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Gauss Points as representation object.
"""
+ proxy.UpdatePipeline()
+ select_cells_with_data(proxy, on_gauss=[field_name])
+
+ nb_components = get_nb_components(proxy, entity, field_name)
+
# Get time value
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
+ pvs.GetRenderView().ViewTime = time_value
proxy.UpdatePipeline(time=time_value)
# Create Gauss Points object
- source = pv.GaussPoints(proxy)
+ source = pvs.GaussPoints(proxy)
source.UpdatePipeline()
# Get Gauss Points representation object
- gausspnt = pv.GetRepresentation(source)
+ gausspnt = pvs.GetRepresentation(source)
# Get lookup table
- entity_data_info = None
- point_data_info = source.GetPointDataInformation()
- if field_name in point_data_info.keys():
- entity_data_info = point_data_info
- else:
- entity_data_info = source.GetCellDataInformation()
- nb_components = entity_data_info[field_name].GetNumberOfComponents()
-
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
# Set field range if necessary
Stream Lines as representation object.
"""
+ proxy.UpdatePipeline()
# We don't need mesh parts with no data on them
if entity == EntityType.NODE:
select_cells_with_data(proxy, on_points=[field_name])
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Do merge
- source = pv.MergeBlocks(proxy)
+ source = pvs.MergeBlocks(proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
cell_to_point.UpdatePipeline()
source = cell_to_point
source = calc
# Stream Tracer
- stream = pv.StreamTracer(source)
+ stream = pvs.StreamTracer(source)
stream.SeedType = "Point Source"
stream.Vectors = ['POINTS', vector_array]
stream.SeedType = "Point Source"
# Get Stream Lines representation object
if is_empty(stream):
return None
- streamlines = pv.GetRepresentation(stream)
+ streamlines = pvs.GetRepresentation(stream)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
Arguments:
proxy -- the pipeline object, containig data
- mesh_name -- the mesh name
- entity -- the entity type
+ mesh_name -- the full or short name of mesh field
Returns:
Submesh as representation object of the given source.
"""
- # Select all cell types
- select_all_cells(proxy)
-
- # Get subset of groups on the given entity
- subset = get_group_names(proxy, mesh_name, entity)
-
- # Select only groups of the given entity type
- proxy.Groups = subset
+ proxy.UpdatePipeline()
+ mesh_full_name = None
+ aList = mesh_name.split('/')
+ if len(aList) >= 2:
+ mesh_full_name = mesh_name
+ else:
+ mesh_full_name = find_mesh_full_name(proxy, mesh_name)
+ if not mesh_full_name:
+ raise RuntimeError, "The given mesh name was not found"
+ # Select only the given mesh
+ proxy.AllArrays = []
+ proxy.UpdatePipeline()
+ proxy.AllArrays = [mesh_full_name]
proxy.UpdatePipeline()
# Get representation object if the submesh is not empty
prs = None
if (proxy.GetDataInformation().GetNumberOfPoints() or
proxy.GetDataInformation().GetNumberOfCells()):
- prs = pv.GetRepresentation(proxy)
+ prs = pvs.GetRepresentation(proxy)
prs.ColorArrayName = ''
return prs
-def MeshOnGroup(proxy, group_name):
+def MeshOnGroup(proxy, extrGroups, group_name):
"""Creates submesh on the group.
Arguments:
proxy -- the pipeline object, containig data
group_name -- the full group name
+ extrGroups -- all extracted groups object
Returns:
Representation object of the given source with single group
selected.
"""
- # Select all cell types
- select_all_cells(proxy)
-
- # Select only the group with the given name
- one_group = [group_name]
- proxy.Groups = one_group
proxy.UpdatePipeline()
+ # Deselect all groups
+ extrGroups.AllGroups = []
+ extrGroups.UpdatePipelineInformation()
+ # Select only the group with the given name
+ extrGroups.AllGroups = [group_name]
+ extrGroups.UpdatePipelineInformation()
# Get representation object if the submesh is not empty
prs = None
# Check if the group was set
- if proxy.Groups.GetData() == one_group:
- group_entity = get_group_entity(group_name)
+ if len(extrGroups.AllGroups) == 1 and \
+ extrGroups.AllGroups[0] == group_name:
# Check if the submesh is not empty
- nb_items = 0
- if group_entity == EntityType.NODE:
- nb_items = proxy.GetDataInformation().GetNumberOfPoints()
- elif group_entity == EntityType.CELL:
- nb_items = proxy.GetDataInformation().GetNumberOfCells()
-
- if nb_items:
- prs = pv.GetRepresentation(proxy)
+ nb_points = proxy.GetDataInformation().GetNumberOfPoints()
+ nb_cells = proxy.GetDataInformation().GetNumberOfCells()
+
+ if nb_points or nb_cells:
+# prs = pvs.GetRepresentation(proxy)
+ prs = pvs.Show()
prs.ColorArrayName = ''
+ display_only(prs)
return prs
print "Import " + file_name.split(os.sep)[-1] + "..."
try:
- paravis_instance.ImportFile(file_name)
- proxy = pv.GetActiveSource()
+ proxy = pvs.MEDReader(FileName=file_name)
if proxy is None:
print "FAILED"
else:
proxy.UpdatePipeline()
+ _med_field_sep = proxy.GetProperty("Separator")
print "OK"
except:
print "FAILED"
else:
# Get view
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
# Create required presentations for the proxy
CreatePrsForProxy(proxy, view, prs_types,
picture_dir, picture_ext)
-
def CreatePrsForProxy(proxy, view, prs_types, picture_dir, picture_ext):
"""Build presentations of the given types for all fields of the proxy.
picture_ext: graphics files extension (determines file type)
"""
+ proxy.UpdatePipeline()
# List of the field names
- field_names = list(proxy.PointArrays.GetData())
- nb_on_nodes = len(field_names)
- field_names.extend(proxy.CellArrays.GetData())
+ fields_info = proxy.GetProperty("FieldsTreeInfo")[::2]
+ print fields_info
# Add path separator to the end of picture path if necessery
if not picture_dir.endswith(os.sep):
# Mesh Presentation
if PrsTypeEnum.MESH in prs_types:
- # Create Mesh presentation. Build all possible submeshes.
-
- # Remember the current state
- groups = list(proxy.Groups)
-
# Iterate on meshes
- mesh_names = get_mesh_names(proxy)
+ mesh_names = get_mesh_full_names(proxy)
for mesh_name in mesh_names:
- # Build mesh on nodes and cells
- for entity in (EntityType.NODE, EntityType.CELL):
- entity_name = EntityType.get_name(entity)
- if if_possible(proxy, mesh_name, entity, PrsTypeEnum.MESH):
- print "Creating submesh on " + entity_name + " for '" + mesh_name + "' mesh... "
- prs = MeshOnEntity(proxy, mesh_name, entity)
- if prs is None:
- print "FAILED"
- continue
- else:
- print "OK"
- # Construct image file name
- pic_name = picture_dir + mesh_name + "_" + entity_name + "." + picture_ext
-
- # Show and dump the presentation into a graphics file
- process_prs_for_test(prs, view, pic_name, False)
-
- # Build submesh on all groups of the mesh
- mesh_groups = get_group_names(proxy, mesh_name,
- entity, wo_nogroups=True)
- for group in mesh_groups:
- print "Creating submesh on group " + group + "... "
- prs = MeshOnGroup(proxy, group)
- if prs is None:
- print "FAILED"
- continue
- else:
- print "OK"
- # Construct image file name
- pic_name = picture_dir + group.replace('/', '_') + "." + picture_ext
-
- # Show and dump the presentation into a graphics file
- process_prs_for_test(prs, view, pic_name, False)
-
- # Restore the state
- proxy.Groups = groups
- proxy.UpdatePipeline()
+ # Build mesh field presentation
+ print "Creating submesh for '" + get_field_short_name(mesh_name) + "' mesh... "
+ prs = MeshOnEntity(proxy, mesh_name, None)
+ if prs is None:
+ print "FAILED"
+ continue
+ else:
+ print "OK"
+ # Construct image file name
+ pic_name = picture_dir + get_field_short_name(mesh_name) + "." + picture_ext
+
+ # Show and dump the presentation into a graphics file
+ process_prs_for_test(prs, view, pic_name, False)
+
+ # Create Mesh presentation. Build all groups.
+ extGrp = pvs.ExtractGroup()
+ extGrp.UpdatePipelineInformation()
+ if if_possible(proxy, None, None, PrsTypeEnum.MESH, extGrp):
+ for group in get_group_names(extGrp):
+ print "Creating submesh on group " + get_group_short_name(group) + "... "
+ prs = MeshOnGroup(proxy, extGrp, group)
+ if prs is None:
+ print "FAILED"
+ continue
+ else:
+ print "OK"
+ # Construct image file name
+ pic_name = picture_dir + get_group_short_name(group) + "." + picture_ext
+
+ # Show and dump the presentation into a graphics file
+ process_prs_for_test(prs, view, pic_name, False)
# Presentations on fields
- for (i, field_name) in enumerate(field_names):
+ for field in fields_info:
+ field_name = get_field_short_name(field)
+ # Ignore mesh presentation
+ if field_name == get_field_mesh_name(field):
+ continue
+ field_entity = get_field_entity(field)
+ # Clear fields selection state
+ proxy.AllArrays = []
+ proxy.UpdatePipeline()
# Select only the current field:
# necessary for getting the right timestamps
- cell_arrays = proxy.CellArrays.GetData()
- point_arrays = proxy.PointArrays.GetData()
- field_entity = None
- if (i >= nb_on_nodes):
- field_entity = EntityType.CELL
- proxy.PointArrays.DeselectAll()
- proxy.CellArrays = [field_name]
- else:
- field_entity = EntityType.NODE
- proxy.CellArrays.DeselectAll()
- proxy.PointArrays = [field_name]
+ proxy.AllArrays = field
+ proxy.UpdatePipeline()
# Get timestamps
- proxy.UpdatePipelineInformation()
+ entity_data_info = proxy.GetCellDataInformation()
timestamps = proxy.TimestepValues.GetData()
- # Restore fields selection state
- proxy.CellArrays = cell_arrays
- proxy.PointArrays = point_arrays
- proxy.UpdatePipelineInformation()
-
for prs_type in prs_types:
# Ignore mesh presentation
if prs_type == PrsTypeEnum.MESH:
# Show and dump the presentation into a graphics file
process_prs_for_test(prs, view, pic_name)
+ return
from math import sqrt, sin, cos, radians
from string import upper
-import pvsimple as pv
+# Do not use pv as a short name.
+# It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call.
+# import pvsimple as pv
+import pvsimple as pvs
#try:
# # TODO(MZN): to be removed (issue with Point Sprite texture)
# #import paravisSM as sm
#except:
-# import paraview.simple as pv
+# import paraview.simple as pvs
# import paraview.servermanager as sm
os.makedirs(pic_dir)
# Save picture
- pv.WriteImage(file_name, view=view, Magnification=1)
+ pvs.WriteImage(file_name, view=view, Magnification=1)
def reset_view(view=None):
"""
if not view:
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
# Camera preferences
view.CameraFocalPoint = [0.0, 0.0, 0.0]
view.CameraParallelProjection = 1
view.ResetCamera()
- pv.Render(view=view)
+ pvs.Render(view=view)
def hide_all(view, to_remove=False):
"""Hide all representations in the view."""
if not view:
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
rep_list = view.Representations
for rep in rep_list:
rep.Visibility = 0
if to_remove:
view.Representations.remove(rep)
- pv.Render(view=view)
+ pvs.Render(view=view)
def display_only(prs, view=None):
hide_all(view)
if (hasattr(prs, 'Visibility') and prs.Visibility != 1):
prs.Visibility = 1
- pv.Render(view=view)
+ pvs.Render(view=view)
def set_visible_lines(xy_prs, lines):
# Transform vector array to scalar array if possible
nb_components = get_nb_components(proxy, array_entity, array_name)
if (nb_components > 1):
- calculator = pv.Calculator(proxy)
+ calculator = pvs.Calculator(proxy)
attribute_mode = "Point Data"
if array_entity != EntityType.NODE:
attribute_mode = "Cell Data"
nb_components = get_nb_components(proxy, array_entity, array_name)
if nb_components == 2:
- calculator = pv.Calculator(proxy)
+ calculator = pvs.Calculator(proxy)
attribute_mode = "Point Data"
if array_entity != EntityType.NODE:
attribute_mode = "Cell Data"
# Extract groups if necessary
if force or (len(groups_to_extract) < len(initial_groups)):
- extract_group = pv.ExtractGroup(proxy)
+ extract_group = pvs.ExtractGroup(proxy)
extract_group.Groups = groups_to_extract
extract_group.UpdatePipeline()
source = extract_group
title = "\n".join([title, vector_mode])
# Create scalar bar
- scalar_bar = pv.CreateScalarBar(Enabled=1)
+ scalar_bar = pvs.CreateScalarBar(Enabled=1)
scalar_bar.Orientation = 'Vertical'
scalar_bar.Title = title
scalar_bar.LookupTable = lookup_table
scalar_bar.LabelShadow = 1
# Add the scalar bar to the view
- pv.GetRenderView().Representations.append(scalar_bar)
+ pvs.GetRenderView().Representations.append(scalar_bar)
# Reassign the current bar
_current_bar = scalar_bar
def get_lookup_table(field_name, nb_components, vector_mode='Magnitude'):
"""Get lookup table for the given field."""
- lookup_table = pv.GetLookupTableForArray(field_name, nb_components)
+ lookup_table = pvs.GetLookupTableForArray(field_name, nb_components)
if vector_mode == 'Magnitude':
lookup_table.VectorMode = vector_mode
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity,
force=True)
# Get Scalar Map representation object
- scalarmap = pv.GetRepresentation(new_proxy)
+ scalarmap = pvs.GetRepresentation(new_proxy)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create slice filter
- slice_filter = pv.Slice(proxy)
+ slice_filter = pvs.Slice(proxy)
slice_filter.SliceType = "Plane"
# Set cut planes normal
slice_filter.SliceOffsetValues = positions
# Get Cut Planes representation object
- cut_planes = pv.GetRepresentation(slice_filter)
+ cut_planes = pvs.GetRepresentation(slice_filter)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create base plane
- base_plane = pv.Slice(proxy)
+ base_plane = pvs.Slice(proxy)
base_plane.SliceType = "Plane"
# Set base plane normal
base_plane = proxy
# Create cutting planes
- cut_planes = pv.Slice(base_plane)
+ cut_planes = pvs.Slice(base_plane)
cut_planes.SliceType = "Plane"
# Set cutting planes normal and get positions
point2 = [bounds[1], bounds[3], bounds[5]]
# Create plot over line filter
- pol = pv.PlotOverLine(cut_planes,
+ pol = pvs.PlotOverLine(cut_planes,
Source="High Resolution Line Source")
- pv.RenameSource('Y' + str(index), pol)
+ pvs.RenameSource('Y' + str(index), pol)
pol.Source.Point1 = point1
pol.Source.Point2 = point2
pol.UpdatePipeline()
cut_planes.UpdatePipeline()
# Get Cut Lines representation object
- cut_lines = pv.GetRepresentation(cut_planes)
+ cut_lines = pvs.GetRepresentation(cut_planes)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Create plot over line filter
- pol = pv.PlotOverLine(proxy, Source="High Resolution Line Source")
+ pol = pvs.PlotOverLine(proxy, Source="High Resolution Line Source")
pol.Source.Point1 = point1
pol.Source.Point2 = point2
pol.UpdatePipeline()
# Get Cut Segment representation object
- cut_segment = pv.GetRepresentation(pol)
+ cut_segment = pvs.GetRepresentation(pol)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Cell centers
if is_data_on_cells(proxy, field_name):
- cell_centers = pv.CellCenters(source)
+ cell_centers = pvs.CellCenters(source)
cell_centers.VertexCells = 1
source = cell_centers
source = calc
# Glyph
- glyph = pv.Glyph(source)
+ glyph = pvs.Glyph(source)
glyph.Vectors = vector_array
glyph.ScaleMode = 'vector'
glyph.MaskPoints = 0
glyph.UpdatePipeline()
# Get Vectors representation object
- vectors = pv.GetRepresentation(glyph)
+ vectors = pvs.GetRepresentation(glyph)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Do merge
- source = pv.MergeBlocks(new_proxy)
+ source = pvs.MergeBlocks(new_proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData()
+ cell_to_point = pvs.CellDatatoPointData()
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
warp_vector.ScaleFactor = def_scale
# Get Deformed Shape representation object
- defshape = pv.GetRepresentation(warp_vector)
+ defshape = pvs.GetRepresentation(warp_vector)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Set scalar field by default
scalar_field_entity = scalar_entity
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Do merge
- source = pv.MergeBlocks(new_proxy)
+ source = pvs.MergeBlocks(new_proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
warp_vector.ScaleFactor = def_scale
# Get Defromed Shape And Scalar Map representation object
- defshapemap = pv.GetRepresentation(warp_vector)
+ defshapemap = pvs.GetRepresentation(warp_vector)
# Get lookup table
lookup_table = get_lookup_table(scalar_field, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Do merge
- merge_blocks = pv.MergeBlocks(new_proxy)
+ merge_blocks = pvs.MergeBlocks(new_proxy)
merge_blocks.UpdatePipeline()
poly_data = None
radians(angle1), radians(angle2))
# Create slice filter
- slice_filter = pv.Slice(merge_blocks)
+ slice_filter = pvs.Slice(merge_blocks)
slice_filter.SliceType = "Plane"
# Set cutting plane normal
use_normal = 0
# Geometry filter
if not poly_data or poly_data.GetDataInformation().GetNumberOfCells() == 0:
- geometry_filter = pv.GeometryFilter(merge_blocks)
+ geometry_filter = pvs.GeometryFilter(merge_blocks)
poly_data = geometry_filter
use_normal = 1 # TODO(MZN): workaround
if is_data_on_cells(poly_data, field_name):
# Cell data to point data
- cell_to_point = pv.CellDatatoPointData(poly_data)
+ cell_to_point = pvs.CellDatatoPointData(poly_data)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Warp by scalar
- warp_scalar = pv.WarpByScalar(source)
+ warp_scalar = pvs.WarpByScalar(source)
warp_scalar.Scalars = scalars
warp_scalar.Normal = normal
warp_scalar.UseNormal = use_normal
if (is_contour):
# Contours
- contour = pv.Contour(warp_scalar)
+ contour = pvs.Contour(warp_scalar)
contour.PointMergeMethod = "Uniform Binning"
contour.ContourBy = ['POINTS', field_name]
scalar_range = get_data_range(proxy, entity,
source = contour
# Get Plot 3D representation object
- plot3d = pv.GetRepresentation(source)
+ plot3d = pvs.GetRepresentation(source)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Do merge
- source = pv.MergeBlocks(new_proxy)
+ source = pvs.MergeBlocks(new_proxy)
# Transform cell data into point data if necessary
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
source = cell_to_point
source = calc
# Contour filter settings
- contour = pv.Contour(source)
+ contour = pvs.Contour(source)
contour.ComputeScalars = 1
contour.ContourBy = contour_by
contour.Isosurfaces = surfaces
# Get Iso Surfaces representation object
- isosurfaces = pv.GetRepresentation(contour)
+ isosurfaces = pvs.GetRepresentation(contour)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
+ pvs.GetRenderView().ViewTime = time_value
proxy.UpdatePipeline(time=time_value)
# Extract only groups with data for the field
# If no quadrature point array is passed, use cell centers
if field_name in qp_arrays:
- generate_qp = pv.GenerateQuadraturePoints(source)
+ generate_qp = pvs.GenerateQuadraturePoints(source)
generate_qp.SelectSourceArray = ['CELLS', 'ELGA_Offset']
source = generate_qp
else:
# Cell centers
- cell_centers = pv.CellCenters(source)
+ cell_centers = pvs.CellCenters(source)
cell_centers.VertexCells = 1
source = cell_centers
source = calc
# Warp by vector
- warp_vector = pv.WarpByVector(source)
+ warp_vector = pvs.WarpByVector(source)
warp_vector.Vectors = [vector_array]
if scale_factor is not None:
warp_vector.ScaleFactor = scale_factor
source = warp_vector
# Get Gauss Points representation object
- gausspnt = pv.GetRepresentation(source)
+ gausspnt = pvs.GetRepresentation(source)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
+ pvs.GetRenderView().ViewTime = time_value
proxy.UpdatePipeline(time=time_value)
# Create Gauss Points object
- source = pv.GaussPoints(proxy)
+ source = pvs.GaussPoints(proxy)
source.UpdatePipeline()
# Get Gauss Points representation object
- gausspnt = pv.GetRepresentation(source)
+ gausspnt = pvs.GetRepresentation(source)
# Get lookup table
entity_data_info = None
time_value = get_time(proxy, timestamp_nb)
# Set timestamp
- pv.GetRenderView().ViewTime = time_value
- pv.UpdatePipeline(time_value, proxy)
+ pvs.GetRenderView().ViewTime = time_value
+ pvs.UpdatePipeline(time_value, proxy)
# Extract only groups with data for the field
new_proxy = extract_groups_for_field(proxy, field_name, entity)
# Do merge
- source = pv.MergeBlocks(new_proxy)
+ source = pvs.MergeBlocks(new_proxy)
# Cell data to point data
if is_data_on_cells(proxy, field_name):
- cell_to_point = pv.CellDatatoPointData(source)
+ cell_to_point = pvs.CellDatatoPointData(source)
cell_to_point.PassCellData = 1
cell_to_point.UpdatePipeline()
source = cell_to_point
source = calc
# Stream Tracer
- stream = pv.StreamTracer(source)
+ stream = pvs.StreamTracer(source)
stream.SeedType = "Point Source"
stream.Vectors = ['POINTS', vector_array]
stream.SeedType = "Point Source"
# Get Stream Lines representation object
if is_empty(stream):
return None
- streamlines = pv.GetRepresentation(stream)
+ streamlines = pvs.GetRepresentation(stream)
# Get lookup table
lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
prs = None
if (proxy.GetDataInformation().GetNumberOfPoints() or
proxy.GetDataInformation().GetNumberOfCells()):
- prs = pv.GetRepresentation(proxy)
+ prs = pvs.GetRepresentation(proxy)
prs.ColorArrayName = ''
return prs
nb_items = proxy.GetDataInformation().GetNumberOfCells()
if nb_items:
- prs = pv.GetRepresentation(proxy)
+ prs = pvs.GetRepresentation(proxy)
prs.ColorArrayName = ''
return prs
try:
paravis_instance.ImportFile(file_name)
- proxy = pv.GetActiveSource()
+ proxy = pvs.GetActiveSource()
if proxy is None:
print "FAILED"
else:
print "FAILED"
else:
# Get view
- view = pv.GetRenderView()
+ view = pvs.GetRenderView()
# Create required presentations for the proxy
CreatePrsForProxy(proxy, view, prs_types,
INCLUDE(SalomeMEDConfig)
FIND_PACKAGE(SalomePython REQUIRED)
FIND_PACKAGE(SalomeHDF5 REQUIRED)
+FIND_PACKAGE(SalomeMED REQUIRED)
FIND_PACKAGE(SalomeMEDFile REQUIRED)
+# Accumulate environment variables for PARAVIS module
+SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_BINS}
+ ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON})
+SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS})
+
#
# process all vtk-modules defined in this plugin. This generates the necessary
# wrappings for all these modules as well.
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+SALOME_GENERATE_TESTS_ENVIRONMENT(tests_env)
ADD_TEST(testMEDReader0 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader0.py)
+SET_TESTS_PROPERTIES(testMEDReader0 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader1 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader1.py)
+SET_TESTS_PROPERTIES(testMEDReader1 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader2 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader2.py)
+SET_TESTS_PROPERTIES(testMEDReader2 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader3 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader3.py)
+SET_TESTS_PROPERTIES(testMEDReader3 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader4 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader4.py)
+SET_TESTS_PROPERTIES(testMEDReader4 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader5 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader5.py)
+SET_TESTS_PROPERTIES(testMEDReader5 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader6 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader6.py)
+SET_TESTS_PROPERTIES(testMEDReader6 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader7 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader7.py)
+SET_TESTS_PROPERTIES(testMEDReader7 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader8 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader8.py)
+SET_TESTS_PROPERTIES(testMEDReader8 PROPERTIES ENVIRONMENT "${tests_env}")
ADD_TEST(testMEDReader9 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader9.py)
+SET_TESTS_PROPERTIES(testMEDReader9 PROPERTIES ENVIRONMENT "${tests_env}")
print "Chart title for xyplot ...", aXYPlot.ChartTitle
error = 0
-try:
- aXYPlot.ShowAxis = [1, 1, 0, 0]
-except:
- print "Error: ShowAxis property is not avaliable for XYPlotView"
- error = error + 1
aXYPlot.AxisUseCustomRange = [1, 1, 0, 0]
error = error + test_values(Ranges, Etvalue[0:2])
Ranges=aXYPlot.BottomAxisRange
error = error + test_values(Ranges, Etvalue[2:4])
-
-try:
- aXYPlot.ShowAxis = [1, 1, 1, 1]
-except:
- print "Error: ShowAxis property is not avaliable for XYPlotView"
- error = error + 1
-
aXYPlot.AxisUseCustomRange = [1, 1, 1, 1]
# Left, bottom, right and top axis range
aXYPlot.LeftAxisRange = [0, 200]
my_view = GetRenderView()
print "\nCreating plot3d.......",
-plot3d = Plot3DOnField(proxy, EntityType.CELL, field_name, 1)
+plot3d = Plot3DOnField(proxy, EntityType.NODE, field_name, 1)
if plot3d is None:
raise RuntimeError("Error!!! Presentation wasn't created...")
linewidths = [1.0, 3.0, 10.0]
compare_prec = 0.00001
-field_name = 'vectoriel_field'
+field_name = 'vectoriel field'
print "\nCreating Vectors.......",
vectors = VectorsOnField(proxy, EntityType.CELL, field_name, 1,
linewidths = [1.0, 3.0, 10.0]
compare_prec = 0.00001
-field_name = 'vectoriel_field'
+field_name = 'vectoriel field'
print "\nCreating stream_lines......."
stream_lines = StreamLinesOnField(proxy, EntityType.CELL,
linewidths = [1.0, 3.0, 10.0]
compare_prec = 0.00001
-field_name = 'scalar_field'
+field_name = 'scalar field'
print "\nCreating cut planes.......",
cut_planes = CutPlanesOnField(proxy, EntityType.CELL, field_name, 1,
linewidths = [1.0, 3.0, 10.0]
compare_prec = 0.00001
-field_name = 'scalar_field'
+field_name = 'scalar field'
print "\nCreating cut lines.......",
cut_lines = CutLinesOnField(proxy, EntityType.CELL, field_name, 1,
field_name = 'VITESSE'
print "\nCreating scalar map.......",
-scalar_map = ScalarMapOnField(proxy, EntityType.CELL, field_name, 1)
+scalar_map = ScalarMapOnField(proxy, EntityType.NODE, field_name, 1)
if scalar_map is None:
raise RuntimeError("Error!!! Presentation wasn't created...")
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"A0_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"A2_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"A4_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"A7_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"A8_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"B2_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"B5_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"B6_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"C0_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"C1_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"C3_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"C8_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"D1_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"D2_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"D6_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"D9_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"E0_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"E4_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.PointArrays.DeselectAll()
-aProxy.CellArrays.DeselectAll()
-aProxy.CellArrays = ['pression']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/pression@@][@@P0']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"E8_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"F2_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"F5_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"F6_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"G0_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"G3_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"G3_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"G8_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"H1_dom."+my_format)
picturedir += os.sep
# Select only the current field:
-aProxy.CellArrays.DeselectAll()
-aProxy.PointArrays.DeselectAll()
-aProxy.PointArrays = ['vitesse']
+aProxy.AllArrays = []
+aProxy.UpdatePipeline()
+aProxy.AllArrays = ['TS0/dom/ComSup0/vitesse@@][@@P1']
+aProxy.UpdatePipeline()
# Animation creation and saving into set of files into picturedir
scene = AnimateReader(aProxy,aView,picturedir+"H2_dom."+my_format)
# Create required presentations for the proxy
# CreatePrsForProxy(aProxy, aView, thePrsTypeList, thePictureDir, thePictureExt, theIsAutoDelete)
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#create Cut Lines presentations for 10 timestamps
for i in range(1,11):
# Create required presentations for the proxy
# CreatePrsForProxy(aProxy, aView, thePrsTypeList, thePictureDir, thePictureExt, theIsAutoDelete)
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#create Cut Planes presentations for 10 timestamps
for i in range(1,11):
print "Creating Deformed Shape...............",
cell_entity = EntityType.CELL
-field_name = 'vectoriel_field'
+field_name = 'vectoriel field'
defshape = DeformedShapeOnField(med_reader, cell_entity, field_name, 1)
pvsimple.ResetCamera()
print "Creating Deformed Shape...............",
cell_entity = EntityType.CELL
-field_name = 'vectoriel_field'
+field_name = 'vectoriel field'
defshape = DeformedShapeOnField(med_reader, cell_entity, field_name, 1)
pvsimple.ResetCamera()
# Create required presentations for the proxy
# CreatePrsForProxy(aProxy, aView, thePrsTypeList, thePictureDir, thePictureExt, theIsAutoDelete)
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#Creation of a set of non-colored and then colored Deformed Shapes, based on time stamps of MODES_DEP field
for colored in [False,True]:
# MED file
file_name = datadir + "hexa_28320_ELEM.med"
field_name = "pression_elem_dom_pb1"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "pointe.med"
-field_name = "fieldcelldouble"
-timestamp_nb = 1
+field_name = "fieldcelldoublescalar"
+#field_name = "fieldcelldoublevector"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Fields_group3D.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Hexa8.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Penta6.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Tetra4.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Tria3.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "Quad4.med"
-field_name = "scalar_field"
-timestamp_nb = 1
+field_name = "scalar field"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "carre_en_quad4_seg2_fields.med"
field_name = "AREA"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "cube_hexa8_quad4.med"
field_name = "fieldcelldouble"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "test_55_solid_concentr_dom.med"
field_name = "RN_precipite_restr"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "H_COUPLEX1.med"
field_name = "Head"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "cas2_2d_couplage_chess_castem.med"
field_name = "pH"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "champc.med"
field_name = "Am241_restriction"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "hydro_sea_alv.med"
field_name = "Head"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "toto.med"
field_name = "erreur"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "couplex_alain.med"
-field_name = "Conc._I129"
-timestamp_nb = 1
+field_name = "Conc. I129"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "KCOUPLEX1.med"
field_name = "Head"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "test_hydro.med"
field_name = "Head"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "ml.med"
field_name = "head_restriction"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "T_COUPLEX1.med"
-field_name = "Conc._I129"
-timestamp_nb = 1
+field_name = "Conc. I129"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "test_hydro_darcy4_out.med"
field_name = "DarcyVelocity"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "UO2_250ans.med"
-field_name = "Concentration_O2(aq)_mol_per_l"
-timestamp_nb = 1
+field_name = "Concentration_O2(aq)_mol per l"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "homard_ASTER_OSF_MEDV2.1.5_1_v2.3.med"
-field_names = ["REMEUN_ERRE_ELGA_NORE", "REMEZEROERRE_ELGA_NORE"]
-timestamp_nb = 1
+field_names = ["REMEUN__ERRE_ELGA_NORE__________", "REMEZEROERRE_ELGA_NORE__________"]
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "occ4050.med"
field_name = "champ_reel"
-timestamp_nb = 1
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "homard_ASTER_OSF_MEDV2.1.5_1_v2.1.med"
-field_names = ["REMEUN_ERRE_ELGA_NORE", "REMEZEROERRE_ELGA_NORE"]
-timestamp_nb = 1
+field_names = ["REMEUN__ERRE_ELGA_NORE__________", "REMEZEROERRE_ELGA_NORE__________"]
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# MED file
file_name = datadir + "homard_ASTER_OSF_MEDV2.1.5_1_v2.2.med"
-field_names = ["REMEUN_ERRE_ELGA_NORE", "REMEZEROERRE_ELGA_NORE"]
-timestamp_nb = 1
+field_names = ["REMEUN__ERRE_ELGA_NORE__________", "REMEZEROERRE_ELGA_NORE__________"]
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# Directory for saving snapshots
-picturedir = get_picture_dir(sys.argv[1], "GaussPoints/C8")
+picturedir = get_picture_dir("GaussPoints/C8")
if not picturedir.endswith(os.sep):
picturedir += os.sep
# MED file
file_name = datadir + "ir.resu.med"
-field_name = "gravit_VARI_ELGA"
-timestamp_nb = 1
+field_name = "gravit__VARI_ELGA"
+#timestamp_nb = 1
+timestamp_nb = 6 # timestamp 1 is empty
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# Directory for saving snapshots
-picturedir = get_picture_dir(sys.argv[1], "GaussPoints/C9")
+picturedir = get_picture_dir("GaussPoints/C9")
if not picturedir.endswith(os.sep):
picturedir += os.sep
# MED file
file_name = datadir + "petit.rmed"
-field_name = "RESPIL_SIEF_ELGA"
-timestamp_nb = 1
+field_name = "RESPIL__SIEF_ELGA"
+timestamp_nb = -1 # last timestamp
paravis.myParavis.ImportFile(file_name)
med_reader = pvsimple.GetActiveSource()
# Create required presentations for the proxy
# CreatePrsForProxy(aProxy, aView, thePrsTypeList, thePictureDir, thePictureExt, theIsAutoDelete)
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#create Iso Surfaces presentations for 10 timestamps
for i in range(1,11):
- hide_all(aView, True)
+ #hide_all(aView, True)
aPrs = IsoSurfacesOnField(aProxy, aFieldEntity,aFieldName , i)
if aPrs is None:
raise RuntimeError, "Presentation is None!!!"
#display only current scalar map
- aPrs.Visibility=1
+ display_only(aPrs, aView)
reset_view(aView)
Render(aView)
# Get viewScalarMap
aView = GetRenderView()
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#create Plot 3D presentations for 10 timestamps
for i in range(1,11):
print "**** Stage4: Displaying scalar field"
print "Creating Scalar Map.......",
-scalarmap1 = ScalarMapOnField(med_reader1, cell_entity, 'scalar_field', 1)
+scalarmap1 = ScalarMapOnField(med_reader1, cell_entity, 'scalar field', 1)
if scalarmap1 is None:
print "FAILED"
else:
view.ResetCamera()
print "Creating Iso Surfaces.....",
-isosurfaces1 = IsoSurfacesOnField(med_reader1, cell_entity, 'scalar_field', 1)
+isosurfaces1 = IsoSurfacesOnField(med_reader1, cell_entity, 'scalar field', 1)
if isosurfaces1 is None:
print "FAILED"
else:
print "OK"
print "Creating Cut Planes.......",
-cutplanes1 = CutPlanesOnField(med_reader1, cell_entity, 'scalar_field', 1,
+cutplanes1 = CutPlanesOnField(med_reader1, cell_entity, 'scalar field', 1,
orientation=Orientation.YZ)
if cutplanes1 is None:
print "FAILED"
print "Creating Scalar Map On Deformed Shape.......",
scalarmapondefshape1 = DeformedShapeAndScalarMapOnField(med_reader1,
cell_entity,
- 'vectoriel_field', 1)
+ 'vectoriel field', 1)
if scalarmapondefshape1 is None:
print "FAILED"
else:
# This case corresponds to: /visu/SWIG_scripts/A8 case
# Create table
-import paraview.simple as pv
+# Do not use pv as a short name.
+# It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call.
+# import paraview.simple as pv
+import paraview.simple as pvs
import paraview.servermanager as sm
"""
# Creating programmable source (table)
-ps = pv.ProgrammableSource()
+ps = pvs.ProgrammableSource()
ps.OutputDataSetType = 'vtkTable'
ps.Script = script
-pv.RenameSource("Very useful data", ps)
+pvs.RenameSource("Very useful data", ps)
ps.UpdatePipeline()
tablesdir = samples_dir + "/Tables/"
# Get view
-view = pv.GetRenderView()
+view = pvs.GetRenderView()
sleep(DELAY)
# Destroy the view
-pv.Delete(view)
+pvs.Delete(view)
# Create view and set background
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
color = [0, 0.3, 1]
view.Background = color
-pv.Render()
+pvs.Render()
# Load MED reader plugin
pv_root_dir = os.getenv("PARAVIS_ROOT_DIR")
-pv.LoadPlugin(pv_root_dir + "/lib/paraview/libMedReaderPlugin.so")
+pvs.LoadPlugin(pv_root_dir + "/lib/paraview/libMedReaderPlugin.so")
# Import MED file
med_file = datadir + "pointe.med"
entity = EntityType.NODE
timestamp = 1
-med_reader = pv.MEDReader(FileName=med_file)
+med_reader = pvs.MEDReader(FileName=med_file)
med_reader.UpdatePipeline()
# Create scalar map
scalarmap = ScalarMapOnField(med_reader, entity, field_name, timestamp)
-pv.Show(scalarmap.Input)
+pvs.Show(scalarmap.Input)
# Set view properties
print "view.CameraFocalPoint = [0, 0, 0]"
view.CameraFocalPoint = [0, 0, 0]
print "view.CameraParallelScale = 2"
view.CameraParallelScale = 2
-print "pv.ResetCamera(view)"
-pv.ResetCamera(view)
+print "pvs.ResetCamera(view)"
+pvs.ResetCamera(view)
# Play with scalar bar
bar = get_bar()
y = range_max - delta * i / nb_colors
lt.RGBPoints[0] = x
lt.RGBPoints[4] = y
- pv.Render(view)
+ pvs.Render(view)
sleep(DELAY / 4.0)
lt.RGBPoints[0] = range_min
lt.RGBPoints[4] = range_max
-print "pv.ResetCamera(view)"
-pv.ResetCamera(view)
+print "pvs.ResetCamera(view)"
+pvs.ResetCamera(view)
# Create another view for cut planes
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
color = [0, 0.7, 0]
view.Background = color
-pv.Render(view)
+pvs.Render(view)
displacement = 0.5
orient = Orientation.YZ
print "Set view.CameraPosition"
cutplanes.Scale[0] = 3
cutplanes.Scale[1] = 10
-pv.Render(view)
+pvs.Render(view)
sleep(DELAY)
-pv.ResetCamera(view)
+pvs.ResetCamera(view)
slice_filter = cutplanes.Input
offset_vals = slice_filter.SliceOffsetValues
slice_filter.SliceType.Normal = normal
pos = get_positions(i, normal, bounds, displacement)
slice_filter.SliceOffsetValues = pos
- pv.Render(view)
+ pvs.Render(view)
sleep(DELAY)
nb_planes = 10
for i in xrange(1, nb_planes):
pos = get_positions(i, normal, bounds, displacement)
slice_filter.SliceOffsetValues = pos
- pv.Render(view)
+ pvs.Render(view)
sleep(DELAY)
slice_filter.SliceType.Normal = [0, 0, 1]
slice_filter.UpdatePipeline()
-print "pv.ResetCamera(view)"
-pv.ResetCamera(view)
+print "pvs.ResetCamera(view)"
+pvs.ResetCamera(view)
# Create one more view for iso surfaces
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
color = [1, 0.7, 0]
view.Background = color
-pv.Render(view)
+pvs.Render(view)
sleep(DELAY)
isosurf = IsoSurfacesOnField(med_reader, entity, field_name, timestamp)
display_only(isosurf, view)
-pv.ResetCamera(view)
+pvs.ResetCamera(view)
print "display_only(isosurf, view)"
sleep(DELAY)
for i in xrange(2, nb_surfaces):
contours = get_contours(scalar_range, i)
contour.Isosurfaces = contours
- pv.Render(view)
+ pvs.Render(view)
sleep(DELAY)
contour.Isosurfaces = get_contours(scalar_range, 10)
contour.UpdatePipeline()
-print "pv.ResetCamera(view)"
-pv.ResetCamera(view)
+print "pvs.ResetCamera(view)"
+pvs.ResetCamera(view)
# Create one more view for cut lines
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
color = [0.7, 0.7, 0.7]
view.Background = color
-pv.Render(view)
+pvs.Render(view)
sleep(DELAY)
cutlines, curves = CutLinesOnField(med_reader, entity, field_name, timestamp,
generate_curves=True)
print "CutLinesOnField(...)"
display_only(cutlines, view)
-pv.ResetCamera(view)
+pvs.ResetCamera(view)
print "display_only(cutlines, view)"
sleep(DELAY)
-xy_view = pv.CreateXYPlotView()
-print "pv.CreateXYPlotView()"
+xy_view = pvs.CreateXYPlotView()
+print "pvs.CreateXYPlotView()"
index = 0
for curve in curves:
- xyrep = pv.Show(curve, xy_view)
+ xyrep = pvs.Show(curve, xy_view)
xyrep.AttributeType = 'Point Data'
xyrep.UseIndexForXAxis = 0
xyrep.XArrayName = 'arc_length'
- pv.Render(xy_view)
+ pvs.Render(xy_view)
set_visible_lines(xyrep, [field_name])
xyrep.SeriesLabel = [field_name, 'Y' + str(index)]
r = str(random.random())
xyrep.SeriesColor = [field_name, r, g, b]
index += 1
-pv.Render(xy_view)
+pvs.Render(xy_view)
sleep(DELAY)
# Create one more view for cut segment
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
color = [0.0, 0.7, 0.3]
view.Background = color
-pv.Render(view)
+pvs.Render(view)
sleep(DELAY)
point1 = [0.0, -1.0, 2.5]
point1, point2)
print "CutSegmentOnField(...)"
display_only(cutsegment, view)
-pv.ResetCamera(view)
+pvs.ResetCamera(view)
print "display_only(cutsegment, view)"
sleep(DELAY)
-xy_view = pv.CreateXYPlotView()
-curve = pv.Show(cutsegment.Input, xy_view)
+xy_view = pvs.CreateXYPlotView()
+curve = pvs.Show(cutsegment.Input, xy_view)
curve.AttributeType = 'Point Data'
curve.UseIndexForXAxis = 0
curve.XArrayName = 'arc_length'
set_visible_lines(xyrep, [field_name])
-pv.Render(xy_view)
+pvs.Render(xy_view)
sleep(DELAY)
# Create one more view for animation
-view = pv.CreateRenderView()
+view = pvs.CreateRenderView()
reset_view(view)
med_file = datadir + "TimeStamps.med"
entity = EntityType.NODE
timestamp = 2
-med_reader = pv.MEDReader(FileName=med_file)
+med_reader = pvs.MEDReader(FileName=med_file)
isosurf = IsoSurfacesOnField(med_reader, entity, field_name, timestamp)
-pv.ResetCamera(view)
+pvs.ResetCamera(view)
print "Start Animation"
-pv.AnimateReader(med_reader, view)
+pvs.AnimateReader(med_reader, view)
# This case corresponds to: /visu/SWIG_scripts/C3 case
# Create table and display curves
-import paraview.simple as pv
+# Do not use pv as a short name.
+# It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call.
+# import paraview.simple as pv
+import paraview.simple as pvs
import paraview.servermanager as sm
"""
# Creating programmable source (table)
-ps = pv.ProgrammableSource()
+ps = pvs.ProgrammableSource()
ps.OutputDataSetType = 'vtkTable'
ps.Script = script
-pv.RenameSource("Very useful data", ps)
+pvs.RenameSource("Very useful data", ps)
ps.UpdatePipeline()
# Display table
# TODO: no possibility to create spreadsheet view
# Display curves
-xy_view = pv.CreateXYPlotView()
+xy_view = pvs.CreateXYPlotView()
xy_view.ChartTitle = 'Very useful data'
xy_view.AxisTitle = ['[ Wt ]', 'Frequency [ Hz ]']
-xy_rep = pv.Show(ps)
+xy_rep = pvs.Show(ps)
xy_rep.AttributeType = 'Row Data'
xy_rep.UseIndexForXAxis = 0
xy_rep.XArrayName = 'Frequency'
xy_rep.SeriesVisibility = ['Frequency', '0']
-pv.Render(xy_view)
+pvs.Render(xy_view)
# Hide legend
xy_view.ShowLegend = 0
-pv.Render(xy_view)
+pvs.Render(xy_view)
# Set logarithmic scaling for X axis
xy_view.AxisLogScale[1] = 1
-pv.Render(xy_view)
+pvs.Render(xy_view)
# Set linear scaling for X axis
xy_view.AxisLogScale[1] = 0
-pv.Render(xy_view)
+pvs.Render(xy_view)
# Set logarithmic scaling for X axis
xy_view.AxisLogScale[0] = 1
-pv.Render(xy_view)
+pvs.Render(xy_view)
# Show legend
xy_view.ShowLegend = 1
-pv.Render(xy_view)
+pvs.Render(xy_view)
aView = GetRenderView()
-field_names = proxy.PointArrays.GetData()
-aTimeStamps = proxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#create list to store picture files sizes
sizes=[]
#create Scalar Map presentations for 10 timestamps
# import MED file
paravis.ImportFile(file)
- proxy = presentations.pv.GetActiveSource()
+ proxy = presentations.pvs.GetActiveSource()
if proxy is None:
raise RuntimeError, "ERROR!!! Can't import file!!!"
# Create required presentations for the proxy
# CreatePrsForProxy(aProxy, aView, thePrsTypeList, thePictureDir, thePictureExt, theIsAutoDelete)
-aFieldNames = aProxy.PointArrays.GetData()
-aNbOnNodes = len(aFieldNames)
-aFieldNames.extend(aProxy.CellArrays.GetData())
-aTimeStamps = aProxy.TimestepValues.GetData()
aFieldEntity = EntityType.NODE
-aFieldName = "MODES_DEPL"
+aFieldName = "MODES___DEPL____________________"
#Creation of a set of non-colored and then colored Vectors presentations, based on time stamps of MODES_DEP field
for colored in [False,True]:
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A0")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A0")
# 1. Import MED file
print 'Importing "hydro_sea_alv.med"...',
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A1")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A1")
med_file_path = datadir + "fra1.med"
pic_path = os.path.join(picturedir, "A1." + pictureext)
pvsimple.Render(view)
print "Picure file name is " + pic_path
-pv.WriteImage(pic_path, view=view, Magnification=1)
+pvs.WriteImage(pic_path, view=view, Magnification=1)
time.sleep(1)
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A2")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A2")
med_file_path = datadir + "carre_MIXTE_0000_v3.0.6.med"
pic_path = os.path.join(picturedir, "A2." + pictureext)
pvsimple.Render(view)
print "Picure file name is " + pic_path
-pv.WriteImage(pic_path, view=view, Magnification=1)
+pvs.WriteImage(pic_path, view=view, Magnification=1)
time.sleep(1)
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A6")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A6")
med_file_path = datadir + "fra.med"
import paravis
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A7")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A7")
med_file_path = datadir + "hexa_28320_ELEM.med"
CreatePrsForFile(my_paravis, med_file_path, [PrsTypeEnum.MESH], picturedir, pictureext)
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/A9")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/A9")
# 1. Step1: Import MED file
print "**** Step1: Importing MED file"
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/B1")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/B1")
# 1. Import MED file
med_file_path = datadir + "resultat.01.med"
print "OK"
# 2. Creation of presentation of each group
-groups_on_cells = get_group_names(med_reader, "MAILLAGE_01_001", EntityType.CELL, wo_nogroups=True)
-groups_on_nodes = get_group_names(med_reader, "MAILLAGE_01_001", EntityType.NODE, wo_nogroups=True)
-
-groups = groups_on_cells + groups_on_nodes
+extGrp = pvs.ExtractGroup()
+extGrp.UpdatePipelineInformation()
+groups = get_group_names(extGrp)
errors = 0
i = 0
i += 1
shor_name = group.split('/')[-1]
print "group: ", shor_name
- prs = MeshOnGroup(med_reader, group)
+ prs = MeshOnGroup(med_reader, extGrp, group)
if prs is None :
print "FAILED!!! Created presentation is None!!!"
med_reader = pvsimple.GetActiveSource()
if med_reader is None:
- print "FAILED"
+ raise RuntimeError, "MEDfileForStructuredMesh.med was not imported!"
else:
print "OK"
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/C4")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/C4")
# 1. Import MED file
med_file_path = datadir + "forma01f.resu.med"
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/C6")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/C6")
# 1. Import MED file
med_file_path = datadir + "relachement_brutal_sans_dudg_gauss.med"
# 2. Creation of GaussPoints presentations
mesh_name = "Maillage"
-field_name = "Result_EQUI_ELGA_SIGM"
+field_name = "Result__EQUI_ELGA_SIGM__________"
timestamp_list = range(1, 5)
for timestamp in timestamp_list:
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/C7")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/C7")
# 1. Import MED file
med_file_path = datadir + "Bug583-Quadratique.resu.med"
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/D0")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/D0")
# Aux method
def get_group_full_name(source, group_name):
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "bugs/D1")
+os.environ["PARAVIS_TEST_PICS"] = sys.argv[1]
+picturedir = get_picture_dir("bugs/D1")
# 1. Import of the "Bug829_resu_mode.med" file at first time
med_file_path = datadir + "Bug829_resu_mode.med"
sizes=[]
for i in range(1,11):
- presentation = DeformedShapeAndScalarMapOnField(med_reader1, EntityType.NODE, "MODES_DEPL", i)
+ presentation = DeformedShapeAndScalarMapOnField(med_reader1, EntityType.NODE, "MODES___DEPL____________________", i)
if presentation is None :
raise RuntimeError, "Presentation is None!!!"
sizes=[]
for i in range(1,11):
- presentation = DeformedShapeAndScalarMapOnField(med_reader2, EntityType.NODE, "MODES_DEPL", 11-i)
+ presentation = DeformedShapeAndScalarMapOnField(med_reader2, EntityType.NODE, "MODES___DEPL____________________", 11-i)
if presentation is None :
raise RuntimeError, "Presentation is None!!!"
view = pvsimple.GetRenderView()
# Creation of colored "DeformedShape" presentations, based on time stamps of "RESU_DEPL" field
-presentation = DeformedShapeOnField(med_reader, EntityType.NODE, 'RESU_DEPL', 1, is_colored=True)
+presentation = DeformedShapeOnField(med_reader, EntityType.NODE, 'RESU____DEPL____________________', 1, is_colored=True)
if presentation is None :
raise RuntimeError, "DeformedShapeOnField Presentation is None!!!"
reset_view(view)
# Creation of colored "Vectors" presentations, based on time stamps of "RESU_DEPL" field
-presentation = VectorsOnField(med_reader, EntityType.NODE, 'RESU_DEPL', 1, is_colored=True)
+presentation = VectorsOnField(med_reader, EntityType.NODE, 'RESU____DEPL____________________', 1, is_colored=True)
if presentation is None :
raise RuntimeError, "Vectors Presentation is None!!!"
reset_view(view)
# Creation of colored "DeformedShapeAndScalarMap" presentations, based on time stamps of "RESU_DEPL" field
-presentation = DeformedShapeAndScalarMapOnField(med_reader, EntityType.NODE, 'RESU_DEPL', 1)
+presentation = DeformedShapeAndScalarMapOnField(med_reader, EntityType.NODE, 'RESU____DEPL____________________', 1)
if presentation is None :
raise RuntimeError, "DeformedShapeAndScalarMap Presentation is None!!!"
reset_view(view)
# Creation of colored "CutPlanes" presentations, based on time stamps of "RESU_DEPL" field
-presentation = CutPlanesOnField(med_reader, EntityType.NODE, 'RESU_DEPL', 1)
+presentation = CutPlanesOnField(med_reader, EntityType.NODE, 'RESU____DEPL____________________', 1)
if presentation is None :
raise RuntimeError, "CutPlanes Presentation is None!!!"
# (spreadsheet view in terms of ParaViS) from in Python script
# 5. Creation of curve based on Table
-xy_view = pv.CreateXYPlotView()
+xy_view = pvs.CreateXYPlotView()
-curve1 = pv.Show(cut_segment1.Input, xy_view)
+curve1 = pvs.Show(cut_segment1.Input, xy_view)
if curve1 == None:
raise RuntimeError, " ERROR!!! Curve based on the first CutSegment is not built!"
-curve2 = pv.Show(cut_segment2.Input, xy_view)
+curve2 = pvs.Show(cut_segment2.Input, xy_view)
if curve2 == None:
raise RuntimeError, " ERROR!!! Curve based on the second CutSegment is not built!"
# 2. Displaying scalar field
print "Creating Scalar Map.......",
-scalarmap = ScalarMapOnField(med_reader, EntityType.CELL, 'scalar_field', 1)
+scalarmap = ScalarMapOnField(med_reader, EntityType.CELL, 'scalar field', 1)
if scalarmap is None:
print "FAILED"
else:
vector_array = calc.ResultArrayName
calc.UpdatePipeline()
source = calc
-stream = pv.StreamTracer(source)
+stream = pvs.StreamTracer(source)
# 3. Apply settings
RenameSource(settings['name'], stream)
import pvsimple
my_paravis = paravis.myParavis
-picturedir = get_picture_dir(sys.argv[1], "imps/A1")
-
+picturedir = get_picture_dir("imps/A1")
def set_prs_colored(prs, proxy, entity, field_name, vector_mode, timestamp_nb):
# Get time value
# 2. Creation of "CutPlanes" presentation, based on time stamp of "scalar field" field
print 'Creation of "CutPlanes" presentation, based on time stamp of "scalar field" field....'
-cutplanes = CutPlanesOnField(med_reader, EntityType.CELL, "scalar_field", 1)
+cutplanes = CutPlanesOnField(med_reader, EntityType.CELL, "scalar field", 1)
if cutplanes is None :
raise RuntimeError, "Presentation is None!!!"
else:
print "OK"
+select_cells_with_data(med_reader, on_cells=["scalar field", "vectoriel field"])
+
print "Setting of deformation:"
warp_vector = pvsimple.WarpByVector(cutplanes.Input)
-warp_vector.Vectors = ["vectoriel_field"]
+warp_vector.Vectors = ["vectoriel field"]
warp_vector.ScaleFactor = 5.0
print "Got scale : ", warp_vector.ScaleFactor
print "Got field name: ", warp_vector.Vectors
presentation = pvsimple.GetRepresentation(warp_vector)
-set_prs_colored(presentation, med_reader, EntityType.CELL, "scalar_field", 'Magnitude', 1)
+set_prs_colored(presentation, med_reader, EntityType.CELL, "scalar field", 'Magnitude', 1)
pic_path = os.path.join(picturedir, "deformed_cut_planes_scalar" + "." + pictureext)
process_prs_for_test(presentation, view, pic_path)
# 3. Creation of "CutPlanes" presentation, based on time stamp of "vectoriel field" field
print 'Creation of "CutPlanes" presentation, based on time stamp of "vectoriel field" field....'
-cutplanes = CutPlanesOnField(med_reader, EntityType.CELL, "vectoriel_field", 1)
+cutplanes = CutPlanesOnField(med_reader, EntityType.CELL, "vectoriel field", 1)
if cutplanes is None :
raise RuntimeError, "Presentation is None!!!"
print "Setting of deformation:"
warp_vector = pvsimple.WarpByVector(cutplanes.Input)
-warp_vector.Vectors = ["vectoriel_field"]
+warp_vector.Vectors = ["vectoriel field"]
warp_vector.ScaleFactor = 5.0
print "Got scale : ", warp_vector.ScaleFactor
print "Got field name: ", warp_vector.Vectors
presentation = pvsimple.GetRepresentation(warp_vector)
-set_prs_colored(presentation, med_reader, EntityType.CELL, "vectoriel_field", 'Magnitude', 1)
+set_prs_colored(presentation, med_reader, EntityType.CELL, "vectoriel field", 'Magnitude', 1)
pic_path = os.path.join(picturedir, "deformed_cut_planes_vectorial" + "." + pictureext)
process_prs_for_test(presentation, view, pic_path)
error = error+1
# Create Scalar Map
-scalarmap = ScalarMapOnField(med_reader, EntityType.NODE, 'RESUMECAEQUI_ELGA_SIGM', 1)
+scalarmap = ScalarMapOnField(med_reader, EntityType.NODE, 'RESUMECAEQUI_ELGA_SIGM__________', 1)
if scalarmap is None:
print "Error!!! ScalarMap is not created"
error = error+1
print "**** Step4: Displaying scalar field"
print "Creating Scalar Map.......",
-scalarmap1 = ScalarMapOnField(med_reader1, cell_entity, 'scalar_field', 1)
+scalarmap1 = ScalarMapOnField(med_reader1, cell_entity, 'scalar field', 1)
if scalarmap1 is None:
print "FAILED"
else:
reset_view(view)
print "Creating Iso Surfaces.....",
-isosurfaces1 = IsoSurfacesOnField(med_reader1, cell_entity, 'scalar_field', 1)
+isosurfaces1 = IsoSurfacesOnField(med_reader1, cell_entity, 'scalar field', 1)
if isosurfaces1 is None:
print "FAILED"
else:
print "OK"
print "Creating Cut Planes.......",
-cutplanes1 = CutPlanesOnField(med_reader1, cell_entity, 'scalar_field', 1,
+cutplanes1 = CutPlanesOnField(med_reader1, cell_entity, 'scalar field', 1,
orientation=Orientation.YZ)
if cutplanes1 is None:
print "FAILED"
print "OK"
mesh_name1 = 'Maillage_MED_HEXA8'
-scalar_field = 'scalar_field'
-vectoriel_field = 'vectoriel_field'
+scalar_field = 'scalar field'
+vectoriel_field = 'vectoriel field'
view = pvsimple.GetRenderView()
print "Creating Scalar Map...................",
