def Gravity(self,Data):
rg = 0.21
zg = 0.21
[r2d, z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
Tool = pp.Tools()
gravdeno = ((r2d + rg)**2 + (z2d + zg)**2)**(1.5)
gravphi = -1.0/(((r2d + rg)**2 + (z2d + zg)**2)**(0.5))
gradphi = Tool.Grad(gravphi,Data.x1,Data.x2,Data.dx1,Data.dx2)
grda3 = self.al_perp(Data)
Bpara = self.al_para(Data)
Grav_afl = (1.0/(Bpara['Bpol']))*(Bpara['Br']*gradphi[:,:,0] + Bpara['Bz']*gradphi[:,:,1])
Grav_tfl = (1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*gradphi[:,:,0] + grda3['GrdA3z']*gradphi[:,:,1])
Grav_force_dict = {}
Grav_force_dict['G_r'] = (1.0*(r2d+rg))/(gravdeno)
Grav_force_dict['G_z'] = (1.0*(z2d+zg))/(gravdeno)
Grav_force_dict['Grav_tfl']=Data.rho*Grav_tfl
Grav_force_dict['Grav_afl']=Data.rho*Grav_afl
return Grav_force_dict
def Force_Multi(self,Data,**kwargs):
D = Data
[r2d, z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
T = pp.Tools()
gradvr = T.Grad(D.v1,D.x1,D.x2,D.dx1,D.dx2)
gradvz = T.Grad(D.v2,D.x1,D.x2,D.dx1,D.dx2)
dvrdr = gradvr[:,:,0]
dvrdz = gradvr[:,:,1]
dvzdr = gradvz[:,:,0]
dvzdz = gradvz[:,:,1]
xrat = z2d/r2d
dvdl = (1.0/(1.0 + xrat**2.0))*(np.abs(dvrdr) + xrat*(np.abs(dvrdz)+np.abs(dvzdr)) + (xrat**2.0)*(np.abs(dvzdz)))
G = 6.67e-8
Msun = 2.0e33
AU = 1.5e13
year = 365.0*3600.0*24.0
sigmae = 0.4
clight = 3.0e10
Qo = 1400.0
alp = kwargs.get('alpha',0.55)
ul = kwargs.get('ul',1.0)
urho = kwargs.get('urho',5.0e-14)
Mstar = kwargs.get('Mstar',30.0)
uvel = np.sqrt((G*Mstar*Msun)/(ul*AU))
Kpara = (Qo**(1.0-alp))/(1.0-alp)
Dless = uvel/(sigmae*clight*urho*ul*AU)
codeval = (1.0/D.rho)*np.abs(dvdl)
Mt = Kpara*(codeval*Dless)**(alp)
return Mt
def Pressure(self,Data,phi=10):
Tool = pp.Tools()
Prgrad = Tool.Grad(Data.pr[:,:,phi],Data.x1,Data.x2,Data.dx1,Data.dx2,polar=True)
Press_force_dict ={}
Press_force_dict['Fp_r'] = -1.0*(Prgrad[:,:,0]/Data.rho[:,:,phi])
Press_force_dict['Fp_th'] = -1.0*(Prgrad[:,:,1]/Data.rho[:,:,phi])
return Press_force_dict
def Stellar_Rad(self,Data,**kwargs):
[r2d,z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
Gravforce = self.Gravity(Data)
Mstar = kwargs.get('Mstar',30.0)
urho = kwargs.get('urho',5.0e-14)
ul = kwargs.get('ul',1.0)
Gammae = kwargs.get('Gammae',0.2369)
Qo = kwargs.get('Qo',1400.0)
Alpha = kwargs.get('Alpha',0.55)
print '-----------------------------------------------'
print 'xfl : ',kwargs.get('xfl',5.0)
print 'Alpha : ',Alpha
print 'Gammae: ',Gammae
print 'Qo : ',Qo
print 'ul : ',ul
print 'urho : ',urho
print 'Mstar : ',Mstar
print '-----------------------------------------------'
sigmae = 0.4
clight = 3.0e10
G = 6.67e-8
Msun = 2.0e33
AU=1.5e13
uvel = np.sqrt((G*Mstar*Msun)/(ul*AU))
Dless = uvel/(urho*ul*AU*sigmae*clight)
Kpara = (Dless**(Alpha))*((Qo**(1.0-Alpha))/(1.0-Alpha))
Tool = pp.Tools()
grv1 = Tool.Grad(Data.v1,Data.x1,Data.x2,Data.dx1,Data.dx2)
grv2 = Tool.Grad(Data.v2,Data.x1,Data.x2,Data.dx1,Data.dx2)
DvrDr = np.abs(grv1[:,:,0])
DvrDz = np.abs(grv1[:,:,1])
DvzDr = np.abs(grv2[:,:,0])
DvzDz = np.abs(grv2[:,:,1])
xrat = z2d/r2d
prf = 1.0/(1.0+xrat**2)
dvdl = prf*(DvrDr + (xrat**2)*DvzDz + xrat*(DvrDz + DvzDr))
Mt = Kpara*((1.0/Data.rho)*dvdl)**(Alpha)
Rad_r = Mt*Gammae*Gravforce['G_r']
Rad_z = Mt*Gammae*Gravforce['G_z']
grda3 = self.al_perp(Data)
StRad_tfl = Data.rho*(1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*Rad_r + grda3['GrdA3z']*Rad_z)
Bpara = self.al_para(Data)
StRad_afl = Data.rho*(1.0/(Bpara['Bpol']))*(Bpara['Br']*Rad_r + Bpara['Bz']*Rad_z)
Rad_force_dict={'dvdl':dvdl,'Mt':Mt,'Fr_r':Rad_r,'Fr_z':Rad_z,'StRad_tfl':StRad_tfl, 'StRad_afl':StRad_afl}
return Rad_force_dict
def single(ty, t, E, rho, sigma, wdir):
#D = pp.pload(nlinf['nlast'],w_dir=wdir) # Loading the data into a pload object D
D = pp.pload(t / 1000 - 1, w_dir=wdir)
flux = D.rho * (D.bx1**2 + D.bx2**2)**1.25 * (D.vx1**2 + D.vx2**2)**0
flux = (flux - np.mean(flux)) * 1 + np.mean(flux) * 1
flux = nd.gaussian_filter(flux, sigma=(sigma, sigma), order=0)
if ty == 'flux':
fig = plt.figure(figsize=(7, 6))
ax = fig.add_subplot(111)
neg = ax.imshow(np.log10(flux).T,
origin='lower',
extent=[D.x1[0], D.x1[-1], D.x2[0], D.x2[-1]])
levels = np.arange(-5.5, -4, 0.5)
# plt.contour(np.log10(flux).T, levels,
# origin='lower',
# linewidths=2,
# extent=[D.x1[0],D.x1[-1],D.x2[0],D.x2[-1]])
cbar = fig.colorbar(neg, ax=ax)
cbar.set_label(r'log(S)')
ax.set_xlabel('l offset (pc)')
ax.set_ylabel('b offset (pc)')
ax.set_title(r't=' + str(t) + r'$\ \mathregular{\rho}$=' + str(rho) +
' E=' + str(E))
fig.subplots_adjust(top=0.9, bottom=0.1, left=0.11, right=0.97)
fig.savefig('t=' + str(t) + ' density=' + str(rho) + ' E=' + str(E) +
'.eps') # Only to be saved as either .png or .jpg
else:
fig = plt.figure(figsize=(7, 6))
ax = fig.add_subplot(111)
neg = ax.imshow(np.log10(D.rho).T,
origin='lower',
extent=[D.x1[0], D.x1[-1], D.x2[0], D.x2[-1]])
cbar = fig.colorbar(neg, ax=ax)
cbar.set_label(r'log($\mathregular{\rho/cm^{-3}}$)')
ax.set_xlabel('l offset (pc)')
ax.set_ylabel('b offset (pc)')
ax.set_title(r't=' + str(t) + r'$\ \mathregular{\rho}$=' + str(rho) +
' E=' + str(E))
fig.subplots_adjust(top=0.9, bottom=0.1, left=0.11, right=0.97)
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='black',
scale=0.2)
# plt.show()
fig.savefig('rho-t=' + str(t) + ' density=' + str(rho) + ' E=' +
str(E) + '.eps') # Only to be saved as either .png or .jpg
def Gravity(self,Data):
[r2d, z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
Tool = pp.Tools()
Grav_force_dict = {}
Grav_force_dict['G_r'] = 1.0/(r2d*r2d)
Grav_force_dict['G_z'] = np.zeros(r2d.shape)
return Grav_force_dict
def Disk_Rad(self,Data,**kwargs):
Ld = asciidata.open(kwargs.get('file','/Users/bhargavvaidya/test_linediskrpcor_55.dat'))
r2d = np.asarray(Ld[0]).reshape(516,1028)
z2d = np.asarray(Ld[1]).reshape(516,1028)
Srl = np.asarray(Ld[2]).reshape(516,1028)
Svl = np.asarray(Ld[3]).reshape(516,1028)
Mstar = kwargs.get('Mstar',30.0)
urho = kwargs.get('urho',5.0e-14)
ul = kwargs.get('ul',0.1)
Gammae = kwargs.get('Gammae',0.2369)
Zeta = kwargs.get('Zeta',0.4644)
Lambda = kwargs.get('Lambda',0.4969)
Qo = kwargs.get('Qo',1400.0)
Alpha = kwargs.get('Alpha',0.55)
print '-----------------------------------------------'
print 'xfl : ',kwargs.get('xfl',5.0)
print 'Alpha : ',Alpha
print 'Gammae: ',Gammae
print 'Zeta : ',Zeta
print 'Lambda: ',Lambda
print 'Qo : ',Qo
print 'ul : ',ul
print 'urho : ',urho
print 'Mstar : ',Mstar
print '-----------------------------------------------'
sigmae = 0.4
clight = 3.0e10
G = 6.67e-8
Msun = 2.0e33
AU=1.5e13
uvel = np.sqrt((G*Mstar*Msun)/(ul*AU))
Dless = uvel/(urho*ul*AU*sigmae*clight)
prefactor = (3.0/2.0)*(1.0/np.pi)*Gammae*Zeta*Lambda
Kpara = (Dless**(Alpha))*((Qo**(1.0-Alpha))/(1.0-Alpha))
Tool = pp.Tools()
grv2 = Tool.Grad(Data.v2,Data.x1,Data.x2,Data.dx1,Data.dx2)
DvzDz = np.abs(grv2[:,:,1])
dvdl = DvzDz
Disk_Mt = Kpara*((1.0/Data.rho)*dvdl)**(Alpha)
Disk_Rad_r = Disk_Mt*prefactor*Srl[2:514,2:1026]
Disk_Rad_z = Disk_Mt*prefactor*Svl[2:514,2:1026]
DiskRad_force_dict={'d_dvdl':dvdl,'d_Mt':Disk_Mt,'d_Fr_r':Disk_Rad_r,'d_Fr_z':Disk_Rad_z}
return DiskRad_force_dict
def al_perp(self,Data):
[r2d, z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
Tool = pp.Tools()
GrdA3 = Tool.Grad(r2d*Data.A3,Data.x1,Data.x2,Data.dx1,Data.dx2)
magGrdA3 = np.sqrt(GrdA3[:,:,0]**2 + GrdA3[:,:,1]**2)
grda3_dict={}
grda3_dict['GrdA3r']=GrdA3[:,:,0]
grda3_dict['GrdA3z']=GrdA3[:,:,1]
grda3_dict['magGrdA3']=magGrdA3
return grda3_dict
def Pressure(self,Data):
Tool = pp.Tools()
Prgrad = Tool.Grad(Data.pr,Data.x1,Data.x2,Data.dx1,Data.dx2)
grda3 = self.al_perp(Data)
Press_tfl = (1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*Prgrad[:,:,0] + grda3['GrdA3z']*Prgrad[:,:,1])
Bpara = self.al_para(Data)
Press_afl = (1.0/(Bpara['Bpol']))*(Bpara['Br']*Prgrad[:,:,0] + Bpara['Bz']*Prgrad[:,:,1])
Press_force_dict ={}
Press_force_dict['Fp_r'] = -1.0*(Prgrad[:,:,0]/Data.rho)
Press_force_dict['Fp_z'] = -1.0*(Prgrad[:,:,1]/Data.rho)
Press_force_dict['Press_tfl']= Press_tfl
Press_force_dict['Press_afl']= Press_afl
return Press_force_dict
def dvdl(self,Data,**kwargs):
D = Data
[r2d, z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
T = pp.Tools()
gradvr = T.Grad(D.v1,D.x1,D.x2,D.dx1,D.dx2)
gradvz = T.Grad(D.v2,D.x1,D.x2,D.dx1,D.dx2)
dvrdr = gradvr[:,:,0]
dvrdz = gradvr[:,:,1]
dvzdr = gradvz[:,:,0]
dvzdz = gradvz[:,:,1]
xrat = z2d/r2d
if kwargs.get('Disk',False) == True:
dvdl = np.abs(dvzdz)
else:
dvdl = (1.0/(1.0 + xrat**2.0))*(np.abs(dvrdr) + xrat*(np.abs(dvrdz)+np.abs(dvzdr)) + (xrat**2.0)*(np.abs(dvzdz)))
return dvdl
def Lorentz(self,Data):
[r2d,z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
Tool = pp.Tools()
grb1 = Tool.Grad(Data.b1,Data.x1,Data.x2,Data.dx1,Data.dx2)
grb2 = Tool.Grad(Data.b2,Data.x1,Data.x2,Data.dx1,Data.dx2)
grb3 = Tool.Grad(Data.b3,Data.x1,Data.x2,Data.dx1,Data.dx2)
grI = Tool.Grad(r2d*Data.b3,Data.x1,Data.x2,Data.dx1,Data.dx2) # This is gradient of current r*Bphi used to estimate Jz
Jr = -grb3[:,:,1]
Jphi= grb1[:,:,1] - grb2[:,:,0]
Jz = (1.0/r2d)*grI[:,:,0]
Loren_force_dict={}
Loren_force_dict['Fl_r']= (Jphi*Data.b2 - Jz*Data.b3)/Data.rho
Loren_force_dict['Fl_z']= (Jr*Data.b3 - Jphi*Data.b1)/Data.rho
Loren_force_dict['Fl_phi']=(Jz*Data.b1 - Jr*Data.b2)/Data.rho
return Loren_force_dict
def RadPressure(self,Data,phi=10,ul=1.0,urho=1.0e-8,Mstar=10.0):
Tool = pp.Tools()
R_GasC = phc.NA*phc.kB
mu_HHe = 2.353
RefLength = ul*phc.au
RefDensity = urho
RefVel = np.sqrt((phc.G*phc.Msun*Mstar)/RefLength)
RefTemp = (RefVel**2)*(mu_HHe/R_GasC)
RefEnergy = RefDensity*(RefLength**3)*(RefVel**2)
radconstant = 4.0*(phc.sigma)/(phc.c)
dimless_radconst = radconstant*(RefTemp**4.0)*(RefLength**3.0)/(RefEnergy)
Radpr = (1.0/3.0)*dimless_radconst*((Data.Temp[:,:,phi]/RefTemp)**4.0)
RadPrgrad = Tool.Grad(Radpr,Data.x1,Data.x2,Data.dx1,Data.dx2,polar=True)
Rad_Press_force_dict ={}
Rad_Press_force_dict['RFp_r'] = -1.0*(RadPrgrad[:,:,0]/Data.rho[:,:,phi])
Rad_Press_force_dict['RFp_th'] = -1.0*(RadPrgrad[:,:,1]/Data.rho[:,:,phi])
return Rad_Press_force_dict
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()
def Mag_Pressure(self,Data):
magpol = np.sqrt(Data.b1**2 + Data.b2**2)
magpr = 0.5*magpol**2
bphipr = 0.5*Data.b3**2
Tool = pp.Tools()
Grdpolmagpr = Tool.Grad(magpr,Data.x1,Data.x2,Data.dx1,Data.dx2)
Grdphimagpr = Tool.Grad(bphipr,Data.x1,Data.x2,Data.dx1,Data.dx2)
grda3 = self.al_perp(Data)
PolMagpr_tfl = (1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*Grdpolmagpr[:,:,0] + grda3['GrdA3z']*Grdpolmagpr[:,:,1])
PhiMagpr_tfl = (1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*Grdphimagpr[:,:,0] + grda3['GrdA3z']*Grdphimagpr[:,:,1])
Bpara = self.al_para(Data)
PolMagpr_afl = (1.0/(Bpara['Bpol']))*(Bpara['Br']*Grdpolmagpr[:,:,0] + Bpara['Bz']*Grdpolmagpr[:,:,1])
PhiMagpr_afl = (1.0/(Bpara['Bpol']))*(Bpara['Br']*Grdphimagpr[:,:,0] + Bpara['Bz']*Grdphimagpr[:,:,1])
[r2d,z2d] = np.meshgrid(Data.x1,Data.x2)
r2d=r2d.T
z2d=z2d.T
pinch = 2.0*(bphipr)/r2d
pinch_tfl = (1.0/(grda3['magGrdA3']))*(grda3['GrdA3r']*pinch)
pinch_afl = (1.0/(Bpara['Br']))*(Bpara['Bpol']*pinch)
Magnetic_pressure_dict={}
Magnetic_pressure_dict['bpolpr_tfl']=PolMagpr_tfl
Magnetic_pressure_dict['bphipr_tfl']=PhiMagpr_tfl
Magnetic_pressure_dict['pinch_tfl'] = pinch_tfl
Magnetic_pressure_dict['bpolpr_afl']=PolMagpr_afl
Magnetic_pressure_dict['bphipr_afl']=PhiMagpr_afl
Magnetic_pressure_dict['pinch_afl'] = pinch_afl
return Magnetic_pressure_dict
def td(ty, t, E, rho, sigma, wdir):
D = pp.pload(t, w_dir=wdir)
if ty == 'flux':
for k in range(D.rho.shape[2]):
for j in range(D.rho.shape[1]):
for i in range(D.rho.shape[0]):
# if (i-D.rho.shape[0]/2)**2+(j-D.rho.shape[1]/2)**2+(k-D.rho.shape[2]/2)**2 > 30**2:
# D.rho[k,j,i] = rho
if D.rho[k, j, i] > 10:
D.rho[k, j, i] = rho
flux = D.rho * (D.bx1**2 + D.bx2**2 +
D.bx3**2)**1.25 * (D.vx1**2 + D.vx2**2 + D.vx3**2)**0
flux = (flux - np.mean(flux)) * 1 + np.mean(flux) * 1
flux = flux.sum(axis=0)
flux = nd.gaussian_filter(flux, sigma=(sigma, sigma), order=0)
fig = plt.figure(figsize=(7, 6))
ax = fig.add_subplot(111)
neg = ax.imshow(np.log10(flux).T,
origin='lower',
extent=[D.x2[0], D.x2[-1], D.x3[0], D.x3[-1]])
levels = np.arange(-5.5, -4, 0.5)
plt.contour(np.log10(flux).T,
levels,
origin='lower',
linewidths=2,
extent=[D.x1[0], D.x1[-1], D.x2[0], D.x2[-1]])
cbar = fig.colorbar(neg, ax=ax)
cbar.set_label(r'log(S)')
ax.set_xlabel('l offset (pc)')
ax.set_ylabel('b offset (pc)')
ax.set_title(r't=' + str(t) + r'$\ \mathregular{\rho}$=' + str(rho) +
' E=' + str(E))
fig.subplots_adjust(top=0.9, bottom=0.1, left=0.11, right=0.97)
fig.savefig('t' + str(t) + '_density' + str(rho) + '_E' + str(E) +
'.eps')
fig.clear()
ax = fig.add_subplot(111)
ax.plot((np.rot90(np.eye(len(flux))) * flux.T).sum(axis=0))
ax.set_xlim(0, 256)
fig.savefig('change.eps')
elif ty == 'rho':
# t = 850
fig = plt.figure(figsize=(7, 6))
ax = fig.add_subplot(111)
neg = ax.imshow(np.log10(D.rho[:, :, 128]).T,
origin='lower',
extent=[D.x2[0], D.x2[-1], D.x3[0], D.x3[-1]])
cbar = fig.colorbar(neg, ax=ax)
cbar.set_label(r'log($\mathregular{\rho/cm^{-3}}$)')
ax.set_xlabel('x offset (pc)')
ax.set_ylabel('y offset (pc)')
ax.set_title(r't=' + str(t) + r'$\ \mathregular{\rho}$=' + str(rho) +
' E=' + str(E))
fig.subplots_adjust(top=0.9, bottom=0.1, left=0.11, right=0.97)
T = pp.Tools()
newdims = 2 * (20, )
Xmesh, Ymesh = np.meshgrid(D.x2.T, D.x3.T)
xcong = T.congrid(Xmesh, newdims, method='linear')
ycong = T.congrid(Ymesh, newdims, method='linear')
velxcong = T.congrid(D.bx1[:, :, 128].T, newdims, method='linear')
velycong = T.congrid(D.bx2[:, :, 128].T, newdims, method='linear')
plt.gca().quiver(xcong, ycong, velxcong, velycong, color='w')
plt.show()
fig.savefig('rho-t=' + str(t) + '_density=' + str(rho) + '_E=' +
str(E) + '.eps') # Only to be saved as either .png or .jpg
# close()
else:
print(D.x1.shape)
# arr = np.meshgrid(D.x1,D.x2,D.x3)
# mlab.points3d(arr[0][0:256:8,0:256:8,0:256:8], arr[1][0:256:8,0:256:8,0:256:8], arr[2][0:256:8,0:256:8,0:256:8], D.rho[0:256:8,0:256:8,0:256:8])
vol = mlab.pipeline.volume(
mlab.pipeline.scalar_field(np.log10(D.prs * D.rho)))
ctf = ColorTransferFunction()
ctf.add_hsv_point(-8, 0.8, 1, 1)
ctf.add_hsv_point(-6.5, 0.45, 1, 1)
ctf.add_hsv_point(-5.4, 0.15, 1, 1)
vol._volume_property.set_color(ctf)
vol._ctf = ctf
vol.update_ctf = True
otf = PiecewiseFunction()
otf.add_point(-8, 0)
otf.add_point(-5.7, 0.082)
otf.add_point(-5.4, 0.0)
vol._otf = otf
vol._volume_property.set_scalar_opacity(otf)
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')
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')
gca().quiver(xcong, ycong, velxcong, velycong, color='w')
savefig('stellar_wind_1.png')
show()
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)
def Reynold(self,Data,Gammae=1.0001):
D = Data
T = pp.Tools()
dOmdr = np.zeros([D.rho.shape[0],D.rho.shape[2]])
VertAvg_Sg = np.zeros([D.rho.shape[0],D.rho.shape[2]])
VertAvg_P = np.zeros([D.rho.shape[0],D.rho.shape[2]])
VertAvg_Vr = np.zeros([D.rho.shape[0],D.rho.shape[2]])
Delta_Vr = np.zeros([D.rho.shape[0],D.rho.shape[2]])
VertAvg_Vphi = np.zeros([D.rho.shape[0],D.rho.shape[2]])
Delta_Vphi = np.zeros([D.rho.shape[0],D.rho.shape[2]])
AziAvg_Vphi = np.zeros(D.rho.shape[0])
AziAvg_Sg = np.zeros(D.rho.shape[0])
AziAvg_Vr = np.zeros(D.rho.shape[0])
AziAvg_Fa = np.zeros(D.rho.shape[0])
AziAvg_Fr = np.zeros(D.rho.shape[0])
AziAvg_Deno = np.zeros(D.rho.shape[0])
dV = D.x1[:,np.newaxis,np.newaxis]*D.x1[:,np.newaxis,np.newaxis]*np.sin(D.x2[np.newaxis,:,np.newaxis])*D.dx1[:,np.newaxis,np.newaxis]*D.dx2[np.newaxis,:,np.newaxis]*D.dx3[np.newaxis,np.newaxis,:]
Mdisk = ((D.rho*dV).sum())
Vr_avg = (D.v1*D.rho*dV).sum()/Mdisk
Vp_avg = (D.v3*D.rho*dV).sum()/Mdisk
for k in range(Data.n3):
for i in range(Data.n1):
VertAvg_Sg[i,k] = (D.rho[i,:,k]*D.x1[i]*np.sin(D.x2)*D.dx2).sum()
VertAvg_P[i,k] = (D.pr[i,:,k]*D.x1[i]*np.sin(D.x2)*D.dx2).sum()
VertAvg_Vr[i,k] = (1.0/VertAvg_Sg[i,k])*(D.rho[i,:,k]*(D.v1[i,:,k]-Vr_avg)*D.x1[i]*np.sin(D.x2)*D.dx2).sum()
VertAvg_Vphi[i,k] = (1.0/VertAvg_Sg[i,k])*(D.rho[i,:,k]*(D.v3[i,:,k]-Vp_avg)*D.x1[i]*np.sin(D.x2)*D.dx2).sum()
[r2d,phi2d]= np.meshgrid(D.x1,D.x3)
r2d = r2d.T
Fa = r2d*VertAvg_Sg*VertAvg_Vr*VertAvg_Vphi
for i in range(Data.n1):
AziAvg_Sg[i] = (VertAvg_Sg[i,:]*D.dx3).sum()
AziAvg_Vr[i] = (VertAvg_Vr[i,:]*D.dx3).sum()
AziAvg_Vphi[i] = (VertAvg_Vphi[i,:]*D.dx3).sum()
Delta_Vr[i,:] = VertAvg_Vr[i,:] - AziAvg_Vr[i]
Delta_Vphi[i,:] = VertAvg_Vr[i,:] - AziAvg_Vphi[i]
Fr = r2d*VertAvg_Sg*Delta_Vr*Delta_Vphi
Omega = VertAvg_Vphi/r2d
Ciso2 = Gammae*(VertAvg_P/VertAvg_Sg)
for k in range(D.n3):
dOmdr[:,k] = (r2d[:,k]/Omega[:,k])*T.deriv(Omega[:,k],D.x1)
Deno = r2d*VertAvg_Sg*Ciso2*np.abs(dOmdr)
for i in range(D.n1):
AziAvg_Fa[i] = (Fa[i,:]*D.dx3).sum()
AziAvg_Fr[i] = (Fr[i,:]*D.dx3).sum()
AziAvg_Deno[i] = (Deno[i,:]*D.dx3).sum()
Alpha_A = AziAvg_Fa/AziAvg_Deno
Alpha_R = AziAvg_Fr/AziAvg_Deno
return {'AlphaA': Alpha_A,'AlphaR': Alpha_R, 'Fa':AziAvg_Fa, 'Fr': AziAvg_Fr, 'Deno':AziAvg_Deno}
return {'SgRphi':VertAvg_Sg, 'VrRphi':VertAvg_Vr, 'VpRphi':VertAvg_Vphi}
