Beispiel #1
0
	def Crit_points(self,Data,xfl=None):
		Im = pp.Image()
		if xfl is None: xfl = 5.0
		Vpol = np.sqrt(Data.v1**2 + Data.v2**2)
		Bpol = np.sqrt(Data.b1**2 + Data.b2**2)
		Btot = np.sqrt(Data.b1**2 + Data.b2**2 + Data.b3**2)
		Valfven = Bpol/np.sqrt(Data.rho)
		Vfast = Btot/np.sqrt(Data.rho)
		Varat = Vpol/Valfven
		Vfrat = Vpol/Vfast
		Dummy = np.zeros(shape=Valfven.shape)
		fldict = Im.field_line(Data.b1,Data.b2,Data.x1,Data.x2,Data.dx1,Data.dx2,xfl,0.001)
		Qx = fldict['qx']
		Qy = fldict['qy']
		Fl_Varat = np.zeros(shape=(2,len(Qx)))
		Fl_Vfrat = np.zeros(shape=(2,len(Qx)))
		
		for i in range(len(Qx)):
			Fl_Varat[:,i] = Im.field_interp(Varat,Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			Fl_Vfrat[:,i] = Im.field_interp(Vfrat,Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])

		Val1 = [Qx[np.abs(Fl_Varat[0,:]-1.0).argmin()],Qy[np.abs(Fl_Varat[0,:]-1.0).argmin()]]
		Val2 = [Qx[np.abs(Fl_Vfrat[0,:]-1.0).argmin()],Qy[np.abs(Fl_Vfrat[0,:]-1.0).argmin()]]

	
		print '------------------------------------------------'
		print '[Qx,Qy] at Alfven :', Val1
		print '[Qx,Qy] at Fast   :', Val2
		print 'Opening Angle at Alfven :',90.0-(180.0/np.pi)*np.arctan(Val1[1]/(Val1[0]-xfl))
		print 'Opening Angle at Fast   :',90.0-(180.0/np.pi)*np.arctan(Val2[1]/(Val2[0]-xfl))
		print '------------------------------------------------'

		return [Val1,Val2,90.0-(180.0/np.pi)*np.arctan(Val1[1]/(Val1[0]-xfl)),90.0-(180.0/np.pi)*np.arctan(Val2[1]/(Val2[0]-xfl))]
Beispiel #2
0
	def newFline_vals(self,Data,CompX,CompY,**kwargs):
		Im = pp.Image()
		fl_dict=Im.field_line(Data.b1,Data.b2,Data.x1,Data.x2,Data.dx1,Data.dx2,kwargs.get('xfl',5.0),0.001)
		Qx = fl_dict['qx']
		Qy = fl_dict['qy']

		Final_Values = np.zeros(shape=(2,len(Qx)))

		for i in range(len(Qx)):
			Final_Values[:,i] = Im.field_interp(CompX,CompY,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])

		Final_Values_dict={'Qy':Qy,'Fl_Val':Final_Values}
		return Final_Values_dict
Beispiel #3
0
def temp(wdir):
    D = pp.pload(30,w_dir=wdir)
    
    I = pp.Image()
    flux=D.prs*1.67e-7/D.rho/1000000/1.3806488e-23
#    print flux.shape
#    flux= (flux-np.mean(flux))*5+np.mean(flux)*5.3
#    flux=nd.gaussian_filter(flux,sigma=(4,4),order=0)
    I.pldisplay(D, flux,x1=D.x1, \
                x2=D.x2,label1='l offset (pc)',label2='b offset (pc)',                                    \
                title='Temperature',                        
                cbar=(True,'vertical'))
#    savefig('MHD_Blast.png') # Only to be saved as either .png or .jpg
    plt.show()
