Пример #1
0
 def plot_mayavi(self):
     """Use mayavi to plot a phenotype phase plane in 3D.
     The resulting figure will be quick to interact with in real time,
     but might be difficult to save as a vector figure.
     returns: mlab figure object"""
     from mayavi import mlab
     figure = mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
     figure.name = "Phenotype Phase Plane"
     max = 10.0
     xmax = self.reaction1_fluxes.max()
     ymax = self.reaction2_fluxes.max()
     zmax = self.growth_rates.max()
     xgrid, ygrid = meshgrid(self.reaction1_fluxes, self.reaction2_fluxes)
     xgrid = xgrid.transpose()
     ygrid = ygrid.transpose()
     xscale = max / xmax
     yscale = max / ymax
     zscale = max / zmax
     mlab.surf(xgrid * xscale, ygrid * yscale, self.growth_rates * zscale,
               representation="wireframe", color=(0, 0, 0), figure=figure)
     mlab.mesh(xgrid * xscale, ygrid * yscale, self.growth_rates * zscale,
               scalars=self.shadow_prices1 + self.shadow_prices2,
               resolution=1, representation="surface", opacity=0.75,
               figure=figure)
     # draw axes
     mlab.outline(extent=(0, max, 0, max, 0, max))
     mlab.axes(opacity=0, ranges=[0, xmax, 0, ymax, 0, zmax])
     mlab.xlabel(self.reaction1_name)
     mlab.ylabel(self.reaction2_name)
     mlab.zlabel("Growth rates")
     return figure
Пример #2
0
 def labels(xlabel="x", ylabel="y", zlabel="z", obj=None):
     if xlabel:
         mlab.xlabel(xlabel, obj)
     if ylabel:
         mlab.ylabel(ylabel, obj)
     if zlabel:
         mlab.zlabel(zlabel, obj)
def plot3D(name, X, Y, Z, zlabel):
    """
    Plots a 3d surface plot of Z using the mayavi mlab.mesh function.

    Parameters
    ----------
    name: string
        The name of the figure.
    X: 2d ndarray
        The x-axis data.
    Y: 2d ndarray
        The y-axis data.
    Z: 2d nd array
        The z-axis data.
    zlabel: The title that appears on the z-axis.
    """
    mlab.figure(name)
    mlab.clf()
    plotData = mlab.mesh(X/(np.max(X) - np.min(X)),
                         Y/(np.max(Y) - np.min(Y)),
                         Z/(np.max(Z) - np.min(Z)))
    mlab.outline(plotData)
    mlab.axes(plotData, ranges=[np.min(X), np.max(X),
                                np.min(Y), np.max(Y),
                                np.min(Z), np.max(Z)])
    mlab.xlabel('Space ($x$)')
    mlab.ylabel('Time ($t$)')
    mlab.zlabel(zlabel)
Пример #4
0
 def plot_mayavi(self):
     """Use mayavi to plot a phenotype phase plane in 3D.
     The resulting figure will be quick to interact with in real time,
     but might be difficult to save as a vector figure.
     returns: mlab figure object"""
     from mayavi import mlab
     figure = mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
     figure.name = "Phenotype Phase Plane"
     max = 10.0
     xmax = self.reaction1_fluxes.max()
     ymax = self.reaction2_fluxes.max()
     zmax = self.growth_rates.max()
     xgrid, ygrid = meshgrid(self.reaction1_fluxes, self.reaction2_fluxes)
     xgrid = xgrid.transpose()
     ygrid = ygrid.transpose()
     xscale = max / xmax
     yscale = max / ymax
     zscale = max / zmax
     mlab.surf(xgrid * xscale, ygrid * yscale, self.growth_rates * zscale,
               representation="wireframe", color=(0, 0, 0), figure=figure)
     mlab.mesh(xgrid * xscale, ygrid * yscale, self.growth_rates * zscale,
               scalars=self.shadow_prices1 + self.shadow_prices2,
               resolution=1, representation="surface", opacity=0.75,
               figure=figure)
     # draw axes
     mlab.outline(extent=(0, max, 0, max, 0, max))
     mlab.axes(opacity=0, ranges=[0, xmax, 0, ymax, 0, zmax])
     mlab.xlabel(self.reaction1_name)
     mlab.ylabel(self.reaction2_name)
     mlab.zlabel("Growth rates")
     return figure
Пример #5
0
def draw_min_cost_surface(graph):

	graph = sim.graph

	X = []
	Y = []
	Z = []

	for day,sizes in graph.items():
		for size,days_const in sizes.items():
			days_const, node = sorted(days_const.items())[0]
			X.append(day)
			Y.append(size/10.)
			Z.append(node.min_cost)

	pts = mlab.points3d(X, Y, Z, Z)

	mesh = mlab.pipeline.delaunay2d(pts)

	# Remove the point representation from the plot
	pts.remove()

	# Draw a surface based on the triangulation
	surf = mlab.pipeline.surface(mesh)

	mlab.xlabel("time")
	mlab.ylabel("size")
	mlab.zlabel("cost")
	mlab.show()
Пример #6
0
def draw_min_feed_surface(graph):

	graph = sim.graph

	X = []
	Y = []
	Z = []

	for day,sizes in graph.items():
		for size,days_const in sizes.items():
			days_const, node = sorted(days_const.items())[-1]
			X.append(day)
			Y.append(size/10.)
			Z.append(node.min_rate*10)
	
	# for i in range(len(X)):
	# 	print ("%d,%f,%f" % (X[i], Y[i], Z[i]))

	pts = mlab.points3d(X, Y, Z, Z)

	mesh = mlab.pipeline.delaunay2d(pts)

	# Remove the point representation from the plot
	pts.remove()

	# Draw a surface based on the triangulation
	surf = mlab.pipeline.surface(mesh)

	mlab.xlabel("time")
	mlab.ylabel("size")
	mlab.zlabel("rate")
	mlab.show()
Пример #7
0
def mcrtmv(frames, mvname, dt, Lx, Ly, Nx, Ny):
    x = np.linspace(0, Lx, Nx)
    y = np.linspace(0, Ly, Ny)
    X, Y = np.meshgrid(x, y)
    size = 500, 500

    fig = ml.figure(size=size, bgcolor=(1., 1., 1.))

    #fig.scene.anti_aliasing_frames=07

    #extent = [0,Nx-1,0,Ny-1,-30,30]

    ml.clf(figure=fig)
    u = np.loadtxt('test.d%07d' % 1)
    fname = '_tmp%07d.png' % 1
    s = ml.surf(x, y, u, figure=fig, vmin=-0, vmax=1)
    ml.axes(extent=[0, Lx, 0, Ly, -2, 2])
    ml.colorbar()
    ml.xlabel('x position')
    ml.ylabel('y position')
    ml.zlabel('wave amplitude')
    """
	pl.ion()
	arr = ml.screenshot()
	img = pl.imshow(arr)
	pl.axis('off')
	"""
    for i in range(2, frames):
        #arr = ml.screenshot()
        #img.set_array(arr)
        u = np.loadtxt('test.d%07d' % i)
        s.mlab_source.scalars = u
        fname = '_tmp%07d.png' % i
def mcrtmv(frames,
           dt,
           mesh,
           d_nodes,
           map,
           savemovie=False,
           mvname='test',
           vmin=-1,
           vmax=1):
    """
	Creates move from numpyfied results in 2d, using mencoder. Prolly does not work on mac!
	"""

    size = 500, 500

    fig = ml.figure(size=size, bgcolor=(1., 1., 1.))

    #fig.scene.anti_aliasing_frames=07

    #extent = [0,Nx-1,0,Ny-1,-30,30]
    xaxis = np.linspace(0, 1, d_nodes[0] + 1)
    yaxis = np.linspace(0, 1, d_nodes[1] + 1)
    ml.clf(figure=fig)
    u = np.load('solution_%06d.npy' % 1)
    u = numpyfy(u, mesh, d_nodes, map)
    fname = '_tmp%07d.png' % 1
    s = ml.imshow(xaxis, yaxis, u, figure=fig, vmin=vmin, vmax=vmax)
    #scale = 1./np.max(np.abs(u))
    u = u
    ml.axes(extent=[0, 1, 0, 1, 0, 2])
    ml.colorbar()
    ml.xlabel('x position')
    ml.ylabel('y position')
    ml.zlabel('wave amplitude')

    if savemovie == True:
        pl.ion()
        arr = ml.screenshot()
        img = pl.imshow(arr)
        pl.axis('off')

    for i in range(2, frames):

        u = np.load('solution_%06d.npy' % i)
        u = numpyfy(u, mesh, d_nodes, map)
        s.mlab_source.scalars = u
        fname = '_tmp%07d.png' % i
        if savemovie == True:
            arr = ml.screenshot()
            img.set_array(arr)
            pl.savefig(filename=fname)  #,figure=fig)
            print 'Saving frame', fname
            pl.draw()

    fig.scene.disable_render = False
    if savemovie:
        os.system(
            "mencoder 'mf://_tmp*.png' -mf type=png:fps=20 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s.mpg"
            % mvname)
Пример #9
0
    def setLabels(self, xlabel="", ylabel="", zlabel=""):
        """
        sets the label

        input:
            - xlabel
            - ylabel
            - zlabel
        """

        mlab.xlabel(xlabel)
        mlab.ylabel(ylabel)
        mlab.zlabel(zlabel)
def mcrtmv(frames, dt,mesh, d_nodes, map, savemovie=False, mvname='test', vmin=-1, vmax=1):
	"""
	Creates move from numpyfied results in 2d, using mencoder. Prolly does not work on mac!
	"""


	size = 500,500
	
	fig = ml.figure(size= size, bgcolor=(1.,1.,1.));

	#fig.scene.anti_aliasing_frames=07

	#extent = [0,Nx-1,0,Ny-1,-30,30]
	xaxis = np.linspace(0,1,d_nodes[0]+1)
	yaxis = np.linspace(0,1,d_nodes[1]+1)
	ml.clf(figure=fig)
	u = np.load('solution_%06d.npy'%1);
	u = numpyfy(u, mesh, d_nodes, map)
	fname = '_tmp%07d.png' % 1
	s = ml.imshow(xaxis, yaxis, u,figure=fig,vmin=vmin, vmax=vmax)
	#scale = 1./np.max(np.abs(u))
	u = u
	ml.axes(extent=[0,1,0,1,0,2])
	ml.colorbar()
	ml.xlabel('x position')
	ml.ylabel('y position')
	ml.zlabel('wave amplitude')

	if savemovie == True:
		pl.ion()
		arr = ml.screenshot()
		img = pl.imshow(arr)
		pl.axis('off')
	
	for i in range(2,frames):

		u = np.load('solution_%06d.npy'%i);
		u = numpyfy(u, mesh, d_nodes, map)
		s.mlab_source.scalars = u
		fname = '_tmp%07d.png' % i
		if savemovie == True:
			arr = ml.screenshot()
			img.set_array(arr)
			pl.savefig(filename=fname)#,figure=fig)
			print 'Saving frame', fname
			pl.draw()

	fig.scene.disable_render = False
	if savemovie:
		os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=20 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s.mpg" % mvname);
