예제 #1
0
    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
예제 #2
0
    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
예제 #3
0
    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()
예제 #4
0
 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)
예제 #5
0
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
예제 #6
0
    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
예제 #7
0
    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
예제 #8
0
        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()
예제 #9
0
        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()
예제 #10
0
    #    #
    #    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()
예제 #11
0
    # 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 *** '
예제 #12
0
    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()
예제 #13
0
    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()
예제 #14
0
    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()
예제 #15
0
    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()
예제 #16
0
    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()
예제 #17
0
    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()
예제 #18
0
#    # 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()
예제 #19
0
    #
    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 *** '