Beispiel #4
0
def plot_jet():
	set_pretty()
	nlinf = pp.nlast_info()
	D = pp.pload(nlinf['nlast'])
	I = pp.Image()
	I.pldisplay(D, D.rho,x1=D.x1,x2=D.x2,label1='$x$',label2='$y$',
	            title=r'Density $\rho$ [MHD jet]',cbar=(True,'vertical'),figsize=[7,12])

	print (I.pldisplay.__doc__)

	# Code to plot field lines. Requires 2 arrays xarr and yarr as
	# the starting point of integration i.e. x and y co-ordinate of the field point.
	I.myfieldlines(D,linspace(D.x1.min(),D.x1.max(),10),linspace(D.x2.min(),D.x2.min(),10),
               colors='w',ls='-',lw=1.5)

	savefig('jet_final.png') # Only to be saved as either .png or .jpg
Beispiel #5
0
def multiple(wdir):
    #D = pp.pload(nlinf['nlast'],w_dir=wdir) # Loading the data into a pload object D
    for i in range(30):
        D = pp.pload(i,w_dir=wdir)
        #print D.rho.shape[0]
        
        I = pp.Image()
        I.pldisplay(D, np.log(D.rho),x1=D.x1, \
                    x2=D.x2,label1='l offset (pc)',label2='b offset (pc)',                                    \
                    title=r'$Density (ln(cm^{-3})) - Velocity (km/s)$ '+str(i*1000)+' years',    
                    cbar=(True,'vertical'))
        T = pp.Tools()
        newdims = 2*(20,)
        Xmesh, Ymesh = np.meshgrid(D.x1.T,D.x2.T)
        xcong = T.congrid(Xmesh,newdims,method='linear')
        ycong = T.congrid(Ymesh,newdims,method='linear')
        velxcong = T.congrid(D.vx1.T,newdims,method='linear')
        velycong = T.congrid(D.vx2.T,newdims,method='linear')
        plt.gca().quiver(xcong, ycong, velxcong, velycong,color='w')
        plt.savefig('20_'+str(i)+'.png') # Only to be saved as either .png or .jpg
        plt.close()