Пример #11
0
def plot_cartesian(traj, xaxis=None, yaxis=None, zaxis=None, color='b',label='_nolegend_',
                   linewidth=2, scatter_size=10, plot_velocity=False):
    import matplotlib_util.util as mpu
    import arm_trajectories as at
    #if traj.__class__ == at.JointTrajectory:
    if isinstance(traj,at.JointTrajectory):
        traj = joint_to_cartesian(traj)

    pts = np.matrix(traj.p_list).T
    label_list = ['X coord (m)', 'Y coord (m)', 'Z coord (m)']
    x = pts[xaxis,:].A1.tolist()
    y = pts[yaxis,:].A1.tolist()

    if plot_velocity:
        vels = np.matrix(traj.v_list).T
        xvel = vels[xaxis,:].A1.tolist()
        yvel = vels[yaxis,:].A1.tolist()

    if zaxis == None:
        mpu.plot_yx(y, x, color, linewidth, '-', scatter_size, label,
                    axis = 'equal', xlabel = label_list[xaxis],
                    ylabel = label_list[yaxis],)
        if plot_velocity:
            mpu.plot_quiver_yxv(y, x, np.matrix([xvel,yvel]),
                                width = 0.001, scale = 1.)
        mpu.legend()
    else:
        from numpy import array
        from enthought.mayavi.api import Engine
        engine = Engine()
        engine.start()
        if len(engine.scenes) == 0:
            engine.new_scene()

        z = pts[zaxis,:].A1.tolist()
        time_list = [t-traj.time_list[0] for t in traj.time_list]
        mlab.plot3d(x,y,z,time_list,tube_radius=None,line_width=4)
        mlab.axes()
        mlab.xlabel(label_list[xaxis])
        mlab.ylabel(label_list[yaxis])
        mlab.zlabel(label_list[zaxis])
        mlab.colorbar(title='Time')

        # ------------------------------------------- 
        axes = engine.scenes[0].children[0].children[0].children[1]
        axes.axes.position = array([ 0.,  0.])
        axes.axes.label_format = '%-#6.2g'
        axes.title_text_property.font_size=4
Пример #12
0
def plot_cartesian(traj, xaxis=None, yaxis=None, zaxis=None, color='b',label='_nolegend_',
                   linewidth=2, scatter_size=10, plot_velocity=False):

    import arm_trajectories as at
    #if traj.__class__ == at.JointTrajectory:
    if isinstance(traj,at.JointTrajectory):
        traj = joint_to_cartesian(traj)

    pts = np.matrix(traj.p_list).T
    label_list = ['X coord (m)', 'Y coord (m)', 'Z coord (m)']
    x = pts[xaxis,:].A1.tolist()
    y = pts[yaxis,:].A1.tolist()

    if plot_velocity:
        vels = np.matrix(traj.v_list).T
        xvel = vels[xaxis,:].A1.tolist()
        yvel = vels[yaxis,:].A1.tolist()

    if zaxis == None:
        mpu.plot_yx(y, x, color, linewidth, '-', scatter_size, label,
                    axis = 'equal', xlabel = label_list[xaxis],
                    ylabel = label_list[yaxis],)
        if plot_velocity:
            mpu.plot_quiver_yxv(y, x, np.matrix([xvel,yvel]),
                                width = 0.001, scale = 1.)
        mpu.legend()
    else:
        from numpy import array
        from enthought.mayavi.api import Engine
        engine = Engine()
        engine.start()
        if len(engine.scenes) == 0:
            engine.new_scene()

        z = pts[zaxis,:].A1.tolist()
        time_list = [t-traj.time_list[0] for t in traj.time_list]
        mlab.plot3d(x,y,z,time_list,tube_radius=None,line_width=4)
        mlab.axes()
        mlab.xlabel(label_list[xaxis])
        mlab.ylabel(label_list[yaxis])
        mlab.zlabel(label_list[zaxis])
        mlab.colorbar(title='Time')

        # ------------------------------------------- 
        axes = engine.scenes[0].children[0].children[0].children[1]
        axes.axes.position = array([ 0.,  0.])
        axes.axes.label_format = '%-#6.2g'
        axes.title_text_property.font_size=4
Пример #13
0
def drawSurfaceDelaunay(point_list):
    x = [i[0] for i in point_list]
    y = [i[1] for i in point_list]
    z = [i[2] for i in point_list]

    pts = mlab.points3d(x, y, z, z)

    mesh = mlab.pipeline.delaunay2d(pts)

    pts.remove()

    surf = mlab.pipeline.surface(mesh)

    mlab.xlabel('x')
    mlab.ylabel('y')
    mlab.zlabel('z')
    mlab.show()
def plot_fiber_voltage(filename,fibertype):

    data = pickle.load( open(filename, "rb" ) )

    decimate_s = 1
    decimate_t = 1
    nproc = len(data)
    data_plot = []
    ddata2dx2 = []
    ddata2dx2_plot = []
    dx = 1
    dt = 1
    for proc in range(len(data)):
        data_plot.append(data[proc][fibertype][::decimate_s, ::decimate_t])
        ddata2dx2.append(np.gradient(data[proc][fibertype],dx))
        ddata2dx2_plot.append(ddata2dx2[proc][0][::decimate_t, ::decimate_s])

    nseg, nsamp = ddata2dx2_plot[0].shape
    x = np.arange(nseg)

    t_plot = []
    t_plot.append(data[0]['tvec'][::decimate_t])
    y = t_plot[0]

    X,Y = np.meshgrid(x, y)

    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    mlab.figure(1, fgcolor=(0, 0, 0), bgcolor=(1, 1, 1))

    s = mlab.surf(data_plot[0], warp_scale="auto", extent = [0,1,0,5,0,1])
    #pdb.set_trace()
    ax=mlab.axes(s, ranges = [0, 43.306, np.min(y), np.max(y), np.min(data_plot[0]), np.max(data_plot[0])])
    #
    ax.axes.label_format='%.2f'
    ax.label_text_property.font_family = 'arial'
    mlab.xlabel('Distance along axon (mm)')
    mlab.ylabel('Time (msec)')
    mlab.zlabel('Membrane voltage (mV)')

    ax.axes.font_factor=0.9
    mlab.savefig('3d_voltage.png', size=(1920, 1080))
    #pdb.set_trace()
    bla = input()
Пример #15
0
def mcrtmv(frames, dt, Lx, Ly, Nx, Ny, savemovie=False, mvname='test'):
    x = np.linspace(0, Lx, Nx)
    y = np.linspace(0, Lx, Nx)
    X, Y = np.meshgrid(x, y)
    size = 500, 500

    fig = ml.figure(size=size, bgcolor=(1., 1., 1.))

    #fig.scene.anti_aliasing_frames=07

    #extent = [0,Nx-1,0,Ny-1,-30,30]

    ml.clf(figure=fig)
    u = np.loadtxt('solution_%06d.txt' % 1)
    fname = '_tmp%07d.png' % 1
    s = ml.surf(x, y, u, figure=fig, vmin=-1, vmax=1)
    ml.axes(extent=[0, Lx, 0, Ly, -2, 2])
    ml.colorbar()
    ml.xlabel('x position')
    ml.ylabel('y position')
    ml.zlabel('wave amplitude')
    if savemovie == True:
        pl.ion()
        arr = ml.screenshot()
        img = pl.imshow(arr)
        pl.axis('off')

    for i in range(2, frames):

        u = np.loadtxt('solution_%06d.txt' % i)
        s.mlab_source.scalars = u
        fname = '_tmp%07d.png' % i
        if savemovie == True:
            arr = ml.screenshot()
            img.set_array(arr)
            pl.savefig(filename=fname)  #,figure=fig)
            print 'Saving frame', fname
            pl.draw()

    fig.scene.disable_render = False
    os.system(
        "mencoder 'mf://_tmp*.png' -mf type=png:fps=20 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s.mpg"
        % mvname)
Пример #16
0
def sigma_m( m ):
    dataname = "sigmaOPT25_with_m{}.npy".format( m )
    res = np.load( dataname )
    print 'max', np.max( res ), 'min', np.min( res )
    from mayavi.api import Engine
    engine = Engine()
    engine.start()
    if len( engine.scenes ) == 0:
        engine.new_scene()
    mlab.surf( x_axis1 , y_axis1 , res  , representation = 'wireframe' )
    surface = engine.scenes[0].children[0].children[0].children[0].children[0].children[0]
    surface.actor.mapper.scalar_range = np.array( [ 6.97602671, 8.8533387 ] )
    surface.actor.mapper.scalar_visibility = False
    scene = engine.scenes[0]
    scene.scene.background = ( 1.0, 1.0, 1.0 )
    surface.actor.property.specular_color = ( 0.0, 0.0, 0.0 )
    surface.actor.property.diffuse_color = ( 0.0, 0.0, 0.0 )
    surface.actor.property.ambient_color = ( 0.0, 0.0, 0.0 )
    surface.actor.property.color = ( 0.0, 0.0, 0.0 )
    surface.actor.property.line_width = 0.
    warp_scalar = engine.scenes[0].children[0].children[0]
    module_manager = engine.scenes[0].children[0].children[0].children[0].children[0]
    warp_scalar.filter.normal = np.array( [ 0. , 0. , 0.8] )
    module_manager.scalar_lut_manager.scalar_bar.global_warning_display = 1
    module_manager.scalar_lut_manager.scalar_bar.position2 = np.array( [ 0.8 , 0.17] )
    module_manager.scalar_lut_manager.scalar_bar.position = np.array( [ 0.1 , 0.01] )
    module_manager.scalar_lut_manager.data_range = np.array( [ 6.97602671, 8.8533387 ] )
    module_manager.scalar_lut_manager.default_data_range = np.array( [ 6.97602671, 8.8533387 ] )
    module_manager.vector_lut_manager.scalar_bar.global_warning_display = 1
    module_manager.vector_lut_manager.scalar_bar.position2 = np.array( [ 0.8 , 0.17] )
    module_manager.vector_lut_manager.scalar_bar.position = np.array( [ 0.1 , 0.01] )
    module_manager.vector_lut_manager.data_range = np.array( [ 0., 1.] )
    module_manager.vector_lut_manager.default_data_range = np.array( [ 0., 1.] )
    scene.scene.isometric_view()
 
    # mlab.surf( x_axis2, y_axis2, res2 )
    
    mlab.xlabel( "rand tau" )
    mlab.ylabel( "rand r" )
    mlab.zlabel( "z" )

    mlab.show()
