def Br_Gauss_local_factor(apar, suffix, ky_GENE): #From GENE Apar to Gauss B_r
#***********1 GENE unit to SI unit
#**** For more info, check on GENE manual page 72
#par = Parameters()
#par.Read_Pars('parameters'+suffix)
#pars = par.pardict
pars = init_read_parameters_file(suffix)
#field = fieldfile('field'+suffix,pars)
#***********geom file
#gpars,geometry = read_geometry_global(pars['magn_geometry'][1:-1]+suffix)
#geom_type, geom_pars, geom_coeff = init_global_geometry(suffix, pars)
qref = 1.6E-19
c = 1.
m_kg = 1.673E-27
Bref = pars['Bref']
Tref = pars['Tref']
nref = pars['nref']
Lref = pars['Lref']
mref = pars['mref']
nref = nref * 1.E19
Tref = Tref * qref * 1.E03
mref = mref * m_kg
pref = nref * Tref
cref = np.sqrt(Tref / mref)
Omegaref = qref * Bref / mref / c
rhoref = cref / Omegaref
rhorefStar = rhoref / Lref
Apar_norm = Bref * Lref * rhorefStar**2
#factor=ky_GENE/rhoref*Apar_norm*B_gauss
factor = ky_GENE * Bref * B_gauss * rhorefStar
return factor
def Br_Gauss_group(apar, suffix, ky_GENE): #From GENE Apar to Gauss B_r
#***********1 GENE unit to SI unit
#**** For more info, check on GENE manual page 72
#par = Parameters()
#par.Read_Pars('parameters'+suffix)
#pars = par.pardict
pars = init_read_parameters_file(suffix)
#field = fieldfile('field'+suffix,pars)
#***********geom file
#gpars,geometry = read_geometry_global(pars['magn_geometry'][1:-1]+suffix)
#geom_type, geom_pars, geom_coeff = init_global_geometry(suffix, pars)
qref = 1.6E-19
c = 1.
m_kg = 1.673E-27
Bref = pars['Bref']
Tref = pars['Tref']
nref = pars['nref']
Lref = pars['Lref']
mref = pars['mref']
nref = nref * 1.E19
Tref = Tref * qref * 1.E03
mref = mref * m_kg
pref = nref * Tref
cref = np.sqrt(Tref / mref)
Omegaref = qref * Bref / mref / c
rhoref = cref / Omegaref
rhorefStar = rhoref / Lref
Apar_norm = Bref * Lref * rhorefStar**2
#print rho_ref
#print rho_ref_star
#***************For global group
#for x in range(0,nx):
#ky_global comes from geomWrapper.py
#ky_GENE_temp=ky_global(pars, geom_coeff, x)
#***************For global group
A_SI = apar * Apar_norm
#print'*********SI test***********'
#print apar
#print A_SI
#print '************************'
#ky_SI=ky_global(pars, geom_coeff, x)[z]
#print ky_SI
#print ky_SI
ky_SI = ky_GENE / rhoref
B_r = ky_SI * A_SI * B_gauss
#print B_r
return B_r
def read_geom_file(file_type,file_name,suffix="dat"):
if file_type=="gfile":
EFITdict = read_EFIT(file_name)
xgrid = EFITdict['rhotn'] #rho_tor
q = EFITdict['qpsi']
R = EFITdict['R']
print("**************************")
print("**************************")
print(str(R))
print(np.shape(R))
R_ref=R[int(len(R)/2)]
print("**************************")
print("**************************")
return xgrid, q, R_ref
elif file_type=="GENE_tracor":
gpars,geometry = read_geometry_global(file_name)
q=geometry['q']
R=geometry['geo_R']
print("**************************")
print("**************************")
print(str(R))
print(np.shape(R))
(nz0,nx0)=np.shape(R)
R_ref=R[int(nz0/2),int(nx0/2)]
print("**************************")
print("**************************")
if suffix=="dat":
suffix=".dat"
else:
suffix="_"+suffix
pars = init_read_parameters_file(suffix)
Lref=pars['Lref']
Bref=pars['Bref']
x0_from_para=pars['x0']
#xgrid=rho_tor
if 'lx_a' in pars:
xgrid = np.arange(pars['nx0'])/float(pars['nx0']-1)*pars['lx_a']+pars['x0']-pars['lx_a']/2.0
else:
xgrid = np.arange(pars['nx0'])/float(pars['nx0']-1)*pars['lx'] - pars['lx']/2.0
print("**************************")
print("**************************")
print("xgrid min max: "+str(np.min(xgrid))+", "+str(np.max(xgrid)))
print("**************************")
print("**************************")
print("**************************")
return xgrid, q, Lref, R_ref, Bref, x0_from_para
include_qn2)[0] + '_sat' + str(sat_rule) + '_add' + str(
add_all)[0] + '_mu' + str(most_unstable)[0]
call(['ETG_quasilinear.py', suffix, sfsuffix, '-n', '-s 4'])
call(['mv', file_name, outdir])
call(['mv', file_name + '.ps', outdir])
#s4 no add most unstable only
add_all = False
include_qn2 = False
sat_rule = 4
most_unstable = True
file_name = 'QL_summary_' + suffix + '_' + sfsuffix + '_iqn2' + str(
include_qn2)[0] + '_sat' + str(sat_rule) + '_add' + str(
add_all)[0] + '_mu' + str(most_unstable)[0]
call(['ETG_quasilinear.py', suffix, sfsuffix, '-n', '-s 4', '-m'])
call(['mv', file_name, outdir])
call(['mv', file_name + '.ps', outdir])
call(['cp', 'summary_' + suffix + '.csv', outdir])
call(['cp', 'parameters_' + suffix, outdir])
call([
'cp', 'scanfiles' + sfsuffix + '/mode_info_all',
outdir + '/mode_info_all_' + sfsuffix
])
pars = init_read_parameters_file('_' + suffix)
call(['cp', pars['magn_geometry'][1:-1] + '_' + suffix, outdir])
if archive:
call(['cp', '-r', outdir, arch_dir])
def l_RIP(suffix):
# Define parameter
del_x= 0.135 #13.5cm for DIIID RIP
beam_width=0.02 #2cm for the laser beam width
real_grid= 0.02 # unit: meter, resolution of the the line integral on height
ratio_location=0. #mid-plan
aveage_delta=0.010 #average around the z=ratio_location\pm aveage_delta (beam width) in meter
#minor radius
#read-in radial location
#Initiate the momlib and fieldlib
pars = init_read_parameters_file(suffix)
field = fieldfile('field'+suffix,pars)
moms = momfile('mom_e'+suffix,pars)
#getting B field using read_write_geometry.py
gpars,geometry = read_geometry_local(pars['magn_geometry'][1:-1]+suffix)
#Get geom_coeff from geomWrapper.py
geom_type, geom_pars, geom_coeff = init_read_geometry_file(suffix, pars)
#From plot mode structures
#Setup the field file
#************************Setting up the time*****************
time0=float(options.time0)
time = np.array(field.tfld)
timemom = np.array(moms.tmom)
if time0 == -1:
itime = -1
itime0 = len(time)-1
else:
itime = np.argmin(abs(time - time0))
itime0 = itime
print("Looking at the RIP at time:",time[itime])
#field.set_time(time[itime],itime0)
field.set_time(time[itime])
moms.set_time(timemom[itime])
#********************************************
dz = 2.0/field.nz
zgrid = np.arange(field.nz)/float(field.nz-1)*(2.0-dz)-1.0
nz=len(zgrid) #number of grid in z axis
#density n0
n0_GENE = pars['nref']
#from momentsWrapper.py
#delta density, check on page 57
upar,deln,deln_global= LILO_moments_from_mom_file(pars,suffix,False,setTime=-1)
n1_GENE=abs(deln_global[:,0,:])
#B field
B0_GENE=geometry['gBfield']
#From fieldlib
Apar_GENE = abs(field.apar()[:,0,:])
#print('**********************')
#print(f'the size of the n0 is {np.shape(n0_GENE)}')
#print('**********************')
#print(f'the size of the deln is {np.shape(n1_GENE)}')
#print('**********************')
#print(f'the size of the B0 is {np.shape(B0_GENE)}')
#print('**********************')
#print(f'the size of the apar is {np.shape(Apar_GENE)}')
#**************************************************
#**************Calculating RIP globally**************
#************Normalized the density and magnetic field************
B0=np.zeros(nz)
B1=np.zeros(nz)
n1=np.zeros(nz)
#ky_GENE=np.zeros(np.shape(deln_global))
B_gauss=10.**4 #1T=10^4Gauss
qref = 1.6E-19 #in C
c = 1. #in 3*10^8m/s
m_kg = 1.673E-27 #in kg
Bref = pars['Bref'] #in Tesla
Tref = pars['Tref'] #in keV
nref = pars['nref'] #in 10^(19) /m^3
Lref = pars['Lref'] #in m
mref = pars['mref'] #in proton mass(kg)
nref = nref * 1.E19 #in the unit of /m^3
Tref = Tref * qref * 1.E03 #in the unit of J
mref = mref * m_kg #in the unit of kg
pref = nref * Tref #in Pa*kB
cref = np.sqrt(Tref / mref) #in the unit of m/s
Omegaref = qref * Bref / mref / c #in rad/s
rhoref = cref / Omegaref #in m rho_i(ion gyroradii)
rhorefStar = rhoref / Lref #Unitless
#ky comes from geomWrapper.py
ky_GENE_temp=ky(pars, geom_coeff)
n0=nref #nref
for z in range(nz):
B0[z]=abs(B0_GENE[z]*Bref*B_gauss)
B1[z]=abs(np.mean(Apar_GENE[z,:])*len(Apar_GENE[z,:])*(ky_GENE_temp[z]/rhoref)*Bref*B_gauss*rhorefStar*rhoref)
n1[z]=abs(np.mean(n1_GENE[z,:])*len(n1_GENE[z,:])*(rhorefStar)*nref)
print('******n0*********')
print(n0)
print('*******n1********')
print(n1)
print('*******B0********')
print(B0)
print('********B1*******')
print(B1)
z_loop, B0_loop = loop(zgrid,B0,-0.5,0.5)
z_loop, B1_loop = loop(zgrid,B1,-0.5,0.5)
z_loop, n1_loop = loop(zgrid,n1,-0.5,0.5)
print('*******n0 Loop********')
print(n0)
print('*******n1 Loop********')
print(n1_loop)
print('*******B0 Loop********')
print(B0_loop)
print('********B1 Loop*******')
print(B1_loop)
Ratio=np.zeros(len(z_loop))
B_ratio=np.zeros(len(z_loop))
n_ratio=np.zeros(len(z_loop))
RIP_gauss=np.zeros(len(z_loop))
for z in range(len(z_loop)):
Ratio[z]=B1_loop[z]*n0/(B0_loop[z]*n1_loop[z])
RIP_gauss[z]=B1_loop[z]
B_ratio[z]=B1_loop[z]/B0_loop[z]
n_ratio[z]=n1_loop[z]/n0
x0=z_loop
y0=Ratio
location_index_max=np.argmin(abs(x0-ratio_location-aveage_delta))
location_index_min=np.argmin(abs(x0-ratio_location+aveage_delta))
local_temp=0
if location_index_max > location_index_min:
location_index_max = location_index_max
location_index_min = location_index_min
elif location_index_min > location_index_max:
local_temp = location_index_max
location_index_max = location_index_min
location_index_min = local_temp
else:
local_temp=np.argmin(abs(x0-ratio_location))
location_index_max=local_temp
location_index_min=local_temp-1
print(location_index_min)
print(location_index_max)
RIP_0=np.mean(y0[location_index_min:location_index_max])
print("RIP ratio average at Z="+str(ratio_location)+": "+str(RIP_0))
#dB_0=np.mean(B_ratio[location_index_min:location_index_max])
#print("dB ratio average at Z="+str(ratio_location)+": "+str(dB_0))
#dn_0=np.mean(n_ratio[location_index_min:location_index_max])
#print("dn ratio average at Z="+str(ratio_location)+": "+str(dn_0))
print("Start ploting")
plt.clf()
plt.title(r'$Magnetic\ fluctuation\ ratio$')
plt.xlabel(r'$z/\pi$',fontsize=13)
plt.ylabel(r'$\frac{ n_e \delta B_r}{ \delta n_e B_0}$',fontsize=10)
plt.plot(z_loop,Ratio)
plt.savefig('Ratio.png')
#plt.show()
plt.clf()
plt.title(r'$Magnetic\ fluctuation$')
plt.xlabel(r'$z/\pi$',fontsize=13)
plt.ylabel(r'$\delta B_r$',fontsize=10)
plt.plot(z_loop,RIP_gauss)
plt.savefig('RIP_gauss.png')
#plt.show()
plt.clf()
plt.title(r'$Magnetic\ fluctuation\ Ratio$')
plt.xlabel(r'$z/\pi$',fontsize=13)
plt.ylabel(r'$\delta B_r$',fontsize=10)
plt.plot(z_loop,B_ratio)
plt.savefig('dB_ratio.png')
#plt.show()
plt.clf()
plt.title(r'$Density\ fluctuation\ Ratio$')
plt.xlabel(r'$z/\pi$',fontsize=13)
plt.ylabel(r'$\delta B_r$',fontsize=10)
plt.plot(z_loop,n_ratio)
plt.savefig('dn_ratio.png')
#plt.show()
print("End ploting")
def Read_parameter(suffix,plot=False):
#Initiate the momlib and fieldlib
pars = init_read_parameters_file(suffix)
field = fieldfile('field'+suffix,pars)
moms = momfile('mom_e'+suffix,pars)
#getting B field using read_write_geometry.py
gpars,geometry = read_geometry_global(pars['magn_geometry'][1:-1]+suffix)
#Get geom_coeff from geomWrapper.py
geom_type, geom_pars, geom_coeff = init_global_geometry(suffix, pars)
real_R=geometry['geo_R'] #it is major radius in meter
real_Z=geometry['geo_Z'] #it is height in meter, midland is 0, down is negative ,up is positive
J=geometry['jacobian'] #Jacobian
gxx=geometry['gxx']
gxy=geometry['gxy']
gxz=geometry['gxz']
gyy=geometry['gyy']
gyz=geometry['gyz']
gzz=geometry['gzz']
#from max_profile_reader.py
x_a,x_rho_ref,T,n0,omt,omn = profile_e_info(suffix)
#From plot mode structures
#Setup the field file
#************************Setting up the time*****************
time0=float(options.time0)
time = np.array(field.tfld)
timemom = np.array(moms.tmom)
if time0 == -1:
itime = -1
itime0 = len(time)-1
else:
itime = np.argmin(abs(time - time0))
itime0 = itime
print(("Looking at the RIP at time:",time[itime]))
#field.set_time(time[itime],itime0)
field.set_time(time[itime])
moms.set_time(timemom[itime])
upar,deln,deln_global= LILO_moments_from_mom_file(pars,suffix,False,setTime=-1)
#********************************************
dz = 2.0/field.nz
zgrid = np.arange(field.nz)/float(field.nz-1)*(2.0-dz)-1.0
zgrid_ext = np.arange(field.nz+4)/float(field.nz+4-1)*(2.0+3*dz)-(1.0+2.0*dz)
#print zgrid
#print zgrid_ext
if 'lx_a' in pars:
xgrid = np.arange(field.nx)/float(field.nx-1)*pars['lx_a']+pars['x0']-pars['lx_a']/2.0
else:
xgrid = np.arange(field.nx)/float(field.nx-1)*pars['lx'] - pars['lx']/2.0
nx=len(xgrid) #number of grid in x axis
nz=len(zgrid) #number of grid in z axis
if nx < 10 or nz < 10:
print("Please increase the resolution")
return 0
#density
n0_GENE = np.tile(n0, (nz, 1))
#print(n0_GENE)
#B field
B0_GENE=geometry['Bfield']
#delta density, check on page 57
upar,deln,deln_global= LILO_moments_from_mom_file(pars,suffix,False,setTime=-1)
n1_GENE=abs(deln_global[:,0,:])
#print geometry['geo_R']
#print np.shape(geometry['geo_R'])
#getting phi averaged apar and delta n
(i1,i2,i3)=np.shape(field.apar())
#print((np.shape(deln_global)))
#print(np.shape(field.apar()))
#Apar_GENE = np.zeros((i1,i3))
#for i in range(i1):
#Apar_GENE = Apar_GENE + field.apar()[i,0,:]
#n1_GENE = n1_GENE + deln_global[]
#Apar_GENE=Apar_GENE/(i2+1)
Apar_GENE = abs(field.apar()[:,0,:])
#*****************************************************************
#************Normalized the density and magnetic field************
B0=np.zeros((nz,nx))
B1=np.zeros((nz,nx))
n0=np.zeros((nz,nx))
n1=np.zeros((nz,nx))
#ky_GENE=np.zeros(np.shape(deln_global))
B_gauss=10.**4 #1T=10^4Gauss
qref = 1.6E-19 #in C
c = 1. #in 3*10^8m/s
m_kg = 1.673E-27 #in kg
Bref = pars['Bref'] #in Tesla
Tref = pars['Tref'] #in keV
nref = pars['nref'] #in 10^(19) /m^3
Lref = pars['Lref'] #in m
mref = pars['mref'] #in proton mass(kg)
nref = nref * 1.E19 #in the unit of /m^3
Tref = Tref * qref * 1000. #in the unit of J
mref = mref * m_kg #in the unit of kg
pref = nref * Tref #in Pa*kB
cref = np.sqrt(Tref / mref) #Speed of sound in the unit of m/s
Omegaref = qref * Bref / (mref * c) #Gyrofrequency in rad/s
rhoref = cref / Omegaref #gyroradius in m
rhorefStar = rhoref / Lref #gyroradius/minor radius in Unitless
for x in range(0,nx):
#ky_global comes from geomWrapper.py
ky_GENE_temp=ky_global(pars, geom_coeff, x)
#print("calc Br")
#print(x)
for z in range(0,nz):
B0[z,x]=abs(B0_GENE[z,x]*Bref*B_gauss)
B1[z,x]=abs(Apar_GENE[z,x]*ky_GENE_temp[z]*Bref*B_gauss*rhorefStar)
n0[z,x]=abs(n0_GENE[z,x]*nref)
n1[z,x]=abs(n1_GENE[z,x]*(n0_GENE[z,x]*rhorefStar)*nref)
#print("rhoi="+str(rhoref)+"m")
#print("Bref="+str(Bref))
#print("B_gauss="+str(B_gauss))
#print("Factor="+str(Bref*B_gauss*rhorefStar))
#************End of Normalized the density and magnetic field************
if plot==True:
plt.clf()
plt.ylabel(r'$Height(m)$',fontsize=10)
plt.xlabel(r'$Major\ raduis(m)$',fontsize=10)
plt.figure(
figsize=(4*(np.max(real_R)-np.min(real_R)), 4*(np.max(real_Z)-np.min(real_Z))),
dpi=96)
plt.contourf(real_R,real_Z,B0)
plt.title('B0 in real space',fontsize=10)
plt.savefig('B0.png')
plt.clf()
plt.ylabel(r'$Height(m)$',fontsize=10)
plt.xlabel(r'$Major\ raduis(m)$',fontsize=10)
plt.figure(
figsize=(4*(np.max(real_R)-np.min(real_R)), 4*(np.max(real_Z)-np.min(real_Z))),
dpi=96)
plt.contourf(real_R,real_Z,B1)
plt.title('B1 in real space',fontsize=10)
plt.savefig('B1.png')
plt.clf()
plt.ylabel(r'$Height(m)$',fontsize=10)
plt.xlabel(r'$Major\ raduis(m)$',fontsize=10)
plt.figure(
figsize=(4*(np.max(real_R)-np.min(real_R)), 4*(np.max(real_Z)-np.min(real_Z))),
dpi=96)
plt.contourf(real_R,real_Z,n0)
plt.title('n0 in real space',fontsize=10)
plt.savefig('n0.png')
plt.clf()
plt.ylabel(r'$Height(m)$',fontsize=10)
plt.xlabel(r'$Major\ raduis(m)$',fontsize=10)
plt.figure(
figsize=(4*(np.max(real_R)-np.min(real_R)), 4*(np.max(real_Z)-np.min(real_Z))),
dpi=96)
plt.contourf(real_R,real_Z,n1)
plt.title('n1 in real space',fontsize=10)
plt.savefig('n1.png')
return J,real_R,real_Z,xgrid,zgrid,B0,B1,n0,n1,gxx,gxy,gyy,gyz,gzz
def omega_calc2(suffix):
calc_from_apar = False
#suffix = '_'+suffix
#par = Parameters()
#par.Read_Pars('parameters'+suffix)
#pars = par.pardict
pars = init_read_parameters_file(suffix)
if pars['n_spec'] == 1:
time, nrgi = get_nrg0(suffix, nspec=1)
elif pars['n_spec'] == 2:
time, nrgi, nrge = get_nrg0(suffix, nspec=2)
elif pars['n_spec'] == 3:
time, nrgi, nrge, nrg2 = get_nrg0(suffix, nspec=3)
else:
sys.exit("n_spec must be 1,2,3.")
#Check for rescaling
print "tmax", time[-1]
print "tmin", time[0]
for i in range(len(time) - 1):
if abs(nrgi[i, 0] - nrgi[i + 1, 0]) / (nrgi[i, 0] +
nrgi[i + 1, 0]) > 0.8:
print "Rescaling at :", time[i]
if calc_from_apar:
print "Calculating growth rate from apar."
#plt.semilogy(time,nrge[:,7])
#plt.xlabel('time')
#plt.show()
else:
print "Calculating growth rate from phi."
#plt.semilogy(time,nrgi[:,6])
#plt.title('QiES')
#plt.xlabel('time')
#plt.show()
tstart = float(raw_input("Enter start time: "))
tend = float(raw_input("Enter end time: "))
field = fieldfile('field' + suffix, pars)
istart = np.argmin(abs(np.array(field.tfld) - tstart))
iend = np.argmin(abs(np.array(field.tfld) - tend))
field.set_time(field.tfld[-1])
imax = np.unravel_index(np.argmax(abs(field.phi()[:, 0, :])),
(field.nz, field.nx))
phi = np.empty(0, dtype='complex128')
if pars['n_fields'] > 1:
imaxa = np.unravel_index(np.argmax(abs(field.apar()[:, 0, :])),
(field.nz, field.nx))
apar = np.empty(0, dtype='complex128')
time = np.empty(0)
for i in range(istart, iend):
#field.set_time(field.tfld[i],i)
field.set_time(field.tfld[i])
phi = np.append(phi, field.phi()[imax[0], 0, imax[1]])
if pars['n_fields'] > 1:
apar = np.append(apar, field.apar()[imaxa[0], 0, imaxa[1]])
time = np.append(time, field.tfld[i])
print "phi_0,phi_f", phi[0], phi[-1]
if len(phi) < 2.0:
output_zeros = True
omega = 0.0 + 0.0J
else:
output_zeros = False
if calc_from_apar:
print "Calculating omega from apar"
if pars['n_fields'] < 2:
stop
omega = np.log(apar / np.roll(apar, 1))
dt = time - np.roll(time, 1)
omega /= dt
omega = np.delete(omega, 0)
time = np.delete(time, 0)
else:
omega = np.log(phi / np.roll(phi, 1))
dt = time - np.roll(time, 1)
omega /= dt
print 'omega', omega
omega = np.delete(omega, 0)
time = np.delete(time, 0)
gam_avg = np.average(np.real(omega))
om_avg = np.average(np.imag(omega))
if output_zeros:
sys.exit("Error: not enough time points in field selection.")
else:
print "Gamma:", gam_avg
print "Omega:", om_avg
f = open('new_omega' + suffix, 'w')
f.write('# omega_calc2\n ' + 'kymin' + ' ' + 'gamma' +
' ' + 'omega\n' + ' ' + 'std_gamma' +
' ' + 'std_omega\n')
f.write(
str(pars['kymin']) + ' ' + str(gam_avg) + ' ' + str(om_avg) +
' ' + str(np.nan) + ' ' + str(np.nan) + '\n')
f.close()
def omega_calc1(suffix):
# parser = op.OptionParser(description='')
# parser.add_option('--show_plots','-p',action='store',dest='show_plots',help = 'Display the variation as a function of z',default=False)
pars = init_read_parameters_file(suffix)
# options = parser.parse_args()
# show_plots = options.show_plots
field = fieldfile('field' + suffix, pars)
tend = field.tfld[-1]
tstart = field.tfld[-1] * 0.9
#print "tstart",tstart
#print "tend",tend
imax = np.unravel_index(np.argmax(abs(field.phi()[:, 0, :])),
(field.nz, field.nx))
phi_t = []
time = np.empty(0)
istart = np.argmin(abs(np.array(field.tfld) - tstart))
iend = np.argmin(abs(np.array(field.tfld) - tend))
phi = np.empty(0, dtype='complex128')
for i in range(istart, iend):
#print "time",field.tfld[i]
field.set_time(field.tfld[i])
phi, apar = eigenfunctions_from_field_file(pars, suffix, False, False,
field.tfld[i], False, False)
phi_t.append(phi)
time = np.append(time, field.tfld[i])
phi_t = np.array(phi_t)
omega_diffs = []
omega_t = []
weight_t = []
weight = []
omega_avg = np.empty(0, dtype='complex128')
delta_t = field.tfld[1] - field.tfld[0]
zmax = len(phi_t[0])
f = open('new_omega' + suffix, 'w')
f.write(' ' + 't' + ' ' + 'gamma' + ' ' + 'omega' +
' ' + 'std_gamma' + ' ' + 'std_omega\n')
for t in range(1, iend - istart):
for z in range(zmax):
omega_t.append(
cmath.log((phi_t[t, z] / phi_t[t - 1, z])) /
(field.tfld[t] - field.tfld[t - 1]))
weight_t.append(abs(phi_t[t, z]) + abs(phi_t[t - 1, z]))
omega_diffs = np.array([
omega_t[i * zmax:(i + 1) * zmax]
for i in range(len(omega_t) // zmax)
],
dtype='complex128')
weight = np.array([
weight_t[i * zmax:(i + 1) * zmax]
for i in range(len(weight_t) // zmax)
],
dtype='float128')
omega_avg = np.append(
omega_avg,
np.sum(omega_diffs[:, t] * weight[:, t]) / np.sum(weight[:, t]))
gamma_avg = omega_avg[t - 1].real
omega_avg2 = omega_avg[t - 1].imag
delta_gamma2 = np.sum(weight[:, t - 1] *
(gamma_avg - omega_diffs[:, t - 1].real)**
2) / np.sum(weight[:, t - 1])
delta_omega2 = np.sum(weight[:, t - 1] *
(omega_avg2 - omega_diffs[:, t - 1].imag)**
2) / np.sum(weight[:, t - 1])
f.write(
str(field.tfld[t]) + ' ' + str(gamma_avg) + ' ' +
str(omega_avg2) + ' ' + str(math.sqrt(delta_gamma2)) + ' ' +
str(math.sqrt(delta_omega2)) + '\n')
f.close()
def omega_calc(suffix):
# parser = op.OptionParser(description='')
# parser.add_option('--show_plots','-p',action='store',dest='show_plots',help = 'Display the variation as a function of z',default=False)
pars = init_read_parameters_file(suffix)
# options = parser.parse_args()
# show_plots = options.show_plots
field = fieldfile('field' + suffix, pars)
tend = field.tfld[-1]
tstart = field.tfld[-1] * 0.9
imax = np.unravel_index(np.argmax(abs(field.phi()[:, 0, :])),
(field.nz, field.nx))
phi_t = []
time = np.empty(0)
istart = np.argmin(abs(np.array(field.tfld) - tstart))
iend = np.argmin(abs(np.array(field.tfld) - tend))
phi = np.empty(0, dtype='complex128')
for i in range(istart, iend):
field.set_time(field.tfld[i])
phi, apar = eigenfunctions_from_field_file(pars, suffix, False, False,
field.tfld[i], False, False)
phi_t.append(phi)
time = np.append(time, field.tfld[i])
phi_t = np.array(phi_t)
omega_diffs = []
omega_t = []
weight_t = []
weight = []
gamma_list = np.zeros(iend - istart - 1)
omega_list = np.zeros(iend - istart - 1)
gamma_delta_list = np.zeros(iend - istart - 1)
omega_delta_list = np.zeros(iend - istart - 1)
weight_list = np.zeros(iend - istart - 1)
weight_avg = 0
omega_avg = np.empty(0, dtype='complex128')
delta_t = field.tfld[1] - field.tfld[0]
zmax = len(phi_t)
f = open('omega_new' + suffix, 'w')
f.write(' ' + 't' + ' ' + 'gamma' + ' ' + 'omega' +
' ' + 'std_gamma' + ' ' + 'std_omega\n')
for t in range(1, iend - istart):
for z in range(zmax):
omega_t.append(
cmath.log((phi_t[t, z] / phi_t[t - 1, z])) /
(field.tfld[t] - field.tfld[t - 1]))
weight_t.append(abs(phi_t[t, z]) + abs(phi_t[t - 1, z]))
#print(omega_t)
omega_diffs = np.array([
omega_t[i * zmax:(i + 1) * zmax]
for i in range(len(omega_t) // zmax)
],
dtype='complex128')
weight = np.array([
weight_t[i * zmax:(i + 1) * zmax]
for i in range(len(weight_t) // zmax)
],
dtype='float128')
#print(weight)
weight_avg = np.average(weight)
#print(weight[0,t])
#print(weight[0,t])
#print(np.sum(omega_diffs[0,t]*weight[0,t])/np.sum(weight[0,t]))
omega_avg = np.append(
omega_avg,
np.sum(omega_diffs[:, t] * weight[:, t]) / np.sum(weight[:, t]))
gamma_avg = omega_avg[t - 1].real
#print(gamma_avg)
omega_avg2 = omega_avg[t - 1].imag
delta_gamma2 = np.sum(weight[:, t - 1] *
(gamma_avg - omega_diffs[:, t - 1].real)**
2) / np.sum(weight[:, t - 1])
delta_omega2 = np.sum(weight[:, t - 1] *
(omega_avg2 - omega_diffs[:, t - 1].imag)**
2) / np.sum(weight[:, t - 1])
gamma_list[t - 1] = gamma_avg
omega_list[t - 1] = omega_avg2
gamma_delta_list[t - 1] = delta_gamma2
omega_delta_list[t - 1] = delta_omega2
weight_list[t - 1] = weight_avg
f.write(
str(field.tfld[t]) + ' ' + str(gamma_avg) + ' ' +
str(omega_avg2) + ' ' + str(math.sqrt(delta_gamma2)) + ' ' +
str(math.sqrt(delta_omega2)) + '\n')
#print("Hello World")
#print("\n",gamma_avg[1],"\n")
avg_delta = np.average(gamma_delta_list)
begin_end = choose_list(
gamma_list, avg_delta
) # choose the segment of the line that is almost constant, please refers to omega_find_line.py
begin = int(begin_end[0])
end = int(begin_end[1])
gamma_final = 0 #weighted average: \frac{Sum wegith * gamma}{Sum weight}
omega_final = 0
gamma_dev_final = 0 #weighted dev: just google it
omega_dev_final = 0
weight_sum = 0
N = end - begin
for i in range(begin - 1, end):
gamma_final = gamma_final + gamma_list[i] * weight_list[i]
omega_final = omega_final + omega_list[i] * weight_list[i]
gamma_dev_final = gamma_dev_final + gamma_delta_list[
i] * gamma_delta_list[i] * weight_list[i]
omega_dev_final = omega_dev_final + omega_delta_list[
i] * omega_delta_list[i] * weight_list[i]
weight_sum = weight_sum + weight_list[i]
gamma_final = gamma_final / weight_sum
omega_final = omega_final / weight_sum
gamma_dev_final = np.sqrt((N * gamma_dev_final) / ((N - 1) * weight_sum))
omega_dev_final = np.sqrt((N * omega_dev_final) / ((N - 1) * weight_sum))
#gamma_final=np.average(gamma_list[begin:end-1])
#omega_final=np.average(omega_list[begin:end-1])
#gamma_dev_final=np.std(gamma_avg[begin:end-1])
#omega_dev_final=np.std(omega_avg[begin:end-1])
print(" gamma is: ", gamma_final, "\n gamma_dev is", gamma_dev_final)
print("\n omega is: ", omega_final, "\n omega_dev is", omega_dev_final)
f.close()
def omega_calc(suffix,plot=False,output_file=True):
percent=40.#percentage of the time to calculate the omega
# parser = op.OptionParser(description='')
# parser.add_option('--show_plots','-p',action='store',dest='show_plots',help = 'Display the variation as a function of z',default=False)
pars = init_read_parameters_file(suffix)
# options = parser.parse_args()
# show_plots = options.show_plots
field = fieldfile('field'+suffix,pars)
tend = field.tfld[-1]
tstart = field.tfld[0]+(field.tfld[-1]-field.tfld[0])*(100.-percent)/100.
#tstart = field.tfld[0]
#print tend, tstart
imax = np.unravel_index(np.argmax(abs(field.phi()[:,0,:])),(field.nz,field.nx))
phi_t = []
time = np.empty(0)
#print np.array(field.tfld)
istart = np.argmin(abs(np.array(field.tfld)-tstart))
iend = np.argmin(abs(np.array(field.tfld)-tend))
phi = np.empty(0,dtype='complex128')
for i in range(istart,iend):
field.set_time(field.tfld[i])
phi, apar = eigenfunctions_from_field_file(pars,suffix,False,False,field.tfld[i],False,False)
phi_t.append(phi)
time = np.append(time,field.tfld[i])
phi_t = np.array(phi_t)
#***********start of omega calculation***********
function = np.mean(phi_t,axis=1)
time=np.array(time)
dt=time[1:]-time[:-1]
dt_min=np.mean(dt)
if abs(np.std(dt))>=np.min(dt)*0.01:
print('time step is NOT uniform. interperlating')
uni_time = np.linspace(min(time),max(time),int(abs((max(time)-min(time))/dt_min)*1.5)) #uniform time
uni_function = np.interp(uni_time,time,function)
else:
uni_time=time
uni_function=function
phi_t=uni_function
print(np.shape(phi_t))
time=uni_time
delta_t = time[1]-time[0]
omega_t=[]
for t0 in range(len(time)-1):
t=t0+1
if phi_t[t-1]==0: continue
elif abs(phi_t[t]/phi_t[t-1])==0:
omega_t.append(0)
elif (phi_t[t]/phi_t[t-1]).imag ==0 and (phi_t[t]/phi_t[t-1]).imag < 0:
omega_temp=complex(0,np.pi)*cmath.log(abs(phi_t[t]/phi_t[t-1]))/delta_t
if abs(omega_temp)>10**3:
continue
else:
omega_t.append(omega_temp)
else:
omega_temp=cmath.log(phi_t[t]/phi_t[t-1])/delta_t
if abs(omega_temp)>10**3:
continue
else:
omega_t.append(omega_temp)
omega_t=np.array(omega_t)
gamma_avg=np.mean(omega_t.imag)
gamma_std=np.std(omega_t.imag)
omega_avg=np.mean(omega_t.real)
omega_std=np.std(omega_t.real)
if plot==True:
plt.clf()
plt.plot(omega_t.imag,label='imag')
plt.plot(omega_t.real,label='real')
plt.show()
if abs(gamma_std/gamma_avg)>=0.3 or abs(omega_std/omega_avg)>=0.3:
print('omega(cs/a)='+str(omega_avg)+'+-'+str(omega_std))
print('gamma(cs/a)='+str(gamma_avg)+'+-'+str(gamma_std))
print('No converged, please check')
#gamma_avg=0
#gamma_std=0
#omega_avg=0
#omega_std=0
else:
print('omega(cs/a)='+str(omega_avg)+'+-'+str(omega_std))
print('gamma(cs/a)='+str(gamma_avg)+'+-'+str(gamma_std))
if output_file==True:
try:
from shutil import copyfile
copyfile('omega'+suffix, 'old_omega'+suffix)
except:
pass
f=open('omega'+suffix,'w')
f.write(' '+str(pars['kymin'])+' '+str(gamma_avg)+' '+str(omega_avg))
f.close()
return gamma_avg,gamma_std,omega_avg,omega_std
