def _plot_fired(self):
X = self.ls_table.X[:, 0]
Y = self.ls_table.Y[:, 0]
Z = self.ls_table.Z[:, 0]
plot_col = getattr(self, self.plot_column)[:, 0]
if self.plot_column == 'n_tex':
plot_col = where(plot_col < 0, 0, plot_col)
mlab.figure(figure="SFB532Demo",
bgcolor=(1.0, 1.0, 1.0),
fgcolor=(0.0, 0.0, 0.0))
mlab.points3d(
X,
Y,
(-1.0) * Z,
plot_col,
# colormap = "gist_rainbow",
# colormap = "Reds",
colormap="YlOrBr",
mode="cube",
scale_factor=0.15)
mlab.scalarbar(title=self.plot_column, orientation='vertical')
mlab.show
def _plot_max_Value( self ):
X = self.X_hf[:, 0]
Y = self.Y_hf[:, 0]
Z = self.Z_hf[:, 0]
plot_col = getattr( self, self.plot_column )[:, 0]
scale = 1 / max( plot_col )
# if self.plot_column == 'n_tex':
# plot_col = where( plot_col < 0, 0, plot_col )
mlab.figure( figure = "SFB532Demo",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, ( -1.0 ) * Z, plot_col,
# colormap = "gist_rainbow",
# colormap = "Reds",
colormap = "copper",
mode = "cube",
scale_factor = scale )
mlab.outline()
mlab.scalarbar( title = self.plot_column, orientation = 'vertical' )
mlab.show
def _plot3d_points_flat_fired(self):
'''Plot array of variable using colormap
'''
aramis_cdt = self.aramis_cdt
m.figure(fgcolor=(0, 0, 0), bgcolor=(1, 1, 1) , size=(1600, 900))
engine = m.get_engine()
scene = engine.scenes[0]
scene.scene.disable_render = True
plot3d_var = getattr(aramis_cdt, self.plot3d_var_)
mask = np.logical_or(np.isnan(aramis_cdt.x_arr),
aramis_cdt.data_array_undeformed_mask[0, :, :])
mask = None
m.points3d(aramis_cdt.x_arr[mask],
aramis_cdt.y_arr[mask],
aramis_cdt.z_arr[mask],
plot3d_var[mask],
mode='cube',
scale_mode='none', scale_factor=1)
m.view(0, 0)
scene.scene.parallel_projection = True
scene.scene.disable_render = False
if self.plot_title:
m.title('step no. %d' % aramis_cdt.evaluated_step_idx, size=0.3)
m.scalarbar(orientation='horizontal', title=self.plot3d_var_)
# plot axes
m.axes()
m.show()
def plot_sr(self, mlab, lc = 0, sr = 0):
lc = self.lc_arr[lc]
gd = self.geo_data_dict
mlab.points3d(gd['X'], gd['Y'], gd['Z'], lc[:, sr],
#colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.1)
def show( hp_shell, x, y, z_middle, displayed_value ):
"""Test contour_surf on regularly spaced co-ordinates like MayaVi.
"""
print '*** plotting data***'
s = points3d( X, Y, z_middle, displayed_value, colormap = "gist_rainbow", mode = "cube", scale_factor = 0.3 )
sb = colorbar( s )
# Recorded script from Mayavi2
#try:
# engine = mayavi.engine
#except NameError:
# from etsproxy.mayavi.api import Engine
# engine = Engine()
# engine.start()
#if len(engine.scenes) == 0:
# engine.new_scene()
# -------------------------------------------
glyph = s#.pipeline.scenes[0].children[0].children[0].children[0]
glyph.glyph.glyph_source.glyph_source.center = array( [ 0., 0., 0.] )
glyph.glyph.glyph_source.glyph_source.progress = 1.0
glyph.glyph.glyph_source.glyph_source.x_length = 0.6
glyph.glyph.glyph_source.glyph_source.y_length = 0.6
sb.scalar_bar.title = 'thickness [m]'
#print s.pipeline
#s.scene.background = (1.0, 1.0, 1.0)
return s
def show(self, x, y, z_middle, displayed_value):
"""Test contour_surf on regularly spaced co-ordinates like MayaVi.
"""
print '*** plotting data***'
s = points3d(X,
Y,
z_middle,
displayed_value,
colormap="gist_rainbow",
mode="cube",
scale_factor=0.3)
sb = colorbar(s)
# Recorded script from Mayavi2
#try:
# engine = mayavi.engine
#except NameError:
# from etsproxy.mayavi.api import Engine
# engine = Engine()
# engine.start()
#if len(engine.scenes) == 0:
# engine.new_scene()
# -------------------------------------------
glyph = s #.pipeline.scenes[0].children[0].children[0].children[0]
glyph.glyph.glyph_source.glyph_source.center = array([0., 0., 0.])
glyph.glyph.glyph_source.glyph_source.progress = 1.0
glyph.glyph.glyph_source.glyph_source.x_length = 0.6
glyph.glyph.glyph_source.glyph_source.y_length = 0.6
sb.scalar_bar.title = 'thickness [m]'
#print s.pipeline
#s.scene.background = (1.0, 1.0, 1.0)
return s
def _plot_fired( self ):
X = self.ls_table.X[:, 0]
Y = self.ls_table.Y[:, 0]
Z = self.ls_table.Z[:, 0]
plot_col = getattr( self, self.plot_column )[:, 0]
if self.plot_column == 'n_tex':
plot_col = where( plot_col < 0, 0, plot_col )
mlab.figure( figure = "SFB532Demo",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, ( -1.0 ) * Z, plot_col,
# colormap = "gist_rainbow",
# colormap = "Reds",
colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.15 )
mlab.scalarbar( title = self.plot_column, orientation = 'vertical' )
mlab.show
offset_arr = np.array([xyoffset, xyoffset, zoffset])
pts = pts + offset_arr
return pts
if __name__ == '__main__':
from numpy import mgrid, c_, hstack, vstack, shape
from etsproxy.mayavi import mlab
geo_supprt = GeoSUPPRT()
shape_xy = 2
shape_z = 1
grid = mgrid[0:1:complex(0, shape_xy + 1),
0:1:complex(0, shape_xy + 1 ),
0:1:complex(0, shape_z + 1)]
X, Y, Z = grid
gpoints = c_[ X.flatten(), Y.flatten(), Z.flatten() ]
mlab.figure(bgcolor=(1.,1.,1.,))
fp1 = geo_supprt(gpoints)
mlab.points3d(fp1[:, 0], fp1[:, 1], fp1[:, 2],
scale_factor = 0.003 ,
resolution = 8)
mlab.axes()
mlab.show()
offset_arr = np.array([xyoffset, xyoffset, zoffset])
pts = pts + offset_arr
return pts
if __name__ == '__main__':
from numpy import mgrid, c_, hstack, vstack, shape
from etsproxy.mayavi import mlab
geo_supprt = GeoSUPPRT()
shape_xy = 2
shape_z = 1
grid = mgrid[0:1:complex(0, shape_xy + 1),
0:1:complex(0, shape_xy + 1 ),
0:1:complex(0, shape_z + 1)]
X, Y, Z = grid
gpoints = c_[ X.flatten(), Y.flatten(), Z.flatten() ]
mlab.figure(bgcolor=(1.,1.,1.,))
fp1 = geo_supprt(gpoints)
mlab.points3d(fp1[:, 0], fp1[:, 1], fp1[:, 2],
scale_factor = 0.003 ,
resolution = 8)
mlab.axes()
mlab.show()
# #
# scalefactor_delta_h = Float( 0.85 ) # [-]
# scalefactor_length_xy = Float( 7. / 8 ) # [-]
# # used only for constant element thickness
# # for the reinforcement layer in a non-linear calculation
# #
# hp.const_reinf_layer_elem = True
# hp.n_elems_reinf_layer = 1
# hp.t_reinf_layer = 0.01
X, Y, Z = mgrid[0:1:complex(0, hp.n_elems_xy + 1),
0:1:complex(0, hp.n_elems_xy + 1),
0:1:complex(0, hp.n_elems_z + 1)]
gpoints = c_[X.flatten(), Y.flatten(), Z.flatten()]
fp1 = hp(gpoints)
#print shape( fp1 )
#print fp1
mlab.points3d(
fp1[:, 0],
fp1[:, 1],
fp1[:, 2],
scale_factor=0.05,
# mode = "cube",
resolution=8)
mlab.show()
# 3) export thickness to file
#
ouput_data_thickness = 'RFEM_file_export/output_data_thickness_' + n_shells_str + '_' + scalefactor_delta_h_str + '02.csv'
export_thickness_data( elem_no, X, Y, t, ouput_data_thickness )
# 4) plot midsurface and thickness in mayavi
#
print '*** plotting data - thickness***'
mlab.figure( figure = "elem_coords and thickness",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, z_middle, t,
colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.50 )
mlab.scalarbar( title = 'elem_coords and thickness', orientation = 'vertical' )
mlab.axes()
mlab.show()
#------------------------------------------------------------------
# MIDSURFACE
# get a csv file with the nodal coords of the shell elements
# in the order of the supplied csv coordinates (x,y)
# --> z_node in [m]
#------------------------------------------------------------------
print '\n'
print '*** CALCULATE MIDSURFACE *** '
def plot_assess_value(self, title = None, add_assess_values_from_file = None, save_assess_values_to_file = None):
'''plot the assess value for all loading case combinations
'''
#----------------------------------------
# script to get the maximum values of 'assess_value'
# at all given coordinate points for all possible loading
# case combinations:
#----------------------------------------
# get the list of all loading case combinations:
#
lcc_list = self.lcc_list
#----------------------------------------------
# run trough all loading case combinations:
#----------------------------------------------
assess_value_list = []
for lcc in lcc_list:
# get the ls_table object and retrieve its 'ls_class'
# (= LSTable_ULS-object)
#
ls_class = lcc.ls_table.ls_class
# get 'assess_name'-column array
#
assess_name = ls_class.assess_name
if assess_name == 'max_eta_nm_tot':
assess_value = getattr(ls_class, 'eta_nm_tot')
if assess_name == 'max_n_tex':
assess_value = getattr(ls_class, 'n_tex')
if assess_name == 'max_eta_tot':
assess_value = getattr(ls_class, 'eta_tot')
# n_tex = ls_class.n_tex_up
# n_tex = ls_class.n_tex_lo
assess_value_list.append(assess_value)
# stack the list to an array in order to use ndmax-function
#
assess_value_arr = hstack(assess_value_list)
print 'assess_value_arr.shape', assess_value_arr.shape
#----------------------------------------------
# get the overall maximum values:
#----------------------------------------------
assess_value_max = ndmax(assess_value_arr, axis = 1)[:, None]
#----------------------------------------------
# plot
#----------------------------------------------
#
X = lcc_list[0].ls_table.X[:, 0]
Y = lcc_list[0].ls_table.Y[:, 0]
Z = lcc_list[0].ls_table.Z[:, 0]
if self.reader_type == 'RFEM':
Z *= -1.0
plot_col = assess_value_max[:, 0]
# save assess values to file in order to superpose them later
#
if save_assess_values_to_file != None:
print 'assess_values saved to file %s' %( save_assess_values_to_file )
assess_value_arr = plot_col
np.savetxt( save_assess_values_to_file, assess_value_arr )
# add read in saved assess values to be superposed with currently read in assess values
#
if add_assess_values_from_file != None:
print 'superpose assess_value_arr with values read in from file %s' %( add_assess_values_from_file )
assess_value_arr = np.loadtxt( add_assess_values_from_file )
plot_col += assess_value_arr
# # if n_tex is negative plot 0 instead:
# #
# plot_col = where(plot_col < 0, 0, plot_col)
mlab.figure(figure = title,
bgcolor = (1.0, 1.0, 1.0),
fgcolor = (0.0, 0.0, 0.0))
mlab.points3d(X, Y, Z, plot_col,
colormap = "YlOrBr",
mode = "cube",
scale_mode = 'none',
scale_factor = 0.10)
mlab.scalarbar(title = assess_name + ' (all LCs)', orientation = 'vertical')
mlab.show()
def plot_n_tex(self, title = None):
'''plot number of textile reinforcement 'n_tex' for all loading case combinations
'''
#----------------------------------------
# script to get the maximum number of reinforcement ('n_tex')
# at all given coordinate points for all possible loading
# case combinations:
#----------------------------------------
# set option to "True" for surrounding
# evaluation of necessary layers "n_tex"
# needed for all loading cases
# get the list of all loading case combinations:
#
lcc_list = self.lcc_list
#----------------------------------------------
# run trough all loading case combinations:
#----------------------------------------------
n_tex_list = []
for lcc in lcc_list:
# get the ls_table object and retrieve its 'ls_class'
# (= LSTable_ULS-object)
#
ls_class = lcc.ls_table.ls_class
# get 'n_tex'-column array
#
n_tex = ls_class.n_tex
# n_tex = ls_class.n_tex_up
# n_tex = ls_class.n_tex_lo
n_tex_list.append(n_tex)
# stack the list to an array in order to use ndmax-function
#
n_tex_arr = hstack(n_tex_list)
#----------------------------------------------
# get the overall maximum values:
#----------------------------------------------
n_tex_max = ndmax(n_tex_arr, axis = 1)[:, None]
#----------------------------------------------
# plot
#----------------------------------------------
#
X = lcc_list[0].ls_table.X[:, 0]
Y = lcc_list[0].ls_table.Y[:, 0]
Z = lcc_list[0].ls_table.Z[:, 0]
plot_col = n_tex_max[:, 0]
# if n_tex is negative plot 0 instead:
#
plot_col = where(plot_col < 0, 0, plot_col)
mlab.figure(figure = title,
bgcolor = (1.0, 1.0, 1.0),
fgcolor = (0.0, 0.0, 0.0))
mlab.points3d(X, Y, (-1.0) * Z, plot_col,
colormap = "YlOrBr",
mode = "cube",
scale_mode = 'none',
scale_factor = 0.10)
mlab.scalarbar(title = 'n_tex (all LCs)', orientation = 'vertical')
mlab.show()
def _plot3d_points_fired(self):
'''Plot arrays of variables in 3d relief
'''
aramis_cdt = self.aramis_cdt
m.figure(fgcolor=(0, 0, 0), bgcolor=(1, 1, 1), size=(900, 600))
engine = m.get_engine()
scene = engine.scenes[0]
scene.scene.disable_render = True
#-----------------------------------
# plot crack width ('crack_field_w')
#-----------------------------------
z_arr = np.zeros_like(aramis_cdt.z_arr)
plot3d_var = getattr(aramis_cdt, self.plot3d_var_)
m.points3d(z_arr, aramis_cdt.x_arr, aramis_cdt.y_arr, plot3d_var,
mode='cube', colormap="blue-red", scale_mode='scalar', vmax=.2)
# scale glyphs
#
glyph = engine.scenes[0].children[0].children[0].children[0]
glyph.glyph.glyph_source.glyph_position = 'tail'
glyph.glyph.glyph_source.glyph_source.x_length = self.glyph_x_length_cr
glyph.glyph.glyph_source.glyph_source.y_length = self.glyph_y_length_cr
glyph.glyph.glyph_source.glyph_source.z_length = self.glyph_z_length_cr
#-----------------------------------
# plot displacement jumps ('d_ux_w')
#-----------------------------------
plot3d_var = getattr(aramis_cdt, self.plot3d_var_)
m.points3d(z_arr, aramis_cdt.x_arr, aramis_cdt.y_arr, plot3d_var, mode='cube',
colormap="blue-red", scale_mode='none')
glyph1 = engine.scenes[0].children[1].children[0].children[0]
# # switch order of the scale_factor corresponding to the order of the
glyph1.glyph.glyph_source.glyph_source.x_length = self.glyph_z_length
glyph1.glyph.glyph_source.glyph_source.y_length = self.glyph_x_length
glyph1.glyph.glyph_source.glyph_source.z_length = self.glyph_y_length
# rotate scene
#
scene = engine.scenes[0]
scene.scene.parallel_projection = True
m.view(0, 90)
glyph.glyph.glyph_source.glyph_position = 'head'
glyph.glyph.glyph_source.glyph_position = 'tail'
module_manager = engine.scenes[0].children[0].children[0]
module_manager.scalar_lut_manager.scalar_bar_representation.minimum_size = np.array([1, 1])
module_manager.scalar_lut_manager.scalar_bar_representation.position2 = np.array([ 0.20603604, 0.16827586])
module_manager.scalar_lut_manager.scalar_bar_representation.moving = 0
module_manager.scalar_lut_manager.scalar_bar_representation.position = np.array([ 0.53971972, 0.19931035])
module_manager.scalar_lut_manager.scalar_bar_representation.maximum_size = np.array([100000, 100000])
scene.scene.disable_render = False
if self.plot_title:
m.title('step no. %d' % aramis_cdt.evaluated_step_idx, size=0.3)
m.scalarbar(orientation='horizontal', title=self.plot3d_var_)
# plot axes
#
m.axes()
m.show()
def plot3d_cracks(self):
# set background color to white and forground color to black
#
m.figure(fgcolor=(0, 0, 0), bgcolor=(1, 1, 1), size=(900, 600))
# get mayavi engine
#
engine = m.get_engine()
scene = engine.scenes[0]
scene.scene.disable_render = True
#-----------------------------------
# plot crack width ('crack_field_w')
#-----------------------------------
# flatten z_arr
# @todo: use instead: extent = [xmin, xmax, ymin, ymax, zmin, zmax],
#
z_arr = np.zeros_like(self.z_arr)
# NOTE: coordinate order is switched in order to display glyphs at their tail instead of their center
# (only possible in mayavis's x-direction)
#
plot3d_var = getattr(self, self.plot3d_var_[0])
# plot3d_var = getattr(self, 'crack_field_w')
vmax = self.plot3d_var_[1]
m.points3d(z_arr, self.x_arr, self.y_arr, plot3d_var, mode='cube', colormap="blue-red", scale_mode='scalar', vmax=vmax)
# plot scalarbar
#
m.scalarbar(orientation='horizontal', title=self.plot3d_var)
# figure title
# uses directory path by default
#
if plot_title == 'true':
m.title(os.path.join(self.data_dir, self.basename))
# scale glyphs
#
glyph = engine.scenes[0].children[0].children[0].children[0]
glyph.glyph.glyph_source.glyph_position = 'tail'
glyph.glyph.glyph_source.glyph_source.x_length = self.glyph_x_length_cr
glyph.glyph.glyph_source.glyph_source.y_length = self.glyph_y_length_cr
glyph.glyph.glyph_source.glyph_source.z_length = self.glyph_z_length_cr
#-----------------------------------
# plot displacement jumps ('d_ux_w')
#-----------------------------------
# plot3d_var = getattr(self, 'd_ux_w')
plot3d_var = getattr(self, 'crack_field_w')
m.points3d(z_arr, self.x_arr, self.y_arr, plot3d_var, mode='cube', colormap="blue-red", scale_mode='none', vmax=vmax)
# m.surf(z_arr, self.x_arr, self.y_arr, colormap="blue-red")
glyph1 = engine.scenes[0].children[1].children[0].children[0]
# # switch order of the scale_factor corresponding to the order of the
glyph1.glyph.glyph_source.glyph_source.x_length = self.glyph_z_length
glyph1.glyph.glyph_source.glyph_source.y_length = self.glyph_x_length
glyph1.glyph.glyph_source.glyph_source.z_length = self.glyph_y_length
# rotate scene
#
scene = engine.scenes[0]
scene.scene.parallel_projection = True
m.view(0, 90)
# scene.scene.camera.position = [616.49832063929375, 638.29074243238438, 514.06081220962164]
# scene.scene.camera.focal_point = [11.259753942489624, 11.990119934082031, 9.7502956390380859]
# scene.scene.camera.view_angle = 30.0
# scene.scene.camera.view_up = [0.79246046934594205, -0.54446721176015089, -0.27488517574095594]
# scene.scene.camera.clipping_range = [595.49259262137014, 1526.1362976999562]
# scene.scene.camera.compute_view_plane_normal()
glyph.glyph.glyph_source.glyph_position = 'head'
glyph.glyph.glyph_source.glyph_position = 'tail'
module_manager = engine.scenes[0].children[0].children[0]
module_manager.scalar_lut_manager.scalar_bar_representation.minimum_size = np.array([1, 1])
module_manager.scalar_lut_manager.scalar_bar_representation.position2 = np.array([ 0.20603604, 0.16827586])
module_manager.scalar_lut_manager.scalar_bar_representation.moving = 0
module_manager.scalar_lut_manager.scalar_bar_representation.position = np.array([ 0.53971972, 0.19931035])
module_manager.scalar_lut_manager.scalar_bar_representation.maximum_size = np.array([100000, 100000])
scene.scene.disable_render = False
# plot axes
#
m.axes()
m.show()
def plot3d_points(self):
# set background color to white and forground color to black
#
m.figure(fgcolor=(0, 0, 0), bgcolor=(1, 1, 1), size=(900, 600))
# NOTE: the missing facettes have all the coordinate position (0,0,0);
# the missing facettes therefore are displayed in points3d as missing elements (gaps)
plot3d_var = getattr(self, self.plot3d_var_[0])
vmax = self.plot3d_var_[1]
# m.points3d(self.x_arr, self.y_arr, self.z_arr, plot3d_var, mode = 'cube', colormap = "blue-red", scale_mode ='none', vmax = vmax)
# m.points3d(self.x_arr_avg, self.y_arr_avg, self.z_arr, plot3d_var, mode = 'cube', colormap = "blue-red", scale_mode ='none', vmax = vmax)
m.points3d(self.x_arr, self.y_arr, self.z_arr, plot3d_var, mode='cube', colormap="blue-red", scale_mode='none', vmax=vmax)
# switch coordinate order to display glyphs at their head/tail insted of their center
# m.points3d(self.z_arr, self.x_arr, self.y_arr, plot3d_var, mode = 'cube', colormap = "blue-red", scale_mode ='none', vmax = vmax)
# plot scalarbar
#
m.scalarbar(orientation='horizontal', title=self.plot3d_var)
# @todo: predefine scalarbar position
# m.scalarbar().position = [0., 0.]
# plot axes
#
m.axes()
# figure title
# uses directory path by default
#
if plot_title == 'true':
m.title(os.path.join(self.data_dir, self.basename))
# get mayavi engine
#
engine = m.get_engine()
# scale glyphs
#
glyph = engine.scenes[0].children[0].children[0].children[0]
glyph.glyph.glyph_source.glyph_source.x_length = self.glyph_x_length
glyph.glyph.glyph_source.glyph_source.y_length = self.glyph_y_length
glyph.glyph.glyph_source.glyph_source.z_length = self.glyph_z_length
glyph.glyph.glyph_source.glyph_position = 'tail'
# rotate scene
#
scene = engine.scenes[0]
scene.scene.parallel_projection = True
scene.scene.z_plus_view()
# preset position of scalarbar
#
module_manager = engine.scenes[0].children[0].children[0]
module_manager.scalar_lut_manager.scalar_bar_representation.maximum_size = np.array([100000, 100000])
module_manager.scalar_lut_manager.scalar_bar_representation.minimum_size = np.array([1, 1])
module_manager.scalar_lut_manager.scalar_bar_representation.position2 = np.array([ 0.20603604, 0.16827586])
module_manager.scalar_lut_manager.scalar_bar_representation.moving = 0
module_manager.scalar_lut_manager.scalar_bar_representation.position = np.array([ 0.40858859, 0.09310345])
module_manager.scalar_lut_manager.scalar_bar_representation.maximum_size = np.array([100000, 100000])
# # @todo: use mlab-functionality instead
# view = mlab.view()
# roll = mlab.roll()
# # Reposition the camera
# mlab.view(*view)
# mlab.roll(roll)
#
# f = mlab.gcf()
# camera = f.scene.camera
# cam.parallel_scale = 9
m.show()
def param_plot( self ):
fig = plt.figure()
ax = fig.gca( projection = '3d' )
values = self.results
p1 = self.values1
p2 = self.values2
n1 = self.name1
n2 = self.name2
n3 = self.name3
x = np.linspace( p1[0], p1[-1], 20 )
y = np.linspace( p2[0], p2[-1], 20 )
X = np.meshgrid( x, x )[0]
Y = np.meshgrid( y, y )[1]
val = np.array( values[0:9] ).reshape( 3, 3 )
spl = spline( p1, p2, val, kx = 2, ky = 2 )
Z = spl( x, y ) / 0.89
val2 = np.array( values[9:] ).reshape( 3, 3 )
spl2 = spline( p1, p2, val2, kx = 2, ky = 2 )
ZZ = spl2( x, y ) / 0.89
#
# ax.plot_wireframe( X, Y, Z, rstride = 5, cstride = 5, alpha = 1.,
# color = 'black', lw = 2 )
#
# i = 0
# for V in p2:
# for vorsp in p1:
# print vorsp, V, values[i]
# ax.plot( [vorsp, vorsp], [V, V], values[i] / 0.89, 'ko', lw = 5 )
# i += 1
# glas 1200tex 5cN: ax.plot( [100, 100], [30, 30], np.array( [588.32, 588.32] ) / 0.89, 'ro', label = '%.1f MPa' % ( 588.32 / 0.89 ) )
# carbon 1600tex 5cN: ax.plot( [70, 70], [60, 60], np.array( [1768., 1768.] ) / 0.89, 'ro', label = '%.1f MPa' % ( 1768. / 0.89 ) )
# ax.plot( [0, 0], [-1e15, -1e15], color = 'black', label = self.label1, lw = 2 )
ax.plot_wireframe( X, Y, ZZ, rstride = 5, cstride = 5, alpha = 1.,
color = 'black', lw = 2 )
i = 0
for V in p2:
for vorsp in p1:
print vorsp, V, values[9 + i]
ax.plot( [vorsp, vorsp], [V, V], values[9 + i] / 0.89, 'ko' )
m.points3d( vorsp, V, values[i] / 0.89 )
i += 1
# glas 1200ax.plot( [50, 50], [30, 30], np.array( [594.15, 594.15] ) / 0.89, 'ro', label = '%.1f MPa' % ( 594.15 / 0.89 ) )
ax.plot( [70, 70], [40, 40], np.array( [1773., 1773.] ) / 0.89, 'ro', label = '%.1f MPa' % ( 1773. / 0.89 ) )
m.points3d( 100, 30, 588.32 / 0.89, color = ( 0.5, 0.7, 0.2 ) )
ax.plot( [0, 0], [-1e15, -1e15], color = 'black', label = self.label2, lw = 2 )
ax.legend( loc = 'upper left' )
ax.set_title( self.title )
ax.set_xlabel( n1 )
ax.set_xlim3d( self.xlim[0], self.xlim[1] )
ax.set_ylabel( n2 )
ax.set_ylim3d( self.ylim[0], self.ylim[1] )
ax.set_zlabel( n3 )
ax.set_zlim3d( self.zlim[0], self.zlim[1] )
#plt.show()
e_arr = orthogonalize( [x, y] )
#n_e_arr = [ e / np.max(np.fabs(e)) for e in e_arr ]
strength = Z
#strength_n = strength / np.max(np.fabs(strength))
m.surf( e_arr[0], e_arr[1], strength )
m.show()
# # scale ( 8m x 8m x 1m ) - geometry to ( 7m x 7m x 0.85m ) - geometry
# # without changing thickness (remains 6 cm)
# #
# scalefactor_delta_h = Float( 0.85 ) # [-]
# scalefactor_length_xy = Float( 7. / 8 ) # [-]
# # used only for constant element thickness
# # for the reinforcement layer in a non-linear calculation
# #
# hp.const_reinf_layer_elem = True
# hp.n_elems_reinf_layer = 1
# hp.t_reinf_layer = 0.01
X, Y, Z = mgrid[0:1:complex(0, hp.n_elems_xy + 1),
0:1:complex(0, hp.n_elems_xy + 1),
0:1:complex(0, hp.n_elems_z + 1)]
gpoints = c_[ X.flatten(), Y.flatten(), Z.flatten() ]
fp1 = hp(gpoints)
#print shape( fp1 )
#print fp1
mlab.points3d(fp1[:, 0], fp1[:, 1], fp1[:, 2],
scale_factor = 0.05 ,
# mode = "cube",
resolution = 8)
mlab.show()
#
ouput_data_thickness = 'RFEM_file_export/output_data_thickness_' + n_shells_str + '_' + scalefactor_delta_h_str + '02.csv'
export_thickness_data(elem_no, X, Y, t, ouput_data_thickness)
# 4) plot midsurface and thickness in mayavi
#
print '*** plotting data - thickness***'
mlab.figure(figure="elem_coords and thickness",
bgcolor=(1.0, 1.0, 1.0),
fgcolor=(0.0, 0.0, 0.0))
mlab.points3d(X,
Y,
z_middle,
t,
colormap="YlOrBr",
mode="cube",
scale_factor=0.50)
mlab.scalarbar(title='elem_coords and thickness', orientation='vertical')
mlab.axes()
mlab.show()
#------------------------------------------------------------------
# MIDSURFACE
# get a csv file with the nodal coords of the shell elements
# in the order of the supplied csv coordinates (x,y)
# --> z_node in [m]
#------------------------------------------------------------------
print '\n'
print '*** CALCULATE MIDSURFACE *** '