Пример #17
0
def mcrtmv(frames, dt,Lx,Ly,Nx,Ny,savemovie=False, mvname='test'):
	x = np.linspace(0,Lx,Nx);
	y = np.linspace(0,Lx,Nx);
	X,Y = np.meshgrid(x,y);
	size = 500,500
	
	fig = ml.figure(size= size, bgcolor=(1.,1.,1.));

	#fig.scene.anti_aliasing_frames=07

	#extent = [0,Nx-1,0,Ny-1,-30,30]
	
	ml.clf(figure=fig)
	u = np.loadtxt('solution_%06d.txt'%1);
	fname = '_tmp%07d.png' % 1
	s = ml.surf(x,y,u,figure=fig,vmin=-1,vmax=1)
	ml.axes(extent=[0,Lx,0,Ly,-2,2])
	ml.colorbar()
	ml.xlabel('x position')
	ml.ylabel('y position')
	ml.zlabel('wave amplitude')
	if savemovie == True:
		pl.ion()
		arr = ml.screenshot()
		img = pl.imshow(arr)
		pl.axis('off')
	
	for i in range(2,frames):

		u = np.loadtxt('solution_%06d.txt'%i);
		s.mlab_source.scalars = u
		fname = '_tmp%07d.png' % i
		if savemovie == True:
			arr = ml.screenshot()
			img.set_array(arr)
			pl.savefig(filename=fname)#,figure=fig)
			print 'Saving frame', fname
			pl.draw()

	fig.scene.disable_render = False
	os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=20 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s.mpg" % mvname);
Пример #18
0
def mayavi_version(X,Y,Z):
    from mayavi import mlab

    # Define the points in 3D space
    # including color code based on Z coordinate.
    pts = mlab.points3d(X, Y, Z, Z)

    # Triangulate based on X, Y with Delaunay 2D algorithm.
    # Save resulting triangulation.
    mesh = mlab.pipeline.delaunay2d(pts)

    # Remove the point representation from the plot
    pts.remove()

    # Draw a surface based on the triangulation
    surf = mlab.pipeline.surface(mesh)

    # Simple plot.
    mlab.xlabel("x")
    mlab.ylabel("y")
    mlab.zlabel("z")
    mlab.show()
Пример #19
0
def mayavi_version(X, Y, Z):
    from mayavi import mlab

    # Define the points in 3D space
    # including color code based on Z coordinate.
    pts = mlab.points3d(X, Y, Z, Z)

    # Triangulate based on X, Y with Delaunay 2D algorithm.
    # Save resulting triangulation.
    mesh = mlab.pipeline.delaunay2d(pts)

    # Remove the point representation from the plot
    pts.remove()

    # Draw a surface based on the triangulation
    surf = mlab.pipeline.surface(mesh)

    # Simple plot.
    mlab.xlabel("x")
    mlab.ylabel("y")
    mlab.zlabel("z")
    mlab.show()
Пример #20
0
def anims(time):
    nc = get_grid_from_dda(time)
    ref = nc.variables['reflectivity'][:]
    u = nc.variables['eastward_wind'][:]
    v = nc.variables['northward_wind'][:]
    w = nc.variables['upward_air_velocity'][:]

    zh = nc.variables['z'][:]
    xh = nc.variables['x'][:]
    yh = nc.variables['y'][:]
    u = np.ma.squeeze(u)
    v = np.ma.squeeze(v)
    w = np.ma.squeeze(w)
    ref = np.squeeze(ref)

    grid_y, grid_z, grid_x = np.meshgrid(yh, zh, xh)

    ref = np.array(ref)
    bca = get_bca(grid_x, grid_y)
    ## Mask region outside dual doppler lobes and
    u = np.ma.masked_where(
        np.logical_or(bca < math.pi / 6, bca > 5 * math.pi / 6), u)
    no_mask = np.where(u.mask == False)
    no_mask_r = np.where(ref > 1)

    ## Apply mask
    grid_xm = grid_x[no_mask[0][0::10], no_mask[1][0::10],
                     no_mask[2][0::10]] / 1e3
    grid_ym = grid_y[no_mask[0][0::10], no_mask[1][0::10],
                     no_mask[2][0::10]] / 1e3
    grid_zm = grid_z[no_mask[0][0::10], no_mask[1][0::10],
                     no_mask[2][0::10]] / 1e3
    um = u[no_mask[0][0::10], no_mask[1][0::10], no_mask[2][0::10]]
    vm = v[no_mask[0][0::10], no_mask[1][0::10], no_mask[2][0::10]]
    wm = w[no_mask[0][0::10], no_mask[1][0::10], no_mask[2][0::10]]
    grid_xmr = grid_x[no_mask_r[0][0::2], no_mask_r[1][0::2],
                      no_mask_r[2][0::2]] / 1e3
    grid_ymr = grid_y[no_mask_r[0][0::2], no_mask_r[1][0::2],
                      no_mask_r[2][0::2]] / 1e3
    grid_zmr = grid_z[no_mask_r[0][0::2], no_mask_r[1][0::2],
                      no_mask_r[2][0::2]] / 1e3
    refm = ref[no_mask_r[0][0::2], no_mask_r[1][0::2], no_mask_r[2][0::2]]

    ## Regrid data for contour plot
    refm_gridded = griddata((grid_xmr, grid_ymr, grid_zmr), refm,
                            (grid_x / 1e3, grid_y / 1e3, grid_z / 1e3))
    um_gridded = griddata((grid_xm, grid_ym, grid_zm), um,
                          (grid_x / 1e3, grid_y / 1e3, grid_z / 1e3))
    vm_gridded = griddata((grid_xm, grid_ym, grid_zm), vm,
                          (grid_x / 1e3, grid_y / 1e3, grid_z / 1e3))
    wm_gridded = griddata((grid_xm, grid_ym, grid_zm), wm,
                          (grid_x / 1e3, grid_y / 1e3, grid_z / 1e3))

    #mlab.options.offscreen = True
    f = mlab.figure(bgcolor=(0, 0, 0), size=(1500, 1500))
    q = mlab.quiver3d(grid_xm,
                      grid_ym,
                      grid_zm,
                      um,
                      vm,
                      wm,
                      extent=[-40, 40, -30, 30, 0, 20])

    colorbar = mlab.colorbar(q, title='m/s', orientation='vertical')
    colorbar.label_text_property.font_size = 5
    #mlab.flow(np.transpose(grid_x)/1e3,
    #          np.transpose(grid_y)/1e3,
    #          np.transpose(grid_z)/1e3,
    #          np.transpose(um_gridded),
    #          np.transpose(vm_gridded),
    #          np.transpose(wm_gridded))

    mlab.contour3d(np.transpose(grid_x) / 1e3,
                   np.transpose(grid_y) / 1e3,
                   np.transpose(grid_z) / 1e3,
                   np.transpose(wm_gridded),
                   colormap='blue-red',
                   contours=[-4, 4],
                   opacity=0.5,
                   extent=[-40, 40, -30, 30, 0, 20])
    mlab.view(azimuth=72.608457142284237,
              elevation=73.373132558239334,
              distance=201.83739701316438,
              focalpoint=(-0.05410797, -0.34705752, 10.27633847))
    mlab.title(
        str(time.month) + '-' + str(time.day) + ' ' + str(time.hour) + ':' +
        str(time.minute))
    axes = mlab.axes(extent=[-40, 40, -30, 30, 0, 20])
    axes.label_text_property.font_family = 'courier'
    axes.label_text_property.font_size = 5
    xlabel = mlab.xlabel('E of CPOL [km]')
    ylabel = mlab.ylabel('N of CPOL [km]')
    zlabel = mlab.zlabel('z [km]')
    xlabel.label_text_property.font_size = 5
    ylabel.label_text_property.font_size = 5
    zlabel.label_text_property.font_size = 5

    mlab.show()
Пример #21
0
# Loop over the values of the slice array, to produce an image of the vector 
# field for each slice
for i in range(len(slice_arr)):
	# Create a new figure 
	fig = mlab.figure(size = (800,700))

	# Create an image of the vector field for this slice of the array
	mlab.quiver3d(X[slice_arr[i],::8,::8], Y[slice_arr[i],::8,::8],\
	 Z[slice_arr[i],::8,::8], mag_x[slice_arr[i],::8,::8],\
	 mag_y[slice_arr[i],::8,::8],mag_z[slice_arr[i],::8,::8],scalars =\
	  B_mag[slice_arr[i],::8,::8], vmax=vmax,vmin=vmin)

	# Make the co-ordinate axes appear on the plot 
	mlab.xlabel('x-axis')
	mlab.ylabel('y-axis')
	mlab.zlabel('z-axis')

	# Rotate the camera so that it is face on
	mlab.view(azimuth=0, elevation = 90)

	# Add a colourbar to the figure
	mlab.colorbar(orientation='vertical')

	# Save the figure
	mlab.savefig(data_loc + 'B_vectors_slice_{}.jpg'.format(slice_arr[i]))

	# Close the figure
	mlab.close()

	# Print a line to the screen to show that the figure has been saved
	print 'Figure saved for slice number {}'.format(i)
Пример #22
0
EnStr=numpy.zeros((numplots), dtype=float)
En=numpy.zeros((numplots), dtype=float)
Enchange=numpy.zeros((numplots-1),dtype=float)
tdata=numpy.zeros((numplots), dtype=float)
nonlin=numpy.zeros((Nx,Ny), dtype=float)
nonlinhat=numpy.zeros((Nx,Ny), dtype=complex)