Beispiel #6
0
	def Fline_values(self,Data,**kwargs):
		Im = pp.Image()
		fl_dict=Im.field_line(Data.b1,Data.b2,Data.x1,Data.x2,Data.dx1,Data.dx2,kwargs.get('xfl',5.0),0.001)
		Qx = fl_dict['qx']
		Qy = fl_dict['qy']
		Gdict=self.Gravity(Data)
		Pdict=self.Pressure(Data)
		Cdict=self.Centrifugal(Data)
		Ldict=self.Lorentz(Data)
		MagPdict = self.Mag_Pressure(Data)
		StRdict=self.Stellar_Rad(Data,**kwargs)
		


	
				
		
		Dummy = np.zeros(Data.rho.shape)
		
		Fl_Gr = np.zeros(shape=(2,len(Qx)))
		tFl_Gr = np.zeros(shape=(2,len(Qx)))
		aFl_Gr = np.zeros(shape=(2,len(Qx)))
		
		Fl_Pr = np.zeros(shape=(2,len(Qx)))
		tFl_Pr = np.zeros(shape=(2,len(Qx)))
		aFl_Pr = np.zeros(shape=(2,len(Qx)))
		
		Fl_Cf = np.zeros(shape=(2,len(Qx)))
		tFl_Cf = np.zeros(shape=(2,len(Qx)))
		aFl_Cf = np.zeros(shape=(2,len(Qx)))
		
		Fl_Lf = np.zeros(shape=(2,len(Qx)))
		tFl_Lf1 = np.zeros(shape=(2,len(Qx)))
		tFl_Lf2 = np.zeros(shape=(2,len(Qx)))
		tFl_Pinch = np.zeros(shape=(2,len(Qx)))
		aFl_Lf1 = np.zeros(shape=(2,len(Qx)))
		aFl_Lf2 = np.zeros(shape=(2,len(Qx)))
		aFl_Pinch = np.zeros(shape=(2,len(Qx)))

		Fl_StRf = np.zeros(shape=(2,len(Qx)))
		tFl_StRf = np.zeros(shape=(2,len(Qx)))
		aFl_StRf = np.zeros(shape=(2,len(Qx)))

		Fl_DiskRf = np.zeros(shape=(2,len(Qx)))
		

		for i in range(len(Qx)):
			Fl_Gr[:,i] = Im.field_interp(Gdict['G_r'],Gdict['G_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			Fl_Pr[:,i] = Im.field_interp(Pdict['Fp_r'],Pdict['Fp_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			Fl_Cf[:,i] = Im.field_interp(Cdict['Fcf_r'],Cdict['Fcf_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			Fl_Lf[:,i] = Im.field_interp(Ldict['Fl_r'],Ldict['Fl_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			Fl_StRf[:,i] = Im.field_interp(StRdict['Fr_r'],StRdict['Fr_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])

			tFl_Gr[:,i] = Im.field_interp(Gdict['Grav_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_Pr[:,i] = Im.field_interp(Pdict['Press_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_Cf[:,i] = Im.field_interp(Cdict['Centri_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_Lf1[:,i] = Im.field_interp(MagPdict['bpolpr_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_Lf2[:,i] = Im.field_interp(MagPdict['bphipr_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_Pinch[:,i] = Im.field_interp(MagPdict['pinch_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			tFl_StRf[:,i] = Im.field_interp(StRdict['StRad_tfl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Gr[:,i] = Im.field_interp(Gdict['Grav_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Pr[:,i] = Im.field_interp(Pdict['Press_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Cf[:,i] = Im.field_interp(Cdict['Centri_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Lf1[:,i] = Im.field_interp(MagPdict['bpolpr_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Lf2[:,i] = Im.field_interp(MagPdict['bphipr_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_Pinch[:,i] = Im.field_interp(MagPdict['pinch_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			aFl_StRf[:,i] = Im.field_interp(StRdict['StRad_afl'],Dummy,Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])
			
		if kwargs.get('DiskRad',False) == True:
			DiskRdict = self.Disk_Rad(Data,**kwargs)
			for i in range(len(Qx)):
				Fl_DiskRf[:,i] = Im.field_interp(DiskRdict['d_Fr_r'],DiskRdict['d_Fr_z'],Data.x1,Data.x2,Data.dx1,Data.dx2,Qx[i],Qy[i])

		var_fl = {}
		keys_list =['Qy','Fl_Gr','Fl_Pr','Fl_Cf','Fl_Lf','Fl_StRf','Fl_DiskRf','tFl_Gr','tFl_Pr','tFl_Cf','tFl_Lf1','tFl_Lf2','tFl_Pinch','tFl_StRf', 'aFl_Gr','aFl_Pr','aFl_Cf','aFl_Lf1','aFl_Lf2','aFl_Pinch','aFl_StRf']
		matrix_list =[Qy,Fl_Gr,Fl_Pr,Fl_Cf,Fl_Lf,Fl_StRf,Fl_DiskRf,tFl_Gr,tFl_Pr,tFl_Cf,tFl_Lf1,tFl_Lf2,tFl_Pinch,tFl_StRf,aFl_Gr,aFl_Pr,aFl_Cf,aFl_Lf1,aFl_Lf2,aFl_Pinch,aFl_StRf]

		for i in range(len(keys_list)):
			var_fl[keys_list[i]]=matrix_list[i]
		
		#print var_fl.keys()
		#var_fl={'Qy':Qy,'Fl_Gr':Fl_Gr,'Fl_Pr':Fl_Pr,'Fl_Cf':Fl_Cf,'Fl_Lf':Fl_Lf,'Fl_StRf':Fl_StRf,'Fl_DiskRf':Fl_DiskRf}
		return var_fl
Beispiel #7
0
    def __init__(self, master):
        frame = Frame(master)
        frame.pack()

        self.wdir = os.getcwd() + '/'
        self.I = pp.Image()

        self.enstep = Entry(frame, width=5)
        self.enstep.pack(side=LEFT)
        self.enstep.insert(0, "0")

        self.varkeys = self.loaddata().get_varinfo(w_dir=self.wdir)['allvars']
        self.grid_dict = self.loaddata().grid(w_dir=self.wdir)

        self.ldatabutton = Button(frame,
                                  text="Load data",
                                  command=self.loaddata)
        self.ldatabutton.pack(side=LEFT)

        self.v = StringVar()
        self.v.set("rho")
        for variables in self.varkeys:
            self.ldata = Radiobutton(frame,
                                     text=variables,
                                     variable=self.v,
                                     value=variables,
                                     command=self.getmyvar)
            self.ldata.pack(side=LEFT)

        self.slvar = StringVar()
        self.slvar.set("Choose Slice")
        SliceList = ("Along x1", "Along x2", "Along x3", "Along x1-x2",
                     "Along x2-x3", "Along x3-x1")
        OptionMenu(frame, self.slvar, *SliceList,
                   command=self.setslice).pack(side=LEFT)

        self.ex1 = Entry(frame, width=5)
        self.ex1.pack(side=LEFT)
        self.ex1.insert(0, "x1")

        self.ex2 = Entry(frame, width=5)
        self.ex2.pack(side=LEFT)
        self.ex2.insert(0, "x2")

        self.ex3 = Entry(frame, width=5)
        self.ex3.pack(side=LEFT)
        self.ex3.insert(0, "x3")

        self.xlb = Entry(frame, width=15)
        self.xlb.pack(side=LEFT)
        self.xlb.insert(0, "xlabel")

        self.ylb = Entry(frame, width=15)
        self.ylb.pack(side=LEFT)
        self.ylb.insert(0, "ylabel")

        self.logvar = IntVar()
        self.chkb = Checkbutton(frame,
                                text="Enable Log",
                                variable=self.logvar,
                                onvalue=1,
                                offvalue=0,
                                command=self.logchkcall)
        self.chkb.pack(side=LEFT)

        self.polarvar = IntVar()
        self.polchkb = Checkbutton(frame,
                                   text="Polar",
                                   variable=self.polarvar,
                                   onvalue=1,
                                   offvalue=0,
                                   command=self.polchkcall)
        self.polchkb.pack(side=LEFT)

        # self.getplot= Button(frame,text='Plot',fg="black",command=self.plotfinal)
        # self.getplot.pack(side=LEFT)

        # place a graph somewhere here
        self.f = Figure(figsize=(8, 8), dpi=100)
        self.a = self.f.add_subplot(111)
        self.canvas = FigureCanvasTkAgg(self.f, master=root)
        self.canvas.show()
        self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
Beispiel #8
0
import os
import sys
from numpy import *
from matplotlib.pyplot import *
import pyPLUTO as pp

#To run this example it is suggested to get data in 2D using pluto_01.ini and set the data in flt datatype instead of dbl.h5

plutodir = os.environ['PLUTO_DIR']
wdir = plutodir + '/Test_Problems/HD/Stellar_Wind/'
nlinf = pp.nlast_info(w_dir=wdir, datatype='float')

D = pp.pload(nlinf['nlast'], w_dir=wdir,
             datatype='float')  # Loading the data into a pload object D.

I = pp.Image()
I.pldisplay(D,
            log10(D.rho),
            x1=D.x1,
            x2=D.x2,
            label1='x',
            label2='y',
            title=r'Log Density $\rho$ [Stellar Wind]',
            cbar=(True, 'vertical'),
            figsize=[8, 12])

# Code to plot arrows. --> Spacing between the arrow can be adjusted by modifying the newdims tuple of conrid function.
T = pp.Tools()
newdims = 2 * (20, )
Xmesh, Ymesh = meshgrid(D.x1.T, D.x2.T)
xcong = T.congrid(Xmesh, newdims, method='linear')
Beispiel #9
0
    def __init__(self, master):

        # create toplevel window
        frame = Frame(master)

        frame.grid(ipadx=10, ipady=10)

        self.wdir = os.getcwd() + '/'
        self.I = pp.Image()
        self.Tool = pp.Tools()

        self.lb1 = Label(frame, text="Nstep").grid(row=0, column=0)

        self.enstep = Entry(frame, width=8)
        self.enstep.grid(row=0, column=1)
        self.enstep.insert(0, "0")

        self.LoadedNstep = StringVar()
        self.PresentTime = StringVar()

        self.myData = self.loaddata()
        self.varkeys = self.myData.get_varinfo()['allvars']
        self.grid_dict = self.myData.grid()

        if self.grid_dict["n3"] != 1:
            self.Geom = '3D'
        elif self.grid_dict["n3"] == 1 and self.grid_dict["n2"] != 1:
            self.Geom = '2D'
        else:
            self.Geom = '1D'

        self.ldatabutton = Button(frame,
                                  text="Load data",
                                  command=self.loaddata)
        self.ldatabutton.grid(row=0, column=2)

        ############### MARK THE CUTS #################################

        self.ex1 = Entry(frame, width=5)
        self.ex1.grid(row=2, column=0)
        self.ex1.insert(0, "x1")

        self.ex2 = Entry(frame, width=5)
        self.ex2.grid(row=2, column=1)
        self.ex2.insert(0, "x2")

        self.ex3 = Entry(frame, width=5)
        self.ex3.grid(row=2, column=2)
        self.ex3.insert(0, "x3")

        if self.Geom == '2D':
            self.ex3.config(state='disabled')

        if self.Geom == '1D':
            self.ex3.config(state='disabled')
            self.ex2.config(state='disabled')
            self.ex1.config(state='disabled')

        # place a graph somewhere here
        self.f = Figure(figsize=(7, 7), dpi=100)
        self.a = self.f.add_subplot(111)
        self.canvas = FigureCanvasTkAgg(self.f, master=root)
        self.canvas.show()
        self.canvas.get_tk_widget().grid(row=0,
                                         column=3,
                                         columnspan=10,
                                         rowspan=10,
                                         sticky=E)

        #self.toolbar = NavigationToolbar2TkAgg(self.canvas,tl)
        #self.toolbar.update()
        #self.canvas._tkcanvas.grid(row=60,column=15,sticky=E)

        self.v = StringVar()
        self.v.set("None")

        ################ VARIABLES TO PLOT #################################

        for j in range(len(self.varkeys)):
            self.ldata = Radiobutton(frame,
                                     text=self.varkeys[j],
                                     variable=self.v,
                                     value=self.varkeys[j],
                                     command=self.getmyvar)
            self.ldata.grid(row=3 + j, column=0, sticky=W)

################ SLICES CHOICE #################################

        self.slvar = StringVar()
        self.slvar.set("Choose Slice")
        if self.Geom == '3D':
            SliceList = ("Along x1", "Along x2", "Along x3", "Along x1-x2",
                         "Along x2-x3", "Along x3-x1")
        elif self.Geom == '2D':
            SliceList = ("Along x1", "Along x2", "Along x1-x2")
        else:
            SliceList = ()

        for j in range(len(SliceList)):
            self.sldata = Radiobutton(frame,
                                      text=SliceList[j],
                                      variable=self.slvar,
                                      value=SliceList[j],
                                      command=self.setslice)
            self.sldata.grid(row=3 + j, column=1, sticky=W)

############### PLOT PROPERTIES #################################

        self.logvar = IntVar()
        self.chkb = Checkbutton(frame,
                                text="Log  ",
                                variable=self.logvar,
                                onvalue=1,
                                offvalue=0,
                                command=self.logchkcall)
        self.chkb.grid(row=3, column=2, sticky=W)  #(row=15,column=0,sticky=W)

        self.polarvar = IntVar()
        self.polchkb = Checkbutton(frame,
                                   text="Polar",
                                   variable=self.polarvar,
                                   onvalue=1,
                                   offvalue=0,
                                   command=self.polchkcall)
        self.polchkb.grid(row=4, column=2, sticky=W)  #(row=15,column=1)
        if self.Geom == '1D':
            self.polchkb.config(state='disabled')
            self.polarvar.set(0)

        self.preaspect = IntVar()
        self.aspectb = Checkbutton(frame,
                                   text="Aspect",
                                   variable=self.preaspect,
                                   onvalue=1,
                                   offvalue=0,
                                   command=self.aspchkcall)
        self.aspectb.grid(row=5, column=2, sticky=W)  #(row=15,column=2)
        if self.Geom == '1D':
            self.aspectb.config(state='disabled')

################ X and Y LABELS #################################

        self.lb2 = Label(frame, text="Labels").grid(row=22, column=0)

        self.xlb = Entry(frame, width=15)
        self.xlb.grid(row=22, column=1)
        self.xlb.insert(0, "xlabel")

        self.ylb = Entry(frame, width=15)
        self.ylb.grid(row=22, column=2)
        self.ylb.insert(0, "ylabel")

        ############### X and Y RANGE#######################

        self.lb2a = Label(frame, text="XRange").grid(row=24, column=0)
        self.lb2b = Label(frame, text="YRange").grid(row=26, column=0)
        self.lb2c = Label(frame, text="VarRange").grid(row=28, column=0)

        self.xrmin = Entry(frame, width=15)
        self.xrmin.grid(row=24, column=1)
        self.xrmin.insert(0, '')
        self.xrmax = Entry(frame, width=15)
        self.xrmax.grid(row=24, column=2)
        self.xrmax.insert(0, '')

        self.yrmin = Entry(frame, width=15)
        self.yrmin.grid(row=26, column=1)
        self.yrmin.insert(0, '')
        self.yrmax = Entry(frame, width=15)
        self.yrmax.grid(row=26, column=2)
        self.yrmax.insert(0, '')

        self.varmin = Entry(frame, width=15)
        self.varmin.grid(row=28, column=1)
        self.varmin.insert(0, '')
        self.varmax = Entry(frame, width=15)
        self.varmax.grid(row=28, column=2)
        self.varmax.insert(0, '')
        if self.Geom == '1D':
            self.yrmin.config(state='disabled')
            self.yrmax.config(state='disabled')

################ CONTOURS #################################

        self.lb3 = Label(frame, text="Contours").grid(row=16, column=0)

        self.contvar = IntVar()
        self.chkb = Checkbutton(frame,
                                text="Contour",
                                variable=self.contvar,
                                onvalue=1,
                                offvalue=0,
                                command=self.contchkcall)
        self.chkb.grid(row=6, column=2, sticky=W)  #(row=16,column=0,sticky=W)

        self.plcont = StringVar()
        self.contkeys = ["None"]
        if "b1" in self.varkeys:
            for item in self.varkeys:
                self.contkeys.append(item)
            self.contkeys.append("x1*b3")
            self.contkeys.append("x1*A3")
        else:
            for item in self.varkeys:
                self.contkeys.append(item)
        self.plcont.set("None")
        self.contmenu = OptionMenu(frame, self.plcont, *self.contkeys)
        self.contmenu.grid(row=16, column=1)

        self.xlevb = Entry(frame, width=15)
        self.xlevb.grid(row=16, column=2, sticky=W)
        self.xlevb.insert(0, "Levels")
        self.xlevb.config(state='disabled')
        self.contmenu.config(state='disabled')

        if self.Geom == '1D':
            self.chkb.config(state='disabled')

################ ARROWS #################################

        self.lb4 = Label(frame, text="Arrows").grid(row=19, column=0)

        self.arrowvar = IntVar()
        self.arrowchkb = Checkbutton(frame,
                                     text="Arrows",
                                     variable=self.arrowvar,
                                     onvalue=1,
                                     offvalue=0,
                                     command=self.arrchkcall)
        self.arrowchkb.grid(row=7, column=2,
                            sticky=W)  #(row=16,column=0,sticky=W)

        self.arrspb = Entry(frame, width=15)
        self.arrspb.grid(row=19, column=2, sticky=W)
        self.arrspb.insert(0, "20")

        self.plarr = StringVar()
        self.arrkeys = ["None"]
        self.arrkeys.append("Vp")
        self.arrkeys.append("Vp_norm")
        if "b1" in self.varkeys:
            self.arrkeys.append("Bp")
            self.arrkeys.append("Bp_norm")
        self.plarr.set("None")
        self.arrmenu = OptionMenu(frame, self.plarr, *self.arrkeys)
        self.arrmenu.grid(row=19, column=1)
        self.arrmenu.config(state='disabled')
        self.arrspb.config(state='disabled')

        if self.Geom == '1D':
            self.arrowchkb.config(state='disabled')

################ VARIOUS PLOTTING BUTTONS #################################

        self.pltbutton = Button(frame, text="Plot", command=self.plotfinal)
        self.pltbutton.grid(row=36, column=0)
        if self.Geom == '1D':
            self.pltbutton.config(state='active')
        else:
            self.pltbutton.config(state='disabled')

        self.surfbutton = Button(frame,
                                 text="Surface",
                                 command=self.plotsurface)
        self.surfbutton.grid(row=36, column=1)
        self.surfbutton.config(state='disabled')
        #if self.Geom == '1D':
        #    self.surfbutton.config(state='disabled')

        self.clrbutton = Button(frame, text="Clear", command=self.plotclear)
        self.clrbutton.grid(row=36, column=2)

        ################ INFORMATION #################################

        self.lbinf0 = Label(frame,
                            text="Information",
                            font=("Times", 12, "bold"))
        self.lbinf0.grid(row=47, column=0, sticky=W, columnspan=3)

        self.lbinf1a = Label(frame, text="Dir :",
                             font=("Times", 10, "bold")).grid(row=49,
                                                              column=0,
                                                              sticky=W,
                                                              columnspan=3)
        self.lbinf1 = Label(frame, text=self.wdir).grid(row=50,
                                                        column=0,
                                                        sticky=W,
                                                        columnspan=3)
        self.lbinf2a = Label(frame,
                             text="Domain :",
                             font=("Times", 10, "bold")).grid(row=51,
                                                              column=0,
                                                              sticky=W,
                                                              columnspan=3)
        self.lbinf2 = Label(
            frame,
            text="n1 x n2 x n3 =  %d x %d x %d " %
            (self.grid_dict.get('n1'), self.grid_dict.get('n2'),
             self.grid_dict.get('n3'))).grid(row=52,
                                             column=0,
                                             sticky=W,
                                             columnspan=3)
        self.lbinf3a = Label(frame,
                             text="Time Status",
                             font=("Times", 10, "bold")).grid(row=53,
                                                              column=0,
                                                              sticky=W,
                                                              columnspan=3)
        self.lbinf4 = Label(frame,
                            text="Nlast = %d" %
                            (pp.nlast_info().get('nlast'))).grid(row=54,
                                                                 column=0,
                                                                 sticky=W,
                                                                 columnspan=3)
        self.lbinf5 = Label(frame,
                            textvariable=self.LoadedNstep).grid(row=55,
                                                                column=0,
                                                                sticky=W,
                                                                columnspan=3)
        self.lbinf6 = Label(frame,
                            textvariable=self.PresentTime).grid(row=56,
                                                                column=0,
                                                                sticky=W,
                                                                columnspan=3)
Beispiel #10
0
    def __init__(self,master):
        frame = Frame(master)
        
        frame.grid(ipadx=10,ipady=10)
        
        
        self.wdir = os.getcwd() + '/'
        self.I = pp.Image()
        


        self.lb1=Label(frame, text="Nstep").grid(row=0,column=0)
        self.lb2=Label(frame,text="Labels").grid(row=16,column=0)
        
        self.enstep = Entry(frame,width=8)
        self.enstep.grid(row=0,column=1)
        self.enstep.insert(0, "0")

        self.myData = self.loaddata()
        self.tinfo = pp.time_info(self.wdir)
        self.varkeys = self.myData.get_varinfo(w_dir=self.wdir)['allvars']
        self.grid_dict= self.myData.grid(w_dir=self.wdir)
        

        self.ldatabutton=Button(frame,text="Load data",command=self.loaddata)
        self.ldatabutton.grid(row=0,column=2)

        self.ex1 = Entry(frame,width=5)
        self.ex1.grid(row=2,column=0)
        self.ex1.insert(0, "x1")

        self.ex2 = Entry(frame,width=5)
        self.ex2.grid(row=2,column=1)
        self.ex2.insert(0, "x2")
        
        self.ex3 = Entry(frame,width=5)
        self.ex3.grid(row=2,column=2)
        self.ex3.insert(0, "x3")

               

        # place a graph somewhere here
        self.f = Figure(figsize=(8,8), dpi=100)
        self.a = self.f.add_subplot(111)
        self.canvas = FigureCanvasTkAgg(self.f, master=root)
        self.canvas.show()
        self.canvas.get_tk_widget().grid(row=0,column=3,columnspan=10,rowspan=10,sticky=E)

        



        
        
        self.v = StringVar()
        self.v.set("rho")
        
        for j in range(len(self.varkeys)):
            self.ldata = Radiobutton(frame,text=self.varkeys[j],variable=self.v,value=self.varkeys[j],command=self.getmyvar)
            self.ldata.grid(row=3+j,column=0,sticky=W)
            
        self.slvar = StringVar()
        self.slvar.set("Choose Slice")
        SliceList = ("Along x1","Along x2","Along x3","Along x1-x2","Along x2-x3","Along x3-x1")
        for j in range(len(SliceList)):
            self.sldata = Radiobutton(frame,text=SliceList[j],variable=self.slvar,value=SliceList[j],command=self.setslice)
            self.sldata.grid(row=3+j,column=1,sticky=W)

        #OptionMenu(frame, self.slvar, *SliceList, command=self.setslice).grid(row=1,column=1)

        self.logvar = IntVar()
        self.chkb = Checkbutton(frame,text="Enable Log",variable=self.logvar,onvalue=1,offvalue=0,command=self.logchkcall)
        self.chkb.grid(row=15,column=0)

        self.polarvar = IntVar()
        self.polchkb = Checkbutton(frame,text="Polar",variable=self.polarvar,onvalue=1,offvalue=0,command=self.polchkcall)
        self.polchkb.grid(row=15,column=1)

        self.preaspect = IntVar()
        self.aspectb = Checkbutton(frame,text="Preserve Aspect",variable=self.preaspect,onvalue=1,offvalue=0,command=self.aspchkcall)
        self.aspectb.grid(row=15,column=2)

        self.xlb = Entry(frame,width=15)
        self.xlb.grid(row=16,column=1)
        self.xlb.insert(0, "xlabel")

        self.ylb = Entry(frame,width=15)
        self.ylb.grid(row=16,column=2)
        self.ylb.insert(16, "ylabel")

        self.pltbutton=Button(frame,text="Plot",command=self.plotfinal)
        self.pltbutton.grid(row=18,column=0)

        self.surfbutton=Button(frame,text="Surface",command=self.plotsurface)
        self.surfbutton.grid(row=18,column=1)

        self.clrbutton=Button(frame,text="Clear",command=self.plotclear)
        self.clrbutton.grid(row=18,column=2)

        self.lbinf0 =  Label(frame,text="Information",font=("Times",12,"bold"))
        self.lbinf0.grid(row=25,column=0,sticky=W,columnspan=3)

        self.lbinf1a = Label(frame,text="Dir :",font=("Times",10,"bold")).grid(row=27,column=0,sticky=W,columnspan=3)
        self.lbinf1 =  Label(frame,text=self.wdir).grid(row=28,column=0,sticky=W,columnspan=3)
        self.lbinf2a = Label(frame,text="Domain :",font=("Times",10,"bold")).grid(row=29,column=0,sticky=W,columnspan=3)
        self.lbinf2 = Label(frame,text="n1 x n2 x n3 =  %d x %d x %d " % (self.grid_dict.get('n1'),self.grid_dict.get('n2'),self.grid_dict.get('n3'))).grid(row=30,column=0,sticky=W,columnspan=3)
        self.lbinf3a = Label(frame,text="Time Status",font=("Times",10,"bold")).grid(row=31,column=0,sticky=W,columnspan=3)
        self.lbinf3 = Label(frame,text="Nlast = %d, Time = %f" % (self.tinfo.get('nlast'), self.tinfo.get('time'))).grid(row=32,column=0,sticky=W,columnspan=3)