def make_contour(r,var,model,vel,par,mode,x):
global new_r,new_zp
import seaborn as sns
sns.set(style="white",rc={"figure.figsize": (8, 8),'axes.labelsize': 16,
'ytick.labelsize': 12,'xtick.labelsize': 12,'axes.titlesize':18})
t_var = np.empty(var[x::,:].shape)
t_r = np.empty(t_var.shape)
for i in range(len(r[0,:])):
t_var[:,i] = var[x::,i]
t_r[:,i] = np.linspace(r[0,i],r[-1,i],len(t_var[:,i]))
var = 1.*t_var
r = 1.*t_r
new_r = lint.leg_interp(r[0:-2,:],8,"EVEN")
new_zp = lint.leg_interp(var[0:-2,:],8,"EVEN")
#levels = np.linspace(np.min(new_zp),np.max(new_zp), 40)
#####REMOVE 0-10deg at the pole:
new_r = new_r[:,11::]
new_zp = new_zp[:,11::]
theta = np.linspace(0,np.deg2rad(90),89)
#########################################
#theta = np.linspace(0,np.deg2rad(90),100)
newt,n_r = np.meshgrid(theta,new_r[:,0])
# np.savetxt("/home/castaned/x.dat",(new_r*np.sin(newt)))
# np.savetxt("/home/castaned/y.dat",(new_r*np.cos(newt)))
# np.savetxt("/home/castaned/z.dat",(new_zp))
plt.contourf((new_r*np.sin(newt)),(new_r*np.cos(newt)),new_zp, 100, cmap=plt.cm.gnuplot,vmax=np.max(new_zp), vmin=np.min(new_zp))
plt.contourf((new_r*np.sin(newt)),-(new_r*np.cos(newt)),new_zp, 100, cmap=plt.cm.gnuplot,vmax=np.max(new_zp), vmin=np.min(new_zp))
plt.contourf(-(new_r*np.sin(newt)),-(new_r*np.cos(newt)),new_zp, 100, cmap=plt.cm.gnuplot,vmax=np.max(new_zp), vmin=np.min(new_zp))
plt.contourf(-(new_r*np.sin(newt)),(new_r*np.cos(newt)),new_zp, 100, cmap=plt.cm.gnuplot,vmax=np.max(new_zp), vmin=np.min(new_zp))
#CSl = plt.contour((new_r*np.sin(newt)),(new_r*np.cos(newt)),new_zp, 20, colors="k")
#CS = plt.contourf((new_r*np.cos(newt)), (new_r*np.sin(newt)), new_zp, cmap=plt.cm.Spectral,levels=levels)
#plt.axes().set_aspect('equal')
#plt.xlim(np.ceil(r[-1,-1]))
plt.ylim(-plt.xlim()[1],plt.xlim()[1])
#plt.xlabel("Radius [R$_{\odot}$]")
#plt.ylabel("Radius [R$_{\odot}$]")
plt.axis('off')
try:
m = (find_name(model,vel,par,mode)).strip()
except:
m = "freq_%.5f" % find_sigma(model,vel,par,mode)
v = find_vel(model,vel)
plt.title("M"+model[0]+"_V"+v+" - mode: "+ m)
return
def find_dr_ofmax(mode, depth, vels):
maxvals = []
for i in range(len(vels)):
tmode = emode(mode.mass, i, mode.name)
xi_r, xi_t, dt_t, zg, r, zp, sig, cs, where = load_MODE_file(
[mode.mass], i, tmode.index, tmode.parity, tmode.frequency, True,
False)
if mode.parity == "EVEN":
xi_r_fine = lint.leg_interp(xi_r[-depth::, :], 8, "EVEN")
xi_t_fine = lint.leg_interp(xi_t[-depth::, :], 8, "EVEN")
dt_t_fine = lint.leg_interp(dt_t[-depth::, :], 8, "EVEN")
else:
xi_r_fine = lint.leg_interp(xi_r[-depth::, :], 8, "OE")
xi_t_fine = lint.leg_interp(xi_t[-depth::, :], 8, "OE")
dt_t_fine = lint.leg_interp(dt_t[-depth::, :], 8, "OE")
rs_n = np.empty(xi_r_fine.shape)
for d in range(depth):
rs_n[d, :] = np.interp(np.linspace(0, 90, 100),
np.linspace(10, 80, 8), r[-d - 1, :])
#plt.plot(np.abs(xi_r_fine[-1,:]*rs_n[-1,:]))
maxval = np.argmax(np.abs(xi_r_fine[-1, :] * rs_n[-1, :]))
maxvals.append([
maxval,
np.linspace(0, 90, 100)[maxval],
(xi_r_fine[-1, :] * rs_n[-1, :])[maxval]
])
maxvals = np.array(maxvals)
return maxvals
def norm_and_scale(xi_r, xi_t, dt_t, rs, ZG, norm_f, scale, depth, reese, sig,
par):
global folder, rotorc_f
xi_r_n = np.empty(xi_r[-(depth + 1):-1, :].shape)
xi_t_n = np.empty(xi_r[-(depth + 1):-1, :].shape)
dt_t_n = np.empty(xi_r[-(depth + 1):-1, :].shape)
rs_n = np.empty(rs[-(depth + 1):-1, :].shape)
ZG_n = np.empty(xi_r[-(depth + 1):-1, :].shape)
import legendre_interp as lint
if par == "EVEN":
xi_r_fine = lint.leg_interp(xi_r[-depth::, :], 8, "EVEN")
else:
xi_r_fine = lint.leg_interp(xi_r[-depth::, :], 8, "OE")
rs_n = np.empty(xi_r_fine.shape)
for d in range(depth):
rs_n[d, :] = np.interp(np.linspace(0, 90, 100), np.linspace(10, 80, 8),
rs[-d - 1, :])
dr_n = xi_r_fine * rs_n[-depth::, :]
#[plt.plot(xi_r_fine[i,:]) for i in range(len(xi_r_fine[:,0])) ]
#print "omega = ",sig
#scale = scale/(sig**2)
if norm_f:
for i in np.arange(-(depth), 0, 1):
i_max = np.argmax(np.abs(xi_r[i, :]))
i_max_fine = np.argmax(np.abs(xi_r_fine[i, :]))
i_max_fine = np.argmax(np.abs(dr_n[i, :]))
#vmax = np.max(np.abs(xi_r_fine[i,:]))
#vmax = 1.*xi_r_fine[i,i_max_fine]
vmax = 1. * dr_n[i, i_max_fine]
#vmax = 1.*xi_r[i,0]
#vmax = 1.
# print "VMAX-------",vmax, xi_r[i,:]
# xi_r_n[i,:] = xi_r[i,:]/xi_r[i,i_max]
# xi_t_n[i,:] = xi_t[i,:]/xi_r[i,i_max]
# dt_t_n[i,:] = dt_t[i,:]/xi_r[i,i_max]
# ZG_n[i,:] = ZG[i,:]/xi_r[i,i_max]
xi_r_n[i, :] = xi_r[i, :] / vmax
xi_t_n[i, :] = xi_t[i, :] / vmax
dt_t_n[i, :] = dt_t[i, :] / vmax
ZG_n[i, :] = ZG[i, :] / vmax
dr_n[i, :] = dr_n[i, :] / vmax
xi_r_n *= scale
xi_t_n *= scale
dt_t_n *= scale
ZG_n *= scale
dr_n *= scale
#print xi_r_n
else:
xi_r_n = xi_r * scale
xi_t_n = xi_t * scale
dt_t_n = dt_t * scale
ZG_n = ZG * scale
# t_reese = scale/(sig**2)
# tmp=(np.max(np.sqrt(xi_r[:,:]**2+xi_t[:,:]**2)))
# print "Reese normalization:",t_reese*(1./tmp)
# if reese:
# """
# for i in np.arange(-(depth),0,1):
# i_max=np.argmax(np.abs(xi_r[i,:]))
# xi_r_n[i,:] = xi_r[i,:]/xi_r[i,i_max]
# xi_t_n[i,:] = xi_t[i,:]/xi_r[i,i_max]
# dt_t_n[i,:] = dt_t[i,:]/xi_r[i,i_max]
# ZG_n[i,:] = ZG[i,:]/xi_r[i,i_max]
# """
#
# xi_r_n = xi_r[-(depth+1):-1,:]*t_reese*(1./tmp)
# xi_t_n = xi_t[-(depth+1):-1,:]*t_reese*(1./tmp)
# dt_t_n = dt_t[-(depth+1):-1,:]*t_reese*(1./tmp)
# ZG_n = ZG[-(depth+1):-1,:]*t_reese*(1./tmp)
# #print "Reese normalization: "+str(t_reese)
return xi_r_n, xi_t_n, dt_t_n, ZG_n, dr_n
def run_visc_pert(model,vel,mode,par,sigma,reese,force_f,minL,phase=0.,ampl=1.,tlmax=0.,tcut=False):
# Info for del dot xi calculation:------------------
# NRO Mode filename:
#modefname="MODE1"
global kind
norm_f = True
ssc = 0.02
if model[0]=="2p5": ssc = 0.01
if kind=="g":
scale = ssc
else:
scale = ssc/(sigma**2)
scale =0.001*drtempmax
depth = 10 #radial zones down from the surface
forcenro = False
#---------------------------------------------------
#clic_run = True
v = find_vel(model,vel)
folder = homedir+"ROTORCmodels/"+par+"/M"+model[0]+"_V"+v+"/"
rotorc_f = homedir+"From_Bob/Delta_Scuti_2010/"+model[0]+"Msun/"+model[0]+"Msun_V"+v+"/"
bob_bin = homedir+"From_Bob/clotho_disc10_bin/"
static_m = homedir+"ROTORCmodels/visibilities/"
#check if visibility file from pulset exits for the selected model:
#v_file = glob.glob(rotorc_f+"visibility_file")
###### FULL MODE FILE GENERATION:
temp_freqs = np.genfromtxt(folder+"temp_freqs")
tfreq = temp_freqs[mode-1]
if force_f==True:
tfreq = sigma
print sigma
#tfreq = 1.59692
#print pyNRO.run_nro(tfreq,folder,model[0],v,par,mode)
where =static_m+model[0]+'Msun/V'+v+"/MODE_"+par+"_"+str(mode)
if not os.path.exists(static_m+model[0]+'Msun/'+'V'+v):
os.makedirs(static_m+model[0]+'Msun/'+'V'+v)
if not os.path.exists(static_m+model[0]+'Msun/'+'V'+v+"/MODE_"+par+"_"+str(mode)):
os.makedirs(where)
if os.path.isfile(where+'/MODE_'+par+'_'+str(mode))==False or forcenro==True:
#check if visibility file from pulset exits for the selected model:
#v_file = glob.glob(rotorc_f+"visibility_file")
if True:
os.chdir(rotorc_f)
r_mod_name = glob.glob("*_ZAMS")
subprocess.call(["cp",r_mod_name[0],"orcmod_pulset"])
subprocess.call([bob_bin+"pulsetnonadb.exe"])
print "Generated visibility_file in "+rotorc_f
subprocess.call([bob_bin+"pulset_gammas.exe"]) #Generates Cmod with gammas
subprocess.call(["cp","Cmod",folder+"Dmod_"+model[0]+"M_V"+v])
print "Generated new Dmod"
#print(glob.glob("*_ZAMS"))
os.chdir(vis_path)
print "Dmod with GAMMAS generated!"
nro_stat = 1
idx_iter = 0
while nro_stat==1:
#RUN NRO!
nro_stat = pyNRO.run_nro(tfreq-idx_iter*1e-4,folder,model[0],v,par,mode,homedir)
idx_iter += 1
subprocess.call(['mv',folder+'MODE_'+par+'_'+str(mode),where+'/MODE_'+par+'_'+str(mode)])
print "Mode file generation complete!"
else:
print "Mode file found! Not running NRO..."
###### del_DOT_xi>
#modeloc = static_m+model[0]+'Msun/V'+vels[vel]+"/"
modeloc = where+"/"
modefname = 'MODE_'+par+'_'+str(mode)
#modefname = 'MODE13'
global s_model
s_model = np.genfromtxt(glob.glob(static_m+model[0]+'Msun/'+model[0]+'Msun_V'+v+"*")[0])
global xi_r_rot,xi_t_rot,dt_t_rot,zg_rot
global xi_r,xi_t,dt_t,zg,r,zp,cs,xi_dot_g
global xi_r_n,xi_t_n,dt_t_n,zg_n
xi_r,xi_t,dt_t,zg,r,zp,sig,cs,xi_dot_g = ddxi.calcdeldotxi(par,model,vel,modeloc,modefname)
xi_r_n,xi_t_n,dt_t_n,zg_n,dr_n = ddxi.norm_and_scale(xi_r,xi_t,dt_t,r,zg,norm_f,scale,depth,reese,sig,par)
if phase!=0:
#dt_t_n = phaser(dt_t_n,phase,1.,tlmax)
#xi_r_n = phaser(xi_r_n,0.,1.,tlmax)
dt_t_n,psi_T,psi_L,mx = phaser2(dt_t_n,phase,np.max(np.abs(dt_t[-depth])),np.max(np.abs(xi_r[-depth])))
xi_r_n = phaser(xi_r_n,0.,1.,mx+np.pi)
print "Theta L_max-----------> ",np.rad2deg(mx),"deg"
np.savetxt(modeloc+"phases.txt",[psi_T,psi_L,np.rad2deg(mx+np.pi)],header="psi_T[deg],psi_L[deg],theta_max_L[deg]")
a_r = scint.trapz(dt_t_n[-1,:])
inv_f = 1.
if a_r<0:
print "-T area"
#xi_r_n *= -1.
#xi_t_n *= -1.
#dt_t_n *= -1.
#zg_n *= -1.
inv_f = -1.
if minL==True:
inv_f *= -1.
#xi_r_rot,xi_t_rot,dt_t_rot,zg_rot = ddxi.to_rotorc(xi_r_n,xi_t_n,dt_t_n,zg_n)
if par == "EVEN":
xi_r_fine = lint.leg_interp(xi_r_n[:,:],8,"EVEN")
xi_t_fine = lint.leg_interp(xi_t_n[:,:],8,"EVEN")
dt_t_fine = lint.leg_interp(dt_t_n[:,:],8,"EVEN")
else:
xi_r_fine = lint.leg_interp(xi_r_n[:,:],8,"OE")
xi_t_fine = lint.leg_interp(xi_t_n[:,:],8,"OE")
dt_t_fine = lint.leg_interp(dt_t_n[:,:],8,"OE")
global rs_n,rs_rot
rs_n = np.empty(xi_r_fine.shape)
for d in range(depth):
rs_n[d,:] = np.interp(np.linspace(0,90,100),np.linspace(10,80,8),r[-d-1,:])
# dr_n = xi_r_fine*rs_n
# for i in range(len(dr_n[:,0])):
# imax = np.argmax(np.abs(dr_n[i,:]))
# dr_n[i,:] = dr_n[i,:]/(dr_n[i,imax]/2.28534026)
p_angles = np.empty(np.shape(xi_r_n))
p_angles_fine = np.empty(np.shape(xi_r_fine))
rot_ang = np.arange(4.5,90.,9)
xi_r_rot = np.empty((depth,len(rot_ang)))
xi_t_rot = np.empty((depth,len(rot_ang)))
dt_t_rot = np.empty((depth,len(rot_ang)))
rs_rot = np.empty((depth,len(rot_ang)))
for d in range(depth):
p_angles[d,:] = (np.linspace(10,80,8))*(1.+xi_t_n[d,:])
p_angles_fine[d,:] = (np.linspace(0,90,100))*(1.+xi_t_fine[d,:])
xi_r_rot[d,:] = np.interp(rot_ang,p_angles_fine[d,:],xi_r_fine[d,:])
xi_t_rot[d,:] = np.interp(rot_ang,p_angles_fine[d,:],xi_t_fine[d,:])
dt_t_rot[d,:] = np.interp(rot_ang,p_angles_fine[d,:],dt_t_fine[d,:])
rs_rot[d,:] = np.interp(rot_ang,p_angles_fine[d,:],rs_n[d,:])
#
# #plt.plot(p_angles_fine[2,:],xi_t_fine[2,:])
# if dr_n[0,-1]>0:
# ivrt = 1.
# else:
# ivrt = -1.
# vr = ivrt*dr_n[0,:]
# #vr = ivrt*dt_t_fine[0,:]
# #lblb = find_vel(model,vel)+" km s$^{-1}$ "+find_name(model,vel,par,mode)
# lblb = find_vel(model,vel)+" km s$^{-1}$ "
# #lblb = r"$\ell$ = "+find_name(model,vel,par,mode).split()[0]
# etsy = "-"
# if find_name(model,vel,par,mode).split()[0] == "2": etsy = "-"
# if par == "EVEN":
# #plt.plot(p_angles_fine[2,:],ivrt*lint.leg_interp(vr[:,:],8,"EVEN")[0,:],label=lblb)
# plt.plot(p_angles_fine[2,:],vr,ls=etsy,label=lblb)
#
# else:
# #plt.plot(p_angles_fine[2,:],ivrt*lint.leg_interp(vr[:,:],8,"OE")[0,:],label=lblb)
# plt.plot(p_angles_fine[2,:],vr,ls=etsy,label=lblb)
# #plt.plot(p_angles_fine[2,:],lint.leg_interp(xi_r[-depth::,:],8,"OE")[2,:],label=find_name(model,vel,par,mode))
# #plt.plot(p_angles[2,:],dt_t[-depth+2,:],"o",mfc="white",mec="k",mew=1)
# #plt.grid()
# plt.xlim(0,90)
# plt.yticks()
# plt.xlabel("Colatitude [deg]")
# plt.ylabel(r"$\delta$R [R$\odot$]")
# #plt.ylabel(r"$\delta$T/T")
# plt.legend(loc="best")
# #plt.title("Mode:" + find_name(model,vel,par,mode))
# #ax.yaxis.set_major_formatter(majorFormatter)
# plt.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
# #plt.title(r"M="+model[0]+"M$_{\odot}$, V="+v+"km s$^{-1}$")
# plt.title(r"M="+model[0]+"M$_{\odot}$")
print "Generating fine clic model..."
pmodels_fine = gen_fine_clic(p_angles_fine,xi_r_fine,xi_t_fine,dt_t_fine,rs_n,dr_n,s_model,model,depth,inv_f,par,tcut)
############ find the perturbed models:
global omega
G = 6.67259e-8
mass = (float((model[0]).replace("p",".")))*1.99e33
theta = np.deg2rad(s_model[:,0])
radius = s_model[:,1]*6.96e10
vrot = s_model[:,4]*1e5
omega = vrot/(radius*np.sin(theta))
omega = np.average(omega[1:-1])
#g_r = (G*mass/(radius**2))-((omega**2)*(radius*np.sin(theta)))*np.sin(theta)
#g_theta = ((omega**2)*(radius*np.sin(theta)))*np.cos(theta)
#geff = (g_r**2 + g_theta**2)**0.5
pert_r = np.empty((len(s_model[:,0]),depth))
pert_t = np.empty((len(s_model[:,0]),depth))
pmodels = []
for i in range(depth):
pert_r[:,i] = s_model[:,1]*(1.+inv_f*xi_r_rot[-i,:])
pert_t[:,i] = s_model[:,2]*(1.+inv_f*dt_t_rot[-i,:])
g_pert = (G*mass/((pert_r[:,i]*6.96e10)**2))-((omega**2)*((pert_r[:,i]*6.96e10)*np.sin(theta)))*np.sin(theta)
for j in range(len(g_pert)):
if np.log10(g_pert[j])>4.33: g_pert[j]=10**(4.33)
tmodel = 1.*s_model
tmodel[:,1] = pert_r[:,i]
tmodel[:,2] = pert_t[:,i]
tmodel[:,3] = np.log10(g_pert)
pmodels.append(tmodel)
if par=="ODD":
pert_r = np.empty((2*len(s_model[:,0]),depth))
pert_t = np.empty((2*len(s_model[:,0]),depth))
pmodels = []
odd_angles = np.arange(4.5,180.,9)
for i in range(depth):
pert_r[0:10,i] = s_model[:,1]+inv_f*xi_r_rot[-i,:]*rs_rot[-i,:]
pert_t[0:10,i] = s_model[:,2]*(1.+inv_f*dt_t_rot[-i,:])
pert_r[10:20,i] = s_model[::-1,1]*(1.-inv_f*xi_r_rot[-i,::-1])
pert_t[10:20,i] = s_model[::-1,2]*(1.-inv_f*dt_t_rot[-i,::-1])
g_pert = (G*mass/((pert_r[:,i]*6.96e10)**2))-((omega**2)*((pert_r[:,i]*6.96e10)*np.sin(odd_angles)))*np.sin(odd_angles)
for j in range(len(g_pert)):
if np.log10(g_pert[j])>4.33: g_pert[j]=10**(4.33)
tmodel = np.empty((20,5))
tmodel[:,0] = odd_angles[:]
tmodel[:,1] = pert_r[:,i]
tmodel[:,2] = pert_t[:,i]
#tmodel[0:10,3] = s_model[:,3]
#tmodel[10:20,3] = s_model[::-1,3]
tmodel[:,3] = np.log10(g_pert)
tmodel[0:10,4] = s_model[:,4]
tmodel[10:20,4] = s_model[::-1,4]
pmodels.append(tmodel)
# plt.plot(pmodels[-1][:,0],s_model[:,1],"--",color="0.5")
#
# global old_modes
# import seaborn as sns
# sns.set(style="white",rc={"figure.figsize": (8, 8),'axes.labelsize': 16,
# 'ytick.labelsize': 12,'xtick.labelsize': 12,
# 'legend.fontsize': 16,'axes.titlesize':18,'font.size':14})
# #plt.plot(pmodels[2][0:-1,0],np.diff(pmodels[2][:,1])/(pmodels[2][1,0]-pmodels[2][0,0]),label=r"$\ell=$"+find_name(model,vel,par,mode).strip().split()[0])
# #plt.plot(pmodels[2][:,0],pmodels[2][:,1],label="old way")
# #plt.plot(pmodels_fine[2][0:-1,0],np.diff(pmodels_fine[2][:,1])/(pmodels_fine[2][1,0]-pmodels_fine[2][0,0]))
# plt.plot(pmodels_fine[2][:,0],pmodels_fine[2][:,2],"-",lw=1.5,label=r"$\ell=$"+find_name(model,vel,par,mode).strip().split()[0])
# #plt.plot(s_model[:,0],s_model[:,1],label="Static")
# #plt.vlines(90,9100,9300)
# o_lims = plt.ylim()
# #plt.vlines(90,min(pmodels_fine[2][:,2])-100,max(pmodels_fine[2][:,2])+100)
# plt.grid()
# plt.xlim(0,180)
# #plt.ylim(o_lims[0],o_lims[1])
# plt.xlabel("Colatitude [deg]")
# plt.ylabel("Radius [M$_{\odot}$]")
# #plt.ylabel("Temperature [K]")
# plt.legend(loc="best")
# #plt.title("Mode: " + find_name(model,vel,par,mode))
#plt.title(r"Perturbed T$_{\mathrm{eff}}$ - M="+model[0]+"M$_{\odot}$, V="+v+"km s$^{-1}$")
return modeloc,pmodels,pmodels_fine