u=0.1*numpy.exp(-(xx**2 + yy**2))*numpy.sin(10*xx+12*yy) 
uold=u
v=numpy.fft.fft2(u)
vold=numpy.fft.fft2(uold)
src = mlab.surf(xx,yy,u,colormap='YlGnBu',warp_scale='auto')
mlab.scalarbar(object=src)
mlab.xlabel('x',object=src)
mlab.ylabel('y',object=src)
mlab.zlabel('u',object=src)
# initial energy
vx=0.5*kxm*(v+vold)
vy=0.5*kym*(v+vold)
ux=numpy.fft.ifft2(vx)
uy=numpy.fft.ifft2(vy)
Kineticenergy=0.5*((u-uold)/dt)**2
Strainenergy=0.5*(ux)**2 + 0.5*(uy)**2 
Potentialenergy=0.5*(0.5*(u+uold))**2 - Es*0.25*(0.5*(u+uold))**4
Kineticenergy=numpy.fft.fft2(Kineticenergy)
Strainenergy=numpy.fft.fft2(Strainenergy)
Potentialenergy=numpy.fft.fft2(Potentialenergy)
EnKin[0]=numpy.real(Kineticenergy[0,0])
EnPot[0]=numpy.real(Potentialenergy[0,0])
EnStr[0]=numpy.real(Strainenergy[0,0])
En[0]=EnStr[0]+EnPot[0]+EnKin[0]
Пример #23
0
else:
    mlab.view(azimuth=38,
              elevation=63,
              distance=np.sqrt(qx.max()**2 + qz.max()**2 + qy.max()**2))

# azimut is the rotation around z axis of mayavi (x)
mlab.roll(0)

if crop_symmetric:
    ax = mlab.axes(line_width=2.0, nb_labels=2 * half_labels + 1)
else:
    ax = mlab.axes(line_width=2.0, nb_labels=4)

mlab.xlabel('Qx (1/nm)')
mlab.ylabel('Qz (1/nm)')
mlab.zlabel('-Qy (1/nm)')
mlab.savefig(savedir + 'S' + str(scan) + comment + '_labels.png', figure=myfig)
ax.label_text_property.opacity = 0.0
ax.title_text_property.opacity = 0.0
mlab.savefig(savedir + 'S' + str(scan) + comment + '_axes.png', figure=myfig)
ax.axes.x_axis_visibility = False
ax.axes.y_axis_visibility = False
ax.axes.z_axis_visibility = False
mlab.savefig(savedir + 'S' + str(scan) + comment + '.png', figure=myfig)
mlab.draw(myfig)

if make_movie:
    if output_format == 'mp4':
        animation = mpy.VideoClip(rotate_scene,
                                  duration=duration).resize(width=fig_size[0],
                                                            height=fig_size[1])
Пример #24
0
xmin = qx[0] * 1E0
xmax = qx[-1] * 1E0
ymin = qy[0] * 1E0
ymax = qy[-1] * 1E0
zmin = qz[0] * 1E0
zmax = qz[-1] * 1E0
obj = mlab.contour3d(plot_data,
                     contours=10,
                     opacity=0.5,
                     transparent=False,
                     extent=[qz[0], qz[-1], qy[0], qy[-1], qx[0],
                             qx[-1]])  #  , vmin=0, vmax=0.8)
mlab.axes(ranges=[xmin, xmax, ymin, ymax, zmin, zmax])
mlab.xlabel('$Q_z$ [$\AA^{-1}$]')
mlab.ylabel('$Q_y$ [$\AA^{-1}$]')
mlab.zlabel('$Q_z$ [$\AA^{-1}$]')
#C:\Users\Sanna\Documents\Beamtime\NanoMAX062017\Analysis_ptypy\scan461_\bragg_peak_stacking\InP\
#mlab.savefig('pos_'+ str(pos) +'.jpg')

# Another way to maka an iso surface. Can also be combined with cut planes
position = 0


def iso_pipeline_plot():
    src = mlab.pipeline.scalar_field(
        plot_data)  # this creates a regular space data
    mlab.pipeline.iso_surface(src,
                              contours=[
                                  diff_data[position].min() +
                                  0.1 * diff_data[position].ptp(),
                              ],
Пример #25
0
    except TypeError:
        a_result = np.NaN
        delta = np.NaN

    delta_dspace = np.append(delta_dspace, [delta])

    print(i)

#Kw_zspace_sap = Kw_zspace_sap * 10**1
#Ka2_yspace_sap = Ka2_yspace_sap * 10**-2
#Ka1_xspace_sap = Ka1_xspace_sap * 10**-2
#use for wrong scaling correction

figure = mlab.figure('DensityPlot')
pts = mlab.points3d(Ka1_xspace_sap,
                    Ka2_yspace_sap,
                    Kw_zspace_sap,
                    delta_dspace,
                    scale_mode='none',
                    scale_factor=0.0005)
#scale_factor = 0.0000001 or 0.001
mlab.xlabel('Ka1,unit : 10^2')
mlab.ylabel('Ka2,unit : 10^2')
mlab.zlabel('Kw,unit : 10^-1')

mlab.axes(None, extent=[0, 0.1, 0, 0.1, 0, 0.1])
#use for wrong scaling correction too
#mlab.axes()

mlab.show()
Пример #26
0
                                 colormap='YlGnBu',
                                 opacity=0.01)
mlab.pipeline.image_plane_widget(src,
                                 plane_orientation='y_axes',
                                 slice_index=Ny / 2,
                                 colormap='YlGnBu',
                                 opacity=0.01)
mlab.pipeline.image_plane_widget(src,
                                 plane_orientation='x_axes',
                                 slice_index=Nx / 2,
                                 colormap='YlGnBu',
                                 opacity=0.01)
mlab.scalarbar()
mlab.xlabel('x', object=src)
mlab.ylabel('y', object=src)
mlab.zlabel('z', object=src)

# initial energy
vx = 0.5 * kxm * (v + vold)
vy = 0.5 * kym * (v + vold)
vz = 0.5 * kzm * (v + vold)
ux = numpy.fft.ifftn(vx)
uy = numpy.fft.ifftn(vy)
uz = numpy.fft.ifftn(vz)
Kineticenergy = 0.5 * ((u - uold) / dt)**2
Strainenergy = 0.5 * (ux)**2 + 0.5 * (uy)**2 + 0.5 * (uz)**2
Potentialenergy = 0.5 * (0.5 * (u + uold))**2 - Es * 0.25 * (0.5 *
                                                             (u + uold))**4
Kineticenergy = numpy.fft.fftn(Kineticenergy)
Strainenergy = numpy.fft.fftn(Strainenergy)
Potentialenergy = numpy.fft.fftn(Potentialenergy)
Пример #27
0
def Apply(db_tested, db_train, sysnames, alpha=0.05, N=50):
    """
    Inputs: A data frame of objects to be tested, a training data set, and a list of ratios to use
    Outputs: An array of booleans of indices in the test data frame which have passed the filter
    """

    #Reconstruct element names from ratio names
    el_list = []
    for r in sysnames:
        el_list.extend(DecomposeR(r))

    #Get matrices for the tested and training datasets
    print("ApplyLOF: Normalise & take logarithms")
    dTest = LogRatioMatrix(db_tested, el_list, stripNaNs=False)
    dTrain = LogRatioMatrix(db_train, el_list, stripNaNs=True)

    #Compute extents of training data for each dimension, renormalise all data
    dTrain, midpts, extents = Renormalise(dTrain)
    dTest = Renormalise(dTest, midpts, extents)[0]

    #Fill in missing data
    print("ApplyLOF: Interpolate missing values")
    dTest = FillNaNs(dTrain, dTest, N)

    print("ApplyLOF: Compute testing set factors")
    LOF_test = ComputeLOF(dTest, dTrain, N)
    print("ApplyLOF: Compute training set factors")
    LOF_ref = ComputeLOF2(dTrain, N)

    #Prepare the rejections filter
    Filter = np.full(dTest.shape[0], True, dtype=np.bool)

    #Find cutoff LOF value for the training set
    c = np.percentile(LOF_ref, 100 * (1 - alpha))
    passing_samples = (LOF_test < c)
    Filter = (Filter & passing_samples)
    print("ApplyLOF: Evaluate with c=" + str(c))

    # DEBUG: Plot results with mayavi
    if _debugVisualise:
        from mayavi import mlab
        dTest[np.isinf(dTest)] = 1000
        LOF_test[np.isinf(LOF_test)] = 1000
        mlab.figure('RSV ')
        mlab.points3d(dTrain.T[-3],
                      dTrain.T[-2],
                      dTrain.T[-1],
                      LOF_ref,
                      scale_mode='none',
                      scale_factor=0.01)
        mlab.axes()
        mlab.xlabel(sysnames[-3])
        mlab.ylabel(sysnames[-2])
        mlab.zlabel(sysnames[-1])
        mlab.show()
        mlab.figure('RSV ')
        mlab.points3d(dTrain.T[-6],
                      dTrain.T[-5],
                      dTrain.T[-4],
                      LOF_ref,
                      scale_mode='none',
                      scale_factor=0.01)
        mlab.axes()
        mlab.xlabel(sysnames[-6])
        mlab.ylabel(sysnames[-5])
        mlab.zlabel(sysnames[-4])
        mlab.show()

    #Return boolean mask for test data frame
    return Filter
Пример #28
0
j=mlab.quiver3d(xs,ys,zs,jx,jy,jz, scale_factor=.002,color=(1,0,0),name='J')
m=mlab.quiver3d(xs,ys,zs,baryX,baryY,baryZ, scale_factor=.013,color=(0,0,1),name='Mb')
t=mlab.quiver3d(xs,ys,zs,tx,ty,tz, scale_factor=.1,color=(0,1,0),name='T/W')
pt=mlab.quiver3d(xs,ys,zs,us,vs,ws, scale_factor=.01,color=(1,1,1),name='projT/W')
mlab.text(.01,.2,'J   ',color=(1,0,0),width=0.1)
mlab.text(.01,.4,'Mb  ',color=(0,0,1),width=0.1)
mlab.text(.01,.5,'T/W ',color=(0,1,0),width=0.1)
mlab.text(.01,.6,'-projT/W',color=(1,1,1),width=0.1)
mlab.title("Gradients along track")


mlab.axes(color=(.7,.7,.7),xlabel='a')
mlab.xlabel('a')
mlab.ylabel('edMax')
mlab.zlabel('rpoe')

mlab.show()

exit()
###############################
# TEST plotting and stepDown function
def func(a,T):
    return -2*(a*a + T*T/2. -a*T/2.) + (a*a*a*a*.7 + T*T*T*T*.34)



p0=(.10,.10,.15)
p1=(.30,.20,.10)

xs=[]
Пример #29
0
import numpy as np
from mayavi import mlab

X = np.array([.49,.98,1.47,1.96,2.45,.49,.98,1.47,1.96,2.45,.49,.98,1.47,1.96,2.45,.49,.98,1.47,1.96,2.45,.49,.98,1.47,1.96,2.45])
Y = np.array([.49,.49,.49,.49,.49,.98,.98,.98,.98,.98,1.47,1.47,1.47,1.47,1.47,1.96,1.96,1.96,1.96,1.96,2.45,2.45,2.45,2.45,2.45])
Z = np.array([0,.0078,.0245,.0485,.0784,.0230,.0235,.0358,.0578,.0887,.0583,.0505,.0573,.0760,.1034,.1005,.0892,.0916,.1078,.1318,.1593,.1507,.1421,.1504,.1715])

#X = np.array([0,1,0,1,.75])
#Y = np.array([0,0,1,1,.75])
#Z = np.array([1,1,1,1,2])

pts = mlab.points3d(X,Y,Z,Z)

mesh = mlab.pipeline.delaunay2d(pts)

pts.remove()

surf = mlab.pipeline.surface(mesh)

mlab.xlabel("Fx (N)")
mlab.ylabel("Fy (N)")
mlab.zlabel("Delta Potential (J)")
mlab.show()
def main_function(file):
    # Process the data to arrays
    # file = "HP_1a1.csv"
    data = pd.read_csv(file)
    data = np.array(data)

    # x: Retention time
    # y: m/z ratio
    # z: Intensity
    x = data[:, 0]
    y = data[:, 1]
    z = data[:, 2]

    # Retrieve scaling scalars from scale function
    x_scale, y_scale, z_scale = scale_function(data)

    # Retrieve rate to downsample data
    rate = rate_downsampling(file)

    # Begin full downsampling of data

    # These lists store the final data of each axis
    xnew = []
    ynew = []
    znew = []

    # These lists are temporary placeholders for each section/bucket of each axis
    data_BucketX = []
    data_BucketY = []
    data_BucketZ = []

    index = 0
    for item in x:
        # Ignore the first line
        if index == 0:
            index += 1
            continue
        # Retention values are the same, grouped into same bucket
        if item == x[index - 1]:
            data_BucketX.append(item)
            data_BucketY.append(y[index])
            data_BucketZ.append(z[index])
        # Different bucket
        else:
            # Ignore buckets with fewer than 100 data points
            if len(data_BucketX) < 100:
                index += 1
                continue
            xn = []
            yn = []
            zn = []

            # Downsample length of each bucket

            # TODO: Fix the rate error
            # An error like the one below may occur with regards to rate:
            #   ERROR: In C:\VPP\standalone-build\VTK-source\Filters\Core\vtkDelaunay2D.cxx, line 819
            #   vtkDelaunay2D (0000027AE2A2ACF0): ERROR: Edge [118461 118462] is non-manifold!!!
            sample = int(len(data_BucketX) / rate)
            xn.extend(signal.resample(data_BucketX, sample))
            yn.extend(signal.resample(data_BucketY, sample))
            zn.extend(signal.resample(data_BucketZ, sample))

            i = 0
            for foo in zn:
                # Rescaled each axis
                xnew.append(xn[i] * x_scale)
                ynew.append(yn[i] / y_scale)
                znew.append(zn[i] / z_scale)
                i += 1

            data_BucketX.clear()
            data_BucketY.clear()
            data_BucketZ.clear()
        index += 1

    # From here, continue to remove data, specifically intensity values, that are too small and irrelevant

    # Temporary list to store indices
    foo = []

    # Set a max z-axis threshold
    z_threshold = max(znew) * 0.01

    # Loop through intensity list
    for i in range(len(znew)):
        # Append to the temporary list the indices of intensity values that are less than the threshold
        if znew[i] < z_threshold:
            foo.append(i)

    # Removes all corresponding elements from each array
    # Must remove from all three lists to preserve uniformity
    xnew = np.delete(xnew, foo)
    ynew = np.delete(ynew, foo)
    znew = np.delete(znew, foo)

    # From here, we are ready to get our plots set up

    # Dummy object to get accurate and original intensity values for colorbar label
    original = mlab.points3d(x, y, z, z, mode='point')
    original.remove()

    # Visualize the points
    pts = mlab.points3d(xnew, ynew, znew, znew, mode='point')

    # Create and visualize the mesh
    mesh = mlab.pipeline.delaunay2d(pts)
    surf = mlab.pipeline.surface(mesh)
    pts.remove()

    # Simple plot axis info rendering
    mlab.xlabel("Retention")
    mlab.ylabel("m/z")
    mlab.zlabel("Intensity")

    # Add text to plot indicating how each axis was rescaled
    mlab.text(0.5, 0.80, 'Retention scaled up by %.2f' % x_scale, width=0.8)
    mlab.text(0.5, 0.85, 'm/z scaled down by %.2f' % y_scale, width=0.8)
    mlab.text(0.5, 0.90, 'Intensity scaled down by %.2f' % z_scale, width=1.0)

    # Colorbar with original intensity values
    colorbar = mlab.colorbar(object=original,
                             title='Intensity',
                             orientation='vertical')
    colorbar.scalar_bar_representation.position = [0.85, 0.18]

    # Show the final plot scene
    mlab.show()
Пример #31
0
def plot3(history, *args, title=None, give=False, plot_style='default',
         axis_label=None, make_square=True, figsize=None,backend='matplotlib',
         **kwargs):

    '''
    Parameters:

    > *args,**kwargs : are passed to matplotlib's pyplot.plot function

    > FIG_TITLE: the title given to the figure. Only used is a figure is not given to plot on

    > GIVE : this command makes the method return the figure after the path data is
            plotted.
    > BACKEND: either matplotlib or mayavi.
    '''

    if backend == 'matplotlib':

        # setting style
        style.use(plot_style)

        # creating figure
        if figsize:
            fig = plt.figure(figsize=figsize)
        else:
            fig = plt.figure()                
        
        ax = fig.gca(projection='3d')
        ax.set_aspect('equal')

        # makes history a numpy array
        history = array(history)


        # getting motion history
        X = history[:, 0]
        Y = history[:, 1]
        Z = history[:, 2]

        # To Do add optional label to the first point
        # Plots the 3 past printer positions on figure
        ax.plot(X, Y, Z, *args, **kwargs)

        # Keeps aspect ratio square but can be computationally expensive for large GCODE
        if make_square:
            # Keeps aspect ratio square
            # http://stackoverflow.com/questions/13685386
            # numpy array
            max_range = array([X.max()-X.min(),
                                  Y.max()-Y.min(),
                                  Z.max()-Z.min()]).max() / 2.0

            mean_x = X.mean()
            mean_y = Y.mean()
            mean_z = Z.mean()
            ax.set_xlim(mean_x - max_range, mean_x + max_range)
            ax.set_ylim(mean_y - max_range, mean_y + max_range)
            ax.set_zlim(mean_z - max_range, mean_z + max_range)

        # labeling figure axes
        if axis_label:
            ax.set_xlabel(axis_label[0])
            ax.set_ylabel(axis_label[1])
            ax.set_zlabel(axis_label[2])

        # sets the figure title
        if title:
            ax.set_title(title)


        # determines whether to show the figure or to return it
        if give:
            return ax
        else:
            # showing figure
            plt.show()

    elif backend == 'mayavi':

        # getting the needing import to plot in mayavi
        from mayavi import mlab

        # makes history a numpy array
        history = array(history)

        # getting x,y,z coordinates
        x = history[:,0]
        y = history[:,1]
        z = history[:,2]

        # changin the figure size
        if figsize:
            mlab.figure(size=figsize)
        else:
            mlab.figure()
            
        # plotting the line plot
        fig = mlab.plot3d(x,y,z, *args, **kwargs)

        # setting label corrdinates
        # labeling figure axes
        if axis_label:
            mlab.xlabel(axis_label[0])
            mlab.ylabel(axis_label[1])
            mlab.zlabel(axis_label[2])

        # sets the figure title
        if title:
            mlab.title(title)

        # showing the figure
        if give:
            return fig, mlab
        else:
            mlab.show()

    # end of view
    return
Пример #32
0
    def plotWithCondition(self, condition):
        assert isinstance(condition,str), "must enter a condition!"

        cursor=self.dbConnection.cursor()

        xname = self.independentVars[0]
        yname = self.independentVars[1]
        xs=[]

        for i in cursor.execute("SELECT DISTINCT " + xname + " FROM models ORDER BY "
                                + xname):
            val = i[0]
            if xname == "edMax":
                val = val#/1.0e15
            xs.append(val)
        ys=[]
        for i in cursor.execute("SELECT DISTINCT " + yname + " FROM models ORDER BY "
                                + yname):
            val = i[0]
            if yname == "edMax":
                val = val#/1.0e15
            ys.append(val)
        #print xs
        #print ys

        #####
        #
        xs, ys =  meshgrid(xs,ys)
        # reverse order since mlab uses mgrid format which returns transpose of matrices in meshgrid style
        xs = xs.transpose()
        ys = ys.transpose()
        #
        #####

        def lookup(x,y):
            assert x >= 0.,  "Lookup only well defined for x >=0"
            assert y >= 0.,  "Lookup only well defined for y >=0"
            tolerance = 1.0001
            additionalConditions=[]
            if not x == 0:
                additionalConditions.append( xname + ">" + str(x/tolerance) )
                additionalConditions.append( xname + "<" + str(x*tolerance) )
            else:
                additionalConditions.append(xname + "=" + str(x))
            if not y == 0:
                additionalConditions.append(yname + ">" + str(y/tolerance))
                additionalConditions.append( yname + "<" + str(y*tolerance))
            else:
                additionalConditions.append(yname + "=" + str(y))
            additionalConditions.append(condition)
            #print additionalConditions
            value= queryDBGivenParams(self.dependentVar,
                {},
                cursor,"models", tuple( additionalConditions ))
            #print x,y, value
            if value:
                if len(value[0]) > 1 :
                    print "WARNING MORE THAN ONE VALUE FOUND!!!"
                return value[0][0]
            else:
                print "WARNING: no value"
                return 0.0

        zs = zeros(xs.shape)

        for i in range(len(xs)):
            row = xs[i]
            #print row
            for j in range(len(row)):
                #print xs[i][j], ys[i][j]
                zs[i][j] = lookup(xs[i][j], ys[i][j] )

        if xname == "edMax":
            xs = array(xs*1e-15)
        else:
            xs = array(xs)

        if yname == "edMax":
            ys=array(ys*1e-15)
        else:
            ys = array(ys)
        zs = array(zs)
        #print xs
        #print ys
        #print zs
        #print size(xs)
        #print size(ys)
        #print size(zs)
        fig=mlab.figure(bgcolor=(.5,.5,.5))
        extents=[xs.min(),xs.max(),
                 ys.min(),ys.max(),
                 zs.min(),zs.max()]

        mlab.surf(xs,ys,zs, colormap="bone",representation='wireframe',
            extent=extents
        )

        mlab.axes(extent=extents,nb_labels=6)
        mlab.outline(extent=extents)
        mlab.xlabel(xname)
        mlab.ylabel(yname)
        mlab.zlabel(self.dependentVar)
Пример #33
0
pts = mlab.points3d(X, Y, Z, Z)

# Triangulate based on X, Y with Delaunay 2D algorithm.
# Save resulting triangulation.
mesh = mlab.pipeline.delaunay2d(pts)

# Remove the point representation from the plot
pts.remove()

# Draw a surface based on the triangulation
surf = mlab.pipeline.surface(mesh)

# Simple plot.
mlab.xlabel("x")
mlab.ylabel("y")
mlab.zlabel("z")
mlab.show()

print x
print y
print s









foo = []

# set a max z-axis threshold
z_threshold = max(znew) * 0.01

for i in range(len(znew)):
    # append to a list the indices of z-axis values that are less than the threshold
    if znew[i] < z_threshold:
        foo.append(i)

# removes all corresponding elements from each array
xnew = np.delete(xnew, foo)
ynew = np.delete(ynew, foo)
znew = np.delete(znew, foo)

# Visualize the points
# pts = mlab.points3d(x_3d, y_3d, z_3d, z_3d, mode='point')
pts = mlab.points3d(xnew, ynew, znew, znew, mode='point')
# pts = mlab.points3d(xnew, ynew, znew, znew, mode='point', scale_factor=3.0)

# Create and visualize the mesh
mesh = mlab.pipeline.delaunay2d(pts)
surf = mlab.pipeline.surface(mesh)
pts.remove()

# Simple plot axis info rendering
mlab.xlabel("Retention")
mlab.ylabel("m/z")
mlab.zlabel("Intensity")
mlab.show()
Пример #35
0
def plotter(profiles, smsh):
    """
    Mesh and profiles plotter.
    :param profiles:
        A list of :class:`openquake.hazardlib.geo.line.Line` instances
    :param smsh:
        A :class:`numpy.ndarray` instance
    """
    #
    if MAYAVI:
        _ = mlab.figure(size=(600, 400))
        #
        scl = -0.01
        delta = 0.1
        wdt = 0.001
        # initialize extremes
        xmi = +1e10
        ymi = +1e10
        zmi = +1e10
        xma = -1e10
        yma = -1e10
        zma = -1e10
        # plotting profiles
        for l in profiles:
            coo = [[p.longitude, p.latitude, p.depth * scl] for p in l]
            coo = np.array(coo)
            mlab.plot3d(coo[:, 0],
                        coo[:, 1],
                        coo[:, 2],
                        color=(0, 1, 0),
                        line_width=wdt,
                        opacity=0.2)
            mlab.points3d(coo[0, 0],
                          coo[0, 1],
                          coo[0, 2],
                          color=(1., 0.5, 0.),
                          line_width=wdt,
                          scale_factor=0.1)
            xmi = min(xmi, np.amin(coo[:, 0]) - delta)
            xma = max(xma, np.amax(coo[:, 0]) + delta)
            ymi = min(ymi, np.amin(coo[:, 1]) - delta)
            yma = max(yma, np.amax(coo[:, 1]) + delta)
            zmi = min(zmi, np.amin(coo[:, 2]) - delta)
            zma = max(zma, np.amax(coo[:, 2]) + delta)
        # plotting mesh
        smsh[:, :, 2] *= scl
        for i in range(smsh.shape[0]):
            k = np.isfinite(smsh[i, :, 0])
            if np.any(k):
                _ = mlab.plot3d(smsh[i, k, 0],
                                smsh[i, k, 1],
                                smsh[i, k, 2],
                                color=(1, 0, 0),
                                line_width=wdt,
                                tube_radius=0.01)
        for i in range(smsh.shape[1]):
            k = np.isfinite(smsh[:, i, 0])
            if sum(k):
                _ = mlab.plot3d(smsh[k, i, 0],
                                smsh[k, i, 1],
                                smsh[k, i, 2],
                                color=(1, 0, 0),
                                line_width=wdt,
                                tube_radius=0.01)
        # decoration
        axes = mlab.axes(extent=[xmi, xma, ymi, yma, zmi, zma])
        axes.label_text_property.font_size = 6
        axes.axes.font_factor = 1.0
        mlab.xlabel('Longitude\n')
        mlab.ylabel('Latitude\n')
        mlab.zlabel('Depth\n [km*0.01]')
        mlab.show()
Пример #36
0
thetag = np.linspace(0.,2.*pi,ntheta)

phi, theta = np.meshgrid(phig,thetag)

rho = np.zeros_like(phi)

sinphi = sin(phi); cosphi = cos(phi); sinth = sin(theta); costh = cos(theta)

m = 0
for k in range(K):
    for j in range(J):
        for i in range(I):
            rho += (c[m]*np.power(sinphi,i+j) *
                    np.power(cosphi,k) *
                    np.power(sinth,j) *
                    np.power(costh,i))
            m += 1

xs = rho * sin(phi) * cos(theta)
ys = rho * sin(phi) * sin(theta)
zs = rho * cos(phi)

import mayavi.mlab as mylab
fig=mylab.figure(1,bgcolor=(0,0,0))
mylab.clf()
ps = 1.*np.ones_like(x)
mylab.points3d(x,y,z,(ps), scale_factor=0.025,colormap='Spectral',opacity=1.)
mylab.mesh(xs, ys, zs,  colormap="bone",opacity=0.5)
mylab.outline();
mylab.xlabel('X'); mylab.ylabel('Y'); mylab.zlabel('Z')
Пример #37
0
unb = numpy.zeros((Nx, Ny), dtype=complex)
v = numpy.zeros((Nx, Ny), dtype=complex)
vna = numpy.zeros((Nx, Ny), dtype=complex)
vnb = numpy.zeros((Nx, Ny), dtype=complex)
mass = numpy.zeros((Nx, Ny), dtype=complex)
test = numpy.zeros((numplots - 1), dtype=float)
tdata = numpy.zeros((numplots - 1), dtype=float)

u = numpy.exp(-(xx**2 + yy**2))
v = numpy.fft.fftn(u)
usquared = abs(u)**2
src = mlab.surf(xx, yy, usquared, colormap='YlGnBu', warp_scale='auto')
mlab.scalarbar()
mlab.xlabel('x', object=src)
mlab.ylabel('y', object=src)
mlab.zlabel('abs(u)^2', object=src)

# initial mass
usquared = abs(u)**2
mass = numpy.fft.fftn(usquared)
ma = numpy.real(mass[0, 0])
print(ma)
maO = ma
t = 0.0
tdata[0] = t
plotnum = 0
#solve pde and plot results
for nt in xrange(numplots - 1):
    for n in xrange(plotgap):
        vna = v * numpy.exp(complex(0, 0.5) * dt * (k2xm + k2ym))
        una = numpy.fft.ifftn(vna)
Пример #38
0
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-

import numpy as np
from mayavi import mlab

X = np.array([0, 1, 0, 1, 0.75])
Y = np.array([0, 0, 1, 1, 0.75])
Z = np.array([1, 1, 1, 1, 2])

# Define the points in 3D space
# including color code based on Z coordinate.
pts = mlab.points3d(X, Y, Z, Z)

# Triangulate based on X, Y with Delaunay 2D algorithm.
# Save resulting triangulation.
mesh = mlab.pipeline.delaunay2d(pts)

# Remove the point representation from the plot
pts.remove()

# Draw a surface based on the triangulation
surf = mlab.pipeline.surface(mesh)

# Simple plot.
mlab.xlabel("x")
mlab.ylabel("y")
mlab.zlabel("z")
mlab.show()
Пример #39
0
# Loop over the values of the slice array, to produce an image of the vector
# field for each slice
for i in range(len(slice_arr)):
    # Create a new figure
    fig = mlab.figure(size=(800, 700))

    # Create an image of the vector field for this slice of the array
    mlab.quiver3d(X[slice_arr[i],::8,::8], Y[slice_arr[i],::8,::8],\
     Z[slice_arr[i],::8,::8], mag_x[slice_arr[i],::8,::8],\
     mag_y[slice_arr[i],::8,::8],mag_z[slice_arr[i],::8,::8],scalars =\
      B_mag[slice_arr[i],::8,::8], vmax=vmax,vmin=vmin)

    # Make the co-ordinate axes appear on the plot
    mlab.xlabel('x-axis')
    mlab.ylabel('y-axis')
    mlab.zlabel('z-axis')

    # Rotate the camera so that it is face on
    mlab.view(azimuth=0, elevation=90)

    # Add a colourbar to the figure
    mlab.colorbar(orientation='vertical')

    # Save the figure
    mlab.savefig(data_loc + 'B_vectors_slice_{}.jpg'.format(slice_arr[i]))

    # Close the figure
    mlab.close()

    # Print a line to the screen to show that the figure has been saved
    print 'Figure saved for slice number {}'.format(i)
Пример #40
0
EnStr = numpy.zeros((numplots), dtype=float)
En = numpy.zeros((numplots), dtype=float)
Enchange = numpy.zeros((numplots - 1), dtype=float)
tdata = numpy.zeros((numplots), dtype=float)
nonlin = numpy.zeros((Nx, Ny), dtype=float)
nonlinhat = numpy.zeros((Nx, Ny), dtype=complex)

u = 0.1 * numpy.exp(-(xx**2 + yy**2)) * numpy.sin(10 * xx + 12 * yy)
uold = u
v = numpy.fft.fft2(u)
vold = numpy.fft.fft2(uold)
src = mlab.surf(xx, yy, u, colormap='YlGnBu', warp_scale='auto')
mlab.scalarbar(object=src)
mlab.xlabel('x', object=src)
mlab.ylabel('y', object=src)
mlab.zlabel('u', object=src)
# initial energy
vx = 0.5 * kxm * (v + vold)
vy = 0.5 * kym * (v + vold)
ux = numpy.fft.ifft2(vx)
uy = numpy.fft.ifft2(vy)
Kineticenergy = 0.5 * ((u - uold) / dt)**2
Strainenergy = 0.5 * (ux)**2 + 0.5 * (uy)**2
Potentialenergy = 0.5 * (0.5 * (u + uold))**2 - Es * 0.25 * (0.5 *
                                                             (u + uold))**4
Kineticenergy = numpy.fft.fft2(Kineticenergy)
Strainenergy = numpy.fft.fft2(Strainenergy)
Potentialenergy = numpy.fft.fft2(Potentialenergy)
EnKin[0] = numpy.real(Kineticenergy[0, 0])
EnPot[0] = numpy.real(Potentialenergy[0, 0])
EnStr[0] = numpy.real(Strainenergy[0, 0])
Пример #41
0
unb=numpy.zeros((Nx,Ny), dtype=complex)
v=numpy.zeros((Nx,Ny), dtype=complex)
vna=numpy.zeros((Nx,Ny), dtype=complex)
vnb=numpy.zeros((Nx,Ny), dtype=complex)
mass=numpy.zeros((Nx,Ny), dtype=complex)
test=numpy.zeros((numplots-1),dtype=float)
tdata=numpy.zeros((numplots-1), dtype=float)

u=numpy.exp(-(xx**2 + yy**2 )) 
v=numpy.fft.fftn(u)
usquared=abs(u)**2
src = mlab.surf(xx,yy,usquared,colormap='YlGnBu',warp_scale='auto')
mlab.scalarbar()
mlab.xlabel('x',object=src)
mlab.ylabel('y',object=src)
mlab.zlabel('abs(u)^2',object=src)

# initial mass
usquared=abs(u)**2
mass=numpy.fft.fftn(usquared)
ma=numpy.real(mass[0,0])
print(ma)
maO=ma
t=0.0
tdata[0]=t
plotnum=0
#solve pde and plot results
for nt in xrange(numplots-1):
    for n in xrange(plotgap):
        vna=v*numpy.exp(complex(0,0.5)*dt*(k2xm+k2ym))
        una=numpy.fft.ifftn(vna)
Пример #42
0
    def plotWithCondition(self, condition):
        assert isinstance(condition, str), "must enter a condition!"

        cursor = self.dbConnection.cursor()

        xname = self.independentVars[0]
        yname = self.independentVars[1]
        xs = []

        for i in cursor.execute("SELECT DISTINCT " + xname +
                                " FROM models ORDER BY " + xname):
            val = i[0]
            if xname == "edMax":
                val = val  #/1.0e15
            xs.append(val)
        ys = []
        for i in cursor.execute("SELECT DISTINCT " + yname +
                                " FROM models ORDER BY " + yname):
            val = i[0]
            if yname == "edMax":
                val = val  #/1.0e15
            ys.append(val)
        #print xs
        #print ys

        #####
        #
        xs, ys = meshgrid(xs, ys)
        # reverse order since mlab uses mgrid format which returns transpose of matrices in meshgrid style
        xs = xs.transpose()
        ys = ys.transpose()

        #
        #####

        def lookup(x, y):
            assert x >= 0., "Lookup only well defined for x >=0"
            assert y >= 0., "Lookup only well defined for y >=0"
            tolerance = 1.0001
            additionalConditions = []
            if not x == 0:
                additionalConditions.append(xname + ">" + str(x / tolerance))
                additionalConditions.append(xname + "<" + str(x * tolerance))
            else:
                additionalConditions.append(xname + "=" + str(x))
            if not y == 0:
                additionalConditions.append(yname + ">" + str(y / tolerance))
                additionalConditions.append(yname + "<" + str(y * tolerance))
            else:
                additionalConditions.append(yname + "=" + str(y))
            additionalConditions.append(condition)
            #print additionalConditions
            value = queryDBGivenParams(self.dependentVar, {}, cursor, "models",
                                       tuple(additionalConditions))
            #print x,y, value
            if value:
                if len(value[0]) > 1:
                    print "WARNING MORE THAN ONE VALUE FOUND!!!"
                return value[0][0]
            else:
                print "WARNING: no value"
                return 0.0

        zs = zeros(xs.shape)

        for i in range(len(xs)):
            row = xs[i]
            #print row
            for j in range(len(row)):
                #print xs[i][j], ys[i][j]
                zs[i][j] = lookup(xs[i][j], ys[i][j])

        if xname == "edMax":
            xs = array(xs * 1e-15)
        else:
            xs = array(xs)

        if yname == "edMax":
            ys = array(ys * 1e-15)
        else:
            ys = array(ys)
        zs = array(zs)
        #print xs
        #print ys
        #print zs
        #print size(xs)
        #print size(ys)
        #print size(zs)
        fig = mlab.figure(bgcolor=(.5, .5, .5))
        extents = [xs.min(), xs.max(), ys.min(), ys.max(), zs.min(), zs.max()]

        mlab.surf(xs,
                  ys,
                  zs,
                  colormap="bone",
                  representation='wireframe',
                  extent=extents)

        mlab.axes(extent=extents, nb_labels=6)
        mlab.outline(extent=extents)
        mlab.xlabel(xname)
        mlab.ylabel(yname)
        mlab.zlabel(self.dependentVar)
Пример #43
0
                   us,
                   vs,
                   ws,
                   scale_factor=.01,
                   color=(1, 1, 1),
                   name='projT/W')
mlab.text(.01, .2, 'J   ', color=(1, 0, 0), width=0.1)
mlab.text(.01, .4, 'Mb  ', color=(0, 0, 1), width=0.1)
mlab.text(.01, .5, 'T/W ', color=(0, 1, 0), width=0.1)
mlab.text(.01, .6, '-projT/W', color=(1, 1, 1), width=0.1)
mlab.title("Gradients along track")

mlab.axes(color=(.7, .7, .7), xlabel='a')
mlab.xlabel('a')
mlab.ylabel('edMax')
mlab.zlabel('rpoe')

mlab.show()

exit()


###############################
# TEST plotting and stepDown function
def func(a, T):
    return -2 * (a * a + T * T / 2. - a * T / 2.) + (a * a * a * a * .7 +
                                                     T * T * T * T * .34)


p0 = (.10, .10, .15)
p1 = (.30, .20, .10)
Пример #44
0
                mlab.outline(extent=[
                    np.min(x1),
                    np.max(x1),
                    np.min(x2),
                    np.max(x2), v0, v1
                ])
                #WARNING: the z-axis will include the warp factor and is highly misleading
                #mlab.axes(src,z_axis_visibility=False,extent=ext,xlabel=plot_dict['xlabel'],ylabel=plot_dict['ylabel'],zlabel=plotter.name)
                mlab.view(azimuth=90,
                          elevation=60,
                          distance=5 * np.max(sizes),
                          focalpoint=origin)
            s = s0 * len(slices[1]) + s1
            mlab.xlabel(plot_dict['xlabel'])
            mlab.ylabel(plot_dict['ylabel'])
            mlab.zlabel(plot_dict['blabel'])
            mlab.savefig('tempfile{:03d}.png'.format(s))

# 3D PLOTS

if num_slice_axes == 1:
    for s in slices[0]:
        print('Rendering frame', s, '...')
        data_slice, plot_dict = plotter.volume3d(slicing_spec, s, dyn_range)
        data_slice = data_slice.astype(np.double)
        ext = plot_dict['extent']
        dims = plot_dict['dims']
        x1 = np.einsum('i,j,k', plot_dict['xpts'], np.ones(dims[1]),
                       np.ones(dims[2])).astype(np.double)
        x2 = np.einsum('i,j,k', np.ones(dims[0]), plot_dict['ypts'],
                       np.ones(dims[2])).astype(np.double)
def read_seismic():
    try:
        t0 = time.time()
        data = segy_dir_path.get()
        #use obspy to read data
        stream = _read_segy(data, headonly=True)
        #create stream object
        num_trace = len(stream.traces)
        #get ns from binary header
        ns = stream.binary_file_header.number_of_samples_per_data_trace

        min_il = int(min_inline.get())
        max_il = int(int(max_inline.get()) + 1)
        il_step = int(inline_step.get())
        min_xl = int(min_xline.get())
        max_xl = int(int(max_xline.get()) + 1)
        xl_step = int(xline_step.get())

        inline_range = np.arange(min_il, max_il, il_step)
        xline_range = np.arange(min_xl, max_xl, xl_step)

        total_traces_calculated = (len(inline_range) * len(xline_range))
        total_missing_traces = int(total_traces_calculated - num_trace)

        lines = [
            "Total no of traces read     : {}".format(num_trace),
            "Total number of calculated traces :{}".format(
                total_traces_calculated),
            "Total traces to pad: {}".format(total_missing_traces)
        ]

        tkinter.messagebox.showinfo("INFO", "\n".join(lines))

        data = np.stack(t.data for t in stream.traces)
        #get z dim
        bounds, nt = data.shape
        data_t = data.T
        #Pad data with zero traces
        data_padded = np.pad(data_t, [(0, 0), (0, total_missing_traces)],
                             mode='constant')
        data_padded = data_padded.T
        #Reshape data to a 3d cube
        shaped_data = np.reshape(data_padded,
                                 (inline_range.size, xline_range.size, nt))
        #calculate the right colorbar scale
        vm = np.percentile(shaped_data, 99)

        #Define the mayavi data source
        source = mlab.pipeline.scalar_field(shaped_data)
        source.spacing = [il_step, xl_step, -4]

        for axis in ['x', 'y', 'z']:
            plane = mlab.pipeline.image_plane_widget(
                source,
                plane_orientation='{}_axes'.format(axis),
                colormap="gray",
                vmin=-vm,
                vmax=vm,
                slice_index=20)
            plane.module_manager.scalar_lut_manager.reverse_lut = True
            mlab.xlabel("XLINE")
            mlab.ylabel("INLINE")
            mlab.zlabel("TIME/DEPTH")
            #mlab.title("3D Seismic Cube : {}".format(str(segy_dir_path.get())))
            #mlab.colorbar()

        mlab.show()

    except ValueError:
        tk.messagebox.showinfo("ERROR", "Please check your input bounds")
        close_window()

    except FileNotFoundError:
        tk.messagebox.showinfo("ERROR", "Please check your input File")
        close_window()
Пример #46
0
    u[i + 1] = u[i] + h * g1(rho[i], u[i], v[i])
    v[i + 1] = v[i] + h * g2(rho[i], u[i], v[i])
    time[i + 1] = time[i] + h

ux, vx, rhox = np.mgrid[-2:2:50j, -2:2:50j, -1.5:1.5:50j]
values = -(rhox**3 - rhox) * (3.0 * rhox**2 -
                              1) - ux * (rhox + 1) - vx * rhox - w * (rhox - 1)
mlab.contour3d(ux, vx, rhox, values, contours=[0], opacity=0.5)
# values_u = a*(1.0 - ux) - eta(rhox+1, c1)
# mlab.contour3d(ux, vx, rhox, values_u, color = (0.7, 0.4, 0.4), contours=[0], opacity = 0.5)
# values_v = b*(1.0 - vx) - eta(rhox, c1)
# mlab.contour3d(ux, vx, rhox, values_v, color = (0.7, 0.4, 0.4), contours=[0], opacity = 0.5)
mlab.axes()
mlab.xlabel('u')
mlab.ylabel('v')
mlab.zlabel('rho')
mlab.plot3d(u, v, rho, tube_radius=0.02, line_width=2.0)

print('Mean u: ', np.mean(u))
print('Mean v: ', np.mean(v))

fig, ax = plt.subplots(1, 2)
ax[0].plot(time, u, label='u')
ax[0].plot(time, v, label='v')
ax[0].legend()
ax[0].set_xlabel('time')

ax[1].plot(time, rho)
ax[1].set_ylabel('rho')
ax[1].set_xlabel('time')
plt.show(block=False)
Пример #47
0
def ckplot(kmod=None, kmod2=None, labels=False, show=True, xlabel='x',ylabel='y',zlabel='z'):
    '''
    This function plots 2D and 3D models
    :param labels:
    :param show: If True, the plots are displayed at the end of this call. If False, plt.show() should be called outside this function
    :return:
    '''
    if kmod.k == 3:
        import mayavi.mlab as mlab

        predictFig = mlab.figure(figure='predict')
        # errorFig = mlab.figure(figure='error')
        if kmod.testfunction:
            truthFig = mlab.figure(figure='test')
        dx = 1
        pts = 25j
        X, Y, Z = np.mgrid[0:dx:pts, 0:dx:pts, 0:dx:pts]
        scalars = np.zeros(X.shape)
        scalars2= np.zeros(X.shape)
        errscalars = np.zeros(X.shape)
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                for k1 in range(X.shape[2]):
                    # errscalars[i][j][k1] = kmod.predicterr_normalized([X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
                    scalars[i][j][k1] = kmod.predict_normalized([X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])    
                    scalars2[i][j][k1] = kmod2.predict([X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])    

        if kmod.testfunction:
            tfscalars = np.zeros(X.shape)
            for i in range(X.shape[0]):
                for j in range(X.shape[1]):
                    for k1 in range(X.shape[2]):
                        tfplot = tfscalars[i][j][k1] = kmod.testfunction([X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
            plot = mlab.contour3d(tfscalars, contours=15, transparent=True, figure=truthFig)
            plot.compute_normals = False

        # obj = mlab.contour3d(scalars, contours=10, transparent=True)
        mlab.contour3d(scalars2, contours=15, transparent=True, figure=predictFig)
        plot = mlab.contour3d(scalars, contours=15, transparent=True, figure=predictFig)
        
        plot.compute_normals = False
        # errplt = mlab.contour3d(errscalars, contours=15, transparent=True, figure=errorFig)
        # errplt.compute_normals = False
        mlab.xlabel(xlabel)
        mlab.ylabel(ylabel)
        mlab.zlabel(zlabel)
        if show:
            mlab.show()

    if kmod.k==2:

        fig = pylab.figure(figsize=(8,6))
        samplePoints = list(zip(*kmod.X))
        # Create a set of data to plot
        plotgrid = 61
        x = np.linspace(kmod.normRange[0][0], kmod.normRange[0][1], num=plotgrid)
        y = np.linspace(kmod.normRange[1][0], kmod.normRange[1][1], num=plotgrid)

        # x = np.linspace(0, 1, num=plotgrid)
        # y = np.linspace(0, 1, num=plotgrid)
        X, Y = np.meshgrid(x, y)

        # Predict based on the optimized results

        zs = np.array([kmod.predict([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])
        Z = zs.reshape(X.shape)
        # Z = (Z*(kmod.ynormRange[1]-kmod.ynormRange[0]))+kmod.ynormRange[0]

        #Calculate errors
        zse = np.array([kmod.predict_var([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])
        Ze = zse.reshape(X.shape)

        spx = (kmod.X[:,0] * (kmod.normRange[0][1] - kmod.normRange[0][0])) + kmod.normRange[0][0]
        spy = (kmod.X[:,1] * (kmod.normRange[1][1] - kmod.normRange[1][0])) + kmod.normRange[1][0]
        contour_levels = 25

        ax = fig.add_subplot(222)
        CS = pylab.contourf(X,Y,Ze, contour_levels)
        pylab.colorbar()
        pylab.plot(spx, spy,'ow')

        ax = fig.add_subplot(221)
        if kmod.testfunction:
            # Setup the truth function
            zt = kmod.testfunction( np.array(list(zip(np.ravel(X), np.ravel(Y)))) )
            ZT = zt.reshape(X.shape)
            CS = pylab.contour(X,Y,ZT,contour_levels ,colors='k',zorder=2)


        # contour_levels = np.linspace(min(zt), max(zt),50)
        if kmod.testfunction:
            contour_levels = CS.levels
            delta = np.abs(contour_levels[0]-contour_levels[1])
            contour_levels = np.insert(contour_levels, 0, contour_levels[0]-delta)
            contour_levels = np.append(contour_levels, contour_levels[-1]+delta)

        CS = plt.contourf(X,Y,Z,contour_levels,zorder=1)
        pylab.plot(spx, spy,'ow', zorder=3)
        pylab.colorbar()

        ax = fig.add_subplot(212, projection='3d')
        # fig = plt.gcf()
        #ax = fig.gca(projection='3d')
        ax.plot_surface(X, Y, Z, rstride=3, cstride=3, alpha=0.4)
        if kmod.testfunction:
            ax.plot_wireframe(X, Y, ZT, rstride=3, cstride=3)
        if show:
            pylab.show()
Пример #48
0
   colormap='YlGnBu',opacity=0.85)
mlab.pipeline.iso_surface(src, contours=[usquared.max()-0.1*usquared.ptp(), ],
   colormap='YlGnBu',opacity=1.0)
mlab.pipeline.image_plane_widget(src,plane_orientation='z_axes',
                            slice_index=Nz/2,colormap='YlGnBu',
                            opacity=0.01)
mlab.pipeline.image_plane_widget(src,plane_orientation='y_axes',
                            slice_index=Ny/2,colormap='YlGnBu',
                            opacity=0.01)
mlab.pipeline.image_plane_widget(src,plane_orientation='x_axes',
                            slice_index=Nx/2,colormap='YlGnBu',
                            opacity=0.01)
mlab.scalarbar()
mlab.xlabel('x',object=src)
mlab.ylabel('y',object=src)
mlab.zlabel('z',object=src)

# initial mass
usquared=abs(u)**2
mass=numpy.fft.fftn(usquared)
ma=numpy.real(mass[0,0,0])
print(ma)
maO=ma
t=0.0
tdata[0]=t
plotnum=0
#solve pde and plot results
for nt in xrange(numplots-1):
    for n in xrange(plotgap):
        vna=v*numpy.exp(complex(0,0.5)*dt*(k2xm+k2ym+k2zm))
        una=numpy.fft.ifftn(vna)
Пример #49
0
sinth = sin(theta)
costh = cos(theta)

m = 0
for k in range(K):
    for j in range(J):
        for i in range(I):
            rho += (c[m] * np.power(sinphi, i + j) * np.power(cosphi, k) *
                    np.power(sinth, j) * np.power(costh, i))
            m += 1

xs = rho * sin(phi) * cos(theta)
ys = rho * sin(phi) * sin(theta)
zs = rho * cos(phi)

import mayavi.mlab as mylab
fig = mylab.figure(1, bgcolor=(0, 0, 0))
mylab.clf()
ps = 1. * np.ones_like(x)
mylab.points3d(x,
               y,
               z, (ps),
               scale_factor=0.025,
               colormap='Spectral',
               opacity=1.)
mylab.mesh(xs, ys, zs, colormap="bone", opacity=0.5)
mylab.outline()
mylab.xlabel('X')
mylab.ylabel('Y')
mylab.zlabel('Z')
Пример #50
0
import tables as tb
import mayavi.mlab as ml

f = tb.openFile('/Users/fpaolo/data/gps/amery_gps_all.h5')
t = f.root.time[:]
x = f.root.x[:]
y = f.root.y[:]
h = f.root.h[:]
f.close()

ml.figure(1, size=(700, 600), fgcolor=(1, 1, 1), bgcolor=(0.5, 0.5, 0.5))
ml.points3d(x, y, h, t.round(1), mode='point')
#ml.plot3d(x, y, h, t.round(1), tube_radius=.3)
ml.colorbar(title='campaigns', orientation='vertical', 
            nb_labels=5, label_fmt='%.0f', nb_colors=5)
ml.outline()
ml.axes(nb_labels=4).axes.label_format = '%.0f'
ml.title('Amery GPS', size=.7)
ml.xlabel('x (km)')
ml.ylabel('y (km)')
ml.zlabel('h (m)')
ml.show()