def plot_volume(in_dict, time_array, route, o_dir, case_name): #----parameters----# Ro = readf.get_variable(in_dict, 'radius', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') year = 365 * 24 * 3600 time_scaling = pow(Ro, 2.0) / Kappa / (1e6 * year) melt_scaling = pow(Ro, 3.0) / 1e9 v_file = '%s/%s.volume.dat' % (route, case_name) if os.path.isfile(v_file) is False: print('no file %s' % (v_file)) return #----read data----# v_data, v_steps = readf.read_q_file(v_file, time_array, 6) v_time = v_data[:, 0] * time_scaling v_T = v_data[:, 1] v_melt = v_data[:, 5] * melt_scaling #print(v_time) #debug #print(v_T) #debug #----plot figures----# case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) o_dir = Mpf.assign_output_dir("%s/vol" % (case_dir)) fig, ax = plt.subplots() ax = plt.subplot(2, 1, 1) plt.plot(v_time, v_T, 'r-') ax.set(ylabel='Temperature[1.0]') ax = plt.subplot(2, 1, 2) plt.plot(v_time, v_melt, 'c-') ax.set(xlabel='Time [ma]', ylabel='Total melt volume [km^3]') fig.savefig("%s/volume_value.eps" % (o_dir)) plt.close(fig)
def hoz_combine(in_dict, route, cname, ta, steps, hdict): fname = '%s_hoz_combine' % (cname) dir0 = './gmt' temp = hdict['temp'] rho = hdict['rho'] col = hdict['col'] nprocz = readf.get_variable(in_dict, 'nprocz', 'int') noz = readf.get_variable(in_dict, 'nodez', 'int') lnoz = int((noz - 1) / nprocz) + 1 foname = '%s/%s' % (dir0, fname) if os.path.isfile(foname): os.remove(foname) for i in range(len(steps)): step = steps[i] t = ta[step] for pz in range(nprocz): filename = '%s/%s.horiz_avg.%d.%d' % (route, cname, pz, step) data = readf.read_data(filename) with open(foname, 'a') as fo: for lnz in range(lnoz): if pz >= 1 and lnz == 0: continue nn = lnz * col fo.write('%.4e %.4e %.4e %.4e\n' % (t, data[nn], data[nn + temp], data[nn + rho])) return fname
def __init__(self, _paraDict, _colsDict, _stepsTuple): self.cD = _colsDict self.sT = _stepsTuple self.dataFile = _paraDict['datafile'] Ro = readf.get_variable(_paraDict, 'radius', 'float') Kappa = readf.get_variable(_paraDict, 'thermdiff', 'float') self.tScale = Ro**2.0 / Kappa / (1e6 * year)
def LowerMantle(_paraDict): tiny = 1e-6 Range = [] ro = readf.get_variable(_paraDict, 'radius_outer', 'float') ri = readf.get_variable(_paraDict, 'radius_inner', 'float') Range.append(ri - tiny) Range.append((ri + ro) / 2.0 + tiny) return Range
def IbcLayer(_paraDict): Range = [] IbcInterfaceIndex = 1 blur = 0.8 InterF = readf.get_variable(_paraDict, 'z_interface', 'float_list') zLith = readf.get_variable(_paraDict, 'z_lith', 'float') ro = readf.get_variable(_paraDict, 'radius_outer', 'float') upper = ro - zLith lower = InterF[IbcInterfaceIndex] thick = upper - lower Range.append(lower - blur * thick) Range.append(upper + blur * thick) return Range
def plot_volume_1(in_dict, time_array, route, o_dir, case_name, settings): #----parameters----# column_dict = settings['column'] color_dict = settings['color'] Ro = readf.get_variable(in_dict, 'radius', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') year = 365 * 24 * 3600 time_scaling = pow(Ro, 2.0) / Kappa / (1e6 * year) melt_scaling = pow(Ro, 3.0) / 1e9 v_file = '%s/%s.volume.dat' % (route, case_name) if os.path.isfile(v_file) is False: print('no file %s' % (v_file)) return data = readf.read_data_1(v_file) temp = column_dict['step'] step_array = data[:, temp] xdata = np.zeros(step_array.shape) for n in range(step_array.size): step = int(step_array[n]) xdata[n] = time_array[step] * time_scaling #----plot figures----# case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) o_dir = Mpf.assign_output_dir("%s/vol" % (case_dir)) fig, ax = plt.subplots() #----temperature----# ax = plt.subplot(2, 1, 1) temp = column_dict['temp'] ydata = data[:, temp] color_type = color_dict['temp'] plt.plot(xdata, ydata, color=color_type, linestyle='-', label='average T') ax.legend() ax.set(ylabel='Temperature[1.0]') #----melting----# ax = plt.subplot(2, 1, 2) temp = column_dict['melting'][0] color_type = color_dict['melting'][0] n_c = len(column_dict['melting']) - 1 ydata = data[:, temp] * melt_scaling plt.plot(xdata, ydata, color=color_type, linestyle='-', label='total') for n in range(n_c): name = 'chemical %d' % (n) temp = column_dict['melting'][n + 1] ydata = data[:, temp] * melt_scaling color_type = color_dict['melting'][n + 1] plt.plot(xdata, ydata, color=color_type, linestyle='--', label=name) ax.legend() ax.set(xlabel='Time [ma]', ylabel='Total melt volume [km^3]') fig.savefig("%s/volume_value.eps" % (o_dir)) plt.close(fig)
def magnetism_intensiy(in_dict, q_data, Tc): pi = np.pi G = 6.67e-11 alphac = 6e-5 rhoc = 7400 kc = 40 Ro = readf.get_variable(in_dict, 'radius', 'float') rc = readf.get_variable(in_dict, 'radius_inner', 'float') Rc = Ro * rc cpc = 800 f = 1.0 / 7 fohm = 1.0 c = 0.63 mu0 = 4 * pi * 1e-7 qad = 4 * pi * G * alphac * rhoc * Tc * kc * Rc / (3 * cpc) qdiff = (q_data - qad) * (q_data - qad > 0.0) B = f * (Rc / Ro)**(3.0) * (2 * mu0 * fohm * c * rhoc** (1.0 / 3))**(0.5) * (qdiff * qad * Rc / (kc * Tc))**(1.0 / 3) return B, qad
def heat_flux(in_dict, time_array, step_tuple, route, o_dir, case_name, **kwargs): def _config(name, default): try: return kwargs[name] except KeyError: return default year = 365 * 24 * 3600 write_q = readf.get_variable(in_dict, 'write_q_files', 'int') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') Cp = readf.get_variable(in_dict, 'cp', 'float') Rho = readf.get_variable(in_dict, 'density', 'float') Tref = readf.get_variable(in_dict, 'reftemperature', 'float') Tsurf = readf.get_variable(in_dict, 'surftemperature', 'float') Ro = readf.get_variable(in_dict, 'radius', 'float') case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) o_dir = Mpf.assign_output_dir("%s/heat_flux" % (case_dir)) Therm_k = Kappa * Cp * Rho time_scaling = pow(Ro, 2.0) / Kappa / (1e6 * year) hq_scaling = Therm_k * Tref / Ro * 1e3 #----read data----# q_file = "%s/%s.qb.dat" % (route, case_name) cols = _config('cols', 5) q_data, q_steps = readf.read_q_file(q_file, time_array, cols) #for i in q_data[:,0]: # print(i)#debug #print(q_steps) #debug colt = _config('colt', 0) colq = _config('colq', 1) colT = _config('colT', 3) print(q_data.size) q_time = q_data[:, 0] * time_scaling #print(q_data[:,0]) #debug q_hq = q_data[:, 1] * hq_scaling if colT is not None: Tc = q_data[:, 3] * Tref + Tsurf else: Tc = Tref * np.ones(q_time.size) + Tsurf B, qad = magnetism_intensiy(in_dict, q_hq / 1e3, Tc) qad = qad * 1e3 B = B * 1e6 #----plot figures----# fig, ax = plt.subplots() ax = plt.subplot(2, 1, 1) #fig, ax = plt.subplots() plt.plot(q_time, q_hq, 'r-') ax.set(ylabel='Heat Flux[mw/m3]') ax = plt.subplot(2, 1, 2) #fig, ax = plt.subplots(212) plt.plot(q_time, B, 'b-') ax.set(xlabel='Time [ma]', ylabel='Magnetism [/muT]') #plt.show() fig.savefig("%s/cmb_heatflux.eps" % (o_dir)) plt.close(fig)
def __init__(self, _paraDict, _colsDict, _stepsTuple, _tArray): self.cD = _colsDict self.sT = _stepsTuple self.tA = _tArray self.dataFile = _paraDict['datafile'] self.nProcZ = readf.get_variable(_paraDict, 'nprocz', 'int') Alpha = readf.get_variable(_paraDict, 'thermexp', 'float') Tref = readf.get_variable(_paraDict, 'reftemperature', 'float') self.Rho = readf.get_variable(_paraDict, 'density', 'float') self.RhoScale = Alpha * Tref * self.Rho self.bA = readf.get_variable(_paraDict, 'buoyancy_ratio', 'float_list') Ro = readf.get_variable(_paraDict, 'radius', 'float') Kappa = readf.get_variable(_paraDict, 'thermdiff', 'float') self.tScale = Ro**2.0 / Kappa / (1e6 * year) self.vScale = Kappa / Ro * year * 1e2
def plot_mf_melting(in_dict, time_array, route, o_dir, case_name, settings): #----parameters----# column_dict = settings['column'] color_dict = settings['color'] Ro = readf.get_variable(in_dict, 'radius', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') year = 365 * 24 * 3600 time_scaling = pow(Ro, 2.0) / Kappa / year filename = '%s/%s.mf.dat' % (route, case_name) if os.path.isfile(filename) is False: print('no file %s' % (filename)) return data = np.genfromtxt(filename) temp = column_dict['step'] step_array = data[:, temp] temp = column_dict['eular'] eu_rate = data[:, temp] temp = column_dict['tracer'] csize = len(temp) - 1 tr_rate = data[:, temp[0]] tr_rate_comp = np.zeros((tr_rate.size, csize)) for i in range(csize): tr_rate_comp[:, i] = data[:, temp[i + 1]] eu = np.zeros(step_array.size) tr = np.zeros(step_array.size) tr_comp = np.zeros((step_array.size, csize)) time = np.zeros(step_array.size) dtime = np.zeros(step_array.size) for n in range(step_array.size): step = int(step_array[n]) time[n] = time_array[step] * time_scaling if n > 0: dtime = time[n] - time[n - 1] eu[n] = eu[n - 1] + eu_rate[n - 1] * dtime tr[n] = tr[n - 1] + tr_rate[n - 1] * dtime tr_comp[n, :] = tr_comp[n - 1, :] + tr_rate_comp[n - 1, :] * dtime #----plot figures----# case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) o_dir = Mpf.assign_output_dir("%s/melting" % (case_dir)) fig, ax = plt.subplots() #----temperature----# ax = plt.subplot(2, 1, 1) color_type = color_dict['tracer'] plt.plot(time / 1e6, tr_rate, color=color_type, linestyle='--', label='Tracer Method') color_type = color_dict['eular'] plt.plot(time / 1e6, eu_rate, color=color_type, linestyle='--', label='Eular Method') color_type = color_dict['melting'] for i in range(csize): plt.plot(time / 1e6, tr_rate_comp[:, i], color=color_type[i + 1], linestyle='-', label='comp%d' % (i)) ax.set(ylabel='Melting Producting Rate [km^3/yr]') ax = plt.subplot(2, 1, 2) color_type = color_dict['tracer'] plt.plot(time / 1e6, tr, color=color_type, linestyle='--', label='Tracer Method') color_type = color_dict['eular'] plt.plot(time / 1e6, eu, color=color_type, linestyle='--', label='Eular Method') color_type = color_dict['melting'] for i in range(csize): plt.plot(time / 1e6, tr_comp[:, i], color=color_type[i + 1], linestyle='-', label='comp%d' % (i)) ax.legend() ax.set(ylabel='Melting Volume[km^3/yr]') ax.set(xlabel='time [ma]') fig.tight_layout() fig.savefig("%s/mml_melting.eps" % (o_dir))
def remove_extra_file1(route, case_name, in_dict, time_array, step_tuple, step_start, p_file, plogfile): caps = 12 steps_inter = 30 nprocz = readf.get_variable(in_dict, 'nprocz', 'int') nprocx = readf.get_variable(in_dict, 'nprocx', 'int') nprocy = readf.get_variable(in_dict, 'nprocy', 'int') nproc = caps * nprocx * nprocy * nprocz p_dict = readf.read_input(p_file) e_steps = readf.get_variable(p_dict, 'episode_steps', 'int_list') steps_in = readf.get_variable(p_dict, 'steps_remain', 'int_list') length = len(step_tuple) time_at_steps = [time_array[step] for step in step_tuple] step_end = step_tuple[len(step_tuple) - 1] stime = time_array[step_start] ftime = time_array[step_end] plog = open(plogfile, 'a') #----get time of steps that are worth keeping----# time_query = [] for time in np.linspace(stime, ftime, steps_inter): time_query.append(time) #----get steps that are worth keeping----# for time in time_query: n = np.argmin(abs(time_at_steps - time)) step = step_tuple[n] if step not in steps_in: steps_in.append(step) is_see = input('deleting steps: see steps to keep?(y/n)') if is_see: print(steps_in) input() #----delete extra files----# for n in range(len(step_tuple)): step = step_tuple[n] if step < step_start: continue # bash_command = [] # bash_command.append('rm %s/%s.proc0.%d.vts'%(route,case_name,step)) # bash_command.append('rm %s/%s.%d.vtm'%(route,case_name,step)) if step not in steps_in: for proc in range(nproc): filename = '%s/%s.proc%d.%d.vts' % (route, case_name, proc, step) if os.path.isfile(filename): os.remove(filename) if proc % nprocz is nprocz - 1: filename = '%s/%s.surf.%d.%d' % (route, case_name, proc, step) if os.path.isfile(filename): os.remove(filename) filename = '%s/%s.surf_ori.%d.%d' % (route, case_name, proc, step) if os.path.isfile(filename): os.remove(filename) filename = '%s/%s.surf_sph.%d' % (route, case_name, step) if os.path.isfile(filename): os.remove(filename) filename = '%s/%s.%d.vtm' % (route, case_name, step) if os.path.isfile(filename): os.remove(filename) # readf.run_bash(bash_command) plog.write('remove file at step %d\n' % (step)) plog.close() #----write remain steps to p_file----# readf.overwrite_to_file(p_file, 'steps_remain', steps_in, vtype='int', vvtype='array') input()
def surf_plot(in_dict, route, o_dir, case_name, step, **kwargs): def _config(name, default): try: return kwargs[name] except KeyError: return default gmt_dir = _config('gmt_dir', './gmt') rot = _config('rot', None) angle = _config('angle', [0.0, 0.0]) vtype = _config('vtype', 'total') cpt = _config('cpt', None) check_bound = _config('check_bound', False) cc_file = './cc' gravacc = readf.get_variable(in_dict, 'gravacc', 'float') Rho = readf.get_variable(in_dict, 'density', 'float') Ro = readf.get_variable(in_dict, 'radius', 'float') Eta = readf.get_variable(in_dict, 'refvisc', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') if vtype is 'total': deg = -1 case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) surf_dir = Mpf.assign_output_dir("%s/surf" % (case_dir)) file0 = '%s/%s.surf0.%d' % (cc_file, case_name, step) if rot is None: ofile = '%s/topo_%d_%d.ps' % (surf_dir, step, deg) file1 = '%s/%s_%d_surf_combine' % (cc_file, case_name, step) else: ofile = '%s/topo_%d_%drt%d_%d_%d_%d.ps' % (surf_dir, step, deg, rot[0], rot[1], angle[0], angle[1]) file1 = '%s/%s_%d_surf_combine_rt%d_%d_%d_%d' % ( cc_file, case_name, step, rot[0], rot[1], angle[0], angle[1]) scl_ang = 180.0 / np.pi if deg is -1: col = 2 else: col = deg + 2 scl_topo = Eta * Kappa / Ro**2.0 / (Rho * gravacc) topo_minor = 200 sminor = 500 smini = 100 #----combine surf output----# if not os.path.isfile(file1): readf.write_surf_runfile(in_dict, route, case_name, step, vtype='total') bashcommand = [] bashcommand.append('%s/images.x %s/runfile' % (cc_file, cc_file)) if rot is not None: bashcommand.append( './lib/eula_polar %s %s %s %s %s %s' % (file0, file1, rot[0], rot[1], angle[0], angle[1])) readf.run_bash(bashcommand) if rot is None: os.rename(file0, file1) #----read head value---# with open(file1) as fin: sdata = fin.readline().split() data = [] for s in sdata: data.append(float(s) * scl_topo) try: bound = kwargs['bound'] #enlist bound in kwargs to creat a liste topomm = [bound[0], bound[1]] #that stands for boundary value for off_topo = bound[2] #dynamic topography except KeyError: #else take from input idat = input('(min,max,offset),reference:(%.4e %.4e %.4e)\n' % (data[0], data[1], data[2])) idat = idat.split(',') topomm = [] topomm.append(float(idat[0])) topomm.append(float(idat[1])) off_topo = float(idat[2]) if data[0] < topomm[0] or data[1] > topomm[1]: print( "at step %s, default value for bound is (%.4e %.4e), given is %.4e %.4e" % (step, data[0], data[1], topomm[0], topomm[1])) if check_bound: return data try: minor = kwargs['minor'] #enlist minor in kwargs to creat a list that topo_minor = minor[0] #stand for interval in color bar, interval of sminor = minor[1] #scale smini = minor[2] except KeyError: isdo = input('change (topo_minor,sminor,smini) value,default is\ (%.4e %.4e,%.4e),y/n\n' % (topo_minor, sminor, smini)) if isdo is 'y': nval = input('new value:') nval = nval.split(',') topo_minor = float(nval[0]) sminor = float(nval[1]) smini = float(nval[2]) #----plot figure using gmt----# bashcommand = [] bashcommand.append( 'gmt nearneighbor -i1[s%.2f],0[s%.2f][o90],%d[s%.2f][o%.2f] -R0/360/-90/90 -I1/1 -S10 -N1 -G%s/topo.grd -V -h1 %s' % (scl_ang, -scl_ang, col, scl_topo, off_topo, gmt_dir, file1)) if cpt is None: cpt = '%s/color.cpt' % (gmt_dir) bashcommand.append( 'gmt makecpt -Cno_green -T%.2f/%.2f/%.2f > %s/color.cpt' % (topomm[0], topomm[1], topo_minor, gmt_dir)) else: cpt = '%s/%s' % (gmt_dir, cpt) bashcommand.append( 'gmt grdimage %s/topo.grd -R0/360/-90/90 -C%s -JW90/6i -X0.35i -Y6.0i -B120g30/60g30 -K -P > %s' % (gmt_dir, cpt, ofile)) bashcommand.append( 'gmt psscale -D3.5i/-0.5i/15.0c/0.5ch -C%s -P -O -U -V -B:Topography/m:%.2ff%.2fWSne >> %s' % (cpt, sminor, smini, ofile)) bashcommand.append('gmt psconvert -A -Tj %s' % ofile) readf.run_bash(bashcommand)
def chemical(in_dict, time_array, step_tuple, column_dict, route, o_dir, case_name, pp_file): get_end = 1 split = 6 init_lower_percent = 0.01 pi = np.pi tiny = 1e-8 year = 365 * 24 * 3600 case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) o_dir = Mpf.assign_output_dir("%s/chemical" % (case_dir)) if os.path.isfile(pp_file): pp_dict = readf.read_input(pp_file) try: pp_dict['end_time'] except KeyError: get_end = 1 else: get_end = 0 else: get_end = 1 #----read parameters----# cols = column_dict['cols'] nprocz = readf.get_variable(in_dict, 'nprocz', 'int') noz = readf.get_variable(in_dict, 'nodez', 'int') Ro = readf.get_variable(in_dict, 'radius', 'float') interface = readf.get_variable(in_dict, 'z_interface', 'float_list') r_inter = interface[-1] r_o = readf.get_variable(in_dict, 'radius_outer', 'float') r_in = readf.get_variable(in_dict, 'radius_inner', 'float') r_lith = r_o - readf.get_variable(in_dict, 'z_lith', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') r_half = (r_o + r_in) / 2.0 lnoz = int((noz - 1) / nprocz) + 1 time_scaling = pow(Ro, 2.0) / Kappa / (1e6 * year) total_ibc = 4 * pi / 3 * (pow(r_lith, 3.0) - pow(r_lith - 20e3 / Ro, 3.0)) #----prepare chemical data----# chemical = np.zeros((len(step_tuple), 3)) time1 = np.zeros(len(step_tuple)) n = 0 for step in step_tuple: time1[n] = time_array[step] print(step, end='\r') data_in = readf.read_horig_output(route, case_name, step, nprocz, lnoz, cols) rr = data_in[:, column_dict['radius']] C = data_in[:, column_dict['ic']] for i in range(noz - 1): volume = 4.0 / 3.0 * pi * (pow(rr[i + 1], 3.0) - pow(rr[i], 3.0)) if rr[i] > r_inter - tiny and rr[i] < r_lith + tiny: chemical[n, 0] = chemical[n, 0] + (C[i] + C[i + 1]) / 2.0 * volume if rr[i] > r_half - tiny: chemical[n, 1] = chemical[n, 1] + (C[i] + C[i + 1]) / 2.0 * volume if rr[i] < r_half + tiny: chemical[n, 2] = chemical[n, 2] + (C[i] + C[i + 1]) / 2.0 * volume n = n + 1 total_chemical = chemical[0, 1] + chemical[0, 2] chemical_low = chemical[:, 2] #chemical_low is lower chemical percent #print(chemical[0,1]+chemical[0,2]) #print(chemical[:,0]) #debug #print(chemical[:,1]) #print(chemical[:,2]) #----plot figures----# #----figure 1 : retained chemical----# fig, ax = plt.subplots() line1, = ax.plot(time1 * time_scaling, chemical[:, 0] / chemical[0, 0], 'r-') ax.set(xlabel='Time [ma]', ylabel='Chemical Percent[1]', title='Retained Chemicals in Initial Layer') fig.savefig("%s/retained_ibc.eps" % (o_dir)) #plt.show() plt.close(fig) #----figure 2 : overturned chemical----# time2 = time1 * time_scaling fig, ax = plt.subplots() line1, = ax.plot(time2, chemical_low / total_chemical, 'b-') ax.set(xlabel='Time [ma]', ylabel='Chemical Percent[1]', title='Overturned Chemical') fig.savefig("%s/overturned_chemical.eps" % (o_dir)) #plt.show() plt.close(fig) #----figure 3 : overturned ibc volume----# fig, ax = plt.subplots() line1, = ax.plot(time2, chemical_low / total_chemical * total_ibc, 'c-') ax.set(xlabel='Time [ma]', ylabel='IBC Volume[1]', title='Overturned IBC') fig.savefig("%s/overturned_IBC.eps" % (o_dir)) if get_end is 1: temp = input( "input scheme to continue getting end for overturn: 'a(auto)/m(manual):" ) if temp is 'a': cid = fig.canvas.mpl_connect('button_press_event', on_press) plt.show() end_time = get_end_time(Gmc[0], Gmc[1], Gmc[2]) diff_t = abs(time2 - end_time) end_n = np.argmin(diff_t) end_c = chemical_low[end_n] episode_c = np.linspace(0.0, 1.0, split) * end_c episode_c[0] = init_lower_percent * end_c episode_steps = [] for cc in episode_c: diff_c = abs(chemical_low - cc) tempn = np.argmin(diff_c) episode_steps.append(step_tuple[tempn]) end_c_percent = end_c / total_chemical episode_completness = episode_c / end_c fig.canvas.mpl_disconnect(cid) elif temp is 'm': plt.show() temp = input('endstep for episode:') end_step = int(temp) end_time = time_array[end_step] * time_scaling diff_t = abs(time2 - end_time) end_n = np.argmin(diff_t) episode_t = np.linspace(0.0, 1.0, split) * end_time end_c = chemical_low[end_n] end_c_percent = end_c / total_chemical episode_completness = episode_t / end_time episode_steps = [] for tt in episode_t: diff_t = abs(time2 - tt) tempn = np.argmin(diff_t) episode_steps.append(step_tuple[tempn]) readf.write_to_file(pp_file, 'end_time', end_time, 'float') readf.write_to_file(pp_file, 'end_c_percent', end_c_percent, 'float') readf.write_to_file(pp_file, 'episode_completness', episode_completness, 'float', 'array') readf.write_to_file(pp_file, 'episode_steps', episode_steps, 'int', 'array') else: plt.show() plt.close(fig)
def horiz_avg_1(in_dict, time_array, step_tuple, column_dict, route, o_dir, case_name): #plot horizontal_averagye result, no chemical nprocz = readf.get_variable(in_dict, 'nprocz', 'int') noz = readf.get_variable(in_dict, 'nodez', 'int') Ra = readf.get_variable(in_dict, 'rayleigh', 'float') Buoy = readf.get_variable(in_dict, 'buoyancy_ratio', 'float_list') Alpha = readf.get_variable(in_dict, 'thermexp', 'float') Tref = readf.get_variable(in_dict, 'reftemperature', 'float') Tsurf = readf.get_variable(in_dict, 'surftemperature', 'float') Rho = readf.get_variable(in_dict, 'density', 'float') Eta = readf.get_variable(in_dict, 'refvisc', 'float') Ro = readf.get_variable(in_dict, 'radius', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') lnoz = int((noz - 1) / nprocz) + 1 cols = column_dict['cols'] n_c = len(column_dict['chemical']) #----derive scalings----# year = 365 * 24 * 3600 r_scaling = Ro / 1e3 time_scaling = pow(Ro, 2.0) / Kappa / (1e6 * year) velo_scaling = Kappa / Ro * year * 1e2 #---output informations---# case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) temp_dir = Mpf.assign_output_dir("%s/temp" % (case_dir)) velo_dir = Mpf.assign_output_dir("%s/velo" % (case_dir)) visc_dir = Mpf.assign_output_dir("%s/visc" % (case_dir)) for step in step_tuple: print(step, end='\r') data_in = readf.read_horig_output(route, case_name, step, nprocz, lnoz, cols) time = time_array[step] * time_scaling ##----plot figures----# col_r = column_dict['radius'] ydata = data_in[:, col_r] settings = { 'name': 'temp', 'x_unit': '1', 'y_unit': '1', 'o_dir': temp_dir, 'plot_type': 'n', 'color': 'r', 'mark': '.' } col_t = column_dict['temp'] xdata = data_in[:, col_t] Mpf.plot_horiz_avg(xdata, ydata, step, time, settings) settings = { 'name': 'visc', 'x_unit': '1', 'y_unit': '1', 'o_dir': visc_dir, 'plot_type': 'l', 'color': 'b', 'mark': '.' } col_v = column_dict['visc'] xdata = data_in[:, col_v] Mpf.plot_horiz_avg(xdata, ydata, step, time, settings) settings = { 'name': ['velo', 'vr', 'vth'], 'x_unit': 'cm/yr', 'y_unit': '1.0', 'o_dir': velo_dir, 'plot_type': 'n', 'color': ('c', 'g'), 'mark': '.' } xdata = np.zeros((noz, 2)) col_vr = column_dict['vr'] col_vth = column_dict['vth'] xdata[:, 0] = data_in[:, col_vr] xdata[:, 1] = data_in[:, col_vth] Mpf.plot_horiz_avg(xdata, ydata, step, time, settings)
def plot_combine(in_dict, oroute, cname, dfile, tp, cdict, tval, **kwarg): def _config(name, default): try: return kwarg[name] except KeyError: return default dcwd = './gmt' Ro = readf.get_variable(in_dict, 'radius', 'float') Kappa = readf.get_variable(in_dict, 'thermdiff', 'float') ri = readf.get_variable(in_dict, 'radius_inner', 'float') Buoy = readf.get_variable(in_dict, 'buoyancy_ratio', 'float') Alpha = readf.get_variable(in_dict, 'thermexp', 'float') year = 365 * 24 * 3600 Time = Ro**2.0 / Kappa / (1e6 * year) R = Ro / 1e5 Temp = readf.get_variable(in_dict, 'reftemperature', 'float') Toff = readf.get_variable(in_dict, 'surftemperature', 'float') Tab = 273.15 Toff = Toff - Tab Rho = readf.get_variable(in_dict, 'density', 'float') Drho = Buoy * Alpha * Temp * Rho tmin = tval[0] tmax = tval[1] tminor = tval[2] tmini = tval[3] rmin = R * ri rmax = R odir0 = Mpf.assign_output_dir('%s/%s' % (oroute, cname)) odir = Mpf.assign_output_dir('%s/combine' % (odir0)) ofile = '%s/combine_%s_%.0f_%.0f.ps' % (odir, tp, tmin, tmax) if tp is 'rho': Dat = Drho Doff = Rho dmin = Rho dmax = Rho + Drho dminor = _config('rhodminor', 5.0) coff = _config('rhocoff', 50.0) elif tp is 'temp': Dat = Temp Doff = Toff dmin = Toff dmax = Toff + Temp dminor = 50.0 coff = 500.0 t = cdict['time'] r = cdict['radius'] dat = cdict[tp] abash = [] abash.append( 'gmt nearneighbor -i%d[s%.4f],%d[s%.4f],%d[s%.4fo%.4f] -R%.4f/%.4f/%.4f/%.4f -I0.1/0.1 -S30 -N1 -Gresult.grd -V %s' % (t, Time, r, R, dat, Dat, Doff, tmin, tmax, rmin, rmax, dfile)) cpt = _config('cpt', None) if cpt is None: abash.append('gmt makecpt -Cno_green -T%.4f/%.4f/%.4f > color.cpt' % (dmin, dmax, dminor)) cfile = 'color.cpt' else: cfile = cpt abash.append( 'gmt grdimage result.grd -R%.4f/%.4f/%.4f/%.4f -C%s -JX4i/4i -Ba%.4ff%.4f:Time/Ma:/a4.0f2.0:Radius/100km:WSen -K -P > %s' % (tmin, tmax, rmin, rmax, cfile, tminor, tmini, ofile)) abash.append( 'gmt psscale -C%s -D4.4i/2.0i/4.0i/0.2i -P -O -V -B%.4f >> %s' % (cfile, coff, ofile)) abash.append('gmt psconvert -A -Tj %s' % ofile) print(abash) #debug readf.run_bash(abash, dcwd)
PVarray.append('cslice2') PVarray.append('melting') #image types from matlab goes here MLarray.append('temp') MLarray.append('rho') MLarray.append('visc') MLarray.append('velo') include_field = 1 #image that is singular (not base on step) goes here SGarray.append('chemical/overturned_IBC') SGarray.append('chemical/retained_ibc') SGarray.append('heat_flux/cmb_heatflux') SGarray.append('vol/volume_value') #steps of interest steparray.append(0) e_steps = Mread.get_variable(pp_dict, 'episode_steps', 'int_list') for step in e_steps: if step > 0: steparray.append(step) try: rsteps = Mread.get_variable(pp_dict, 'steps_remain', 'int_list') except KeyError: map_to_index = 1 else: map_to_index = 0 steparray.append(rsteps[-1]) picN = 0 fileO = '%s/summury.jpg' % (route) maxStepPv = 100000 # max step for searching exitsting output file from CitcomS #----map step to index of 3d figures----#
plot_MF_surf(Route, CaseName, 7400, oroute) input() #--------------------remove files----------------------------# settings = {'col': 10} settings['column'] = { 'step': 0, 'temp': 1, 'melting': [5, 6, 7, 8, 9] } #first in melting is total melting settings['color'] = {'temp': 'r', 'melting': ['k', 'r', 'b', 'g', 'c']} #settings={'col':6} #settings['column']={'step':0,'temp':1,'melting':[5]} #first in melting is total melting #settings['color']={'temp':'r','melting':['k']} #pp.plot_volume_1(inD,time_array,Route,oroute,CaseName,settings) p_dict = Mread.read_input(ppFile) e_steps = Mread.get_variable(p_dict, 'episode_steps', 'int_list') e_ends = e_steps[len(e_steps) - 1] #try: # steps_remain=Mread.get_variable(p_dict,'steps_remain','int_list') #except KeyError: # pp.remove_extra_file(Route,CaseName,inD,time_array,Steps,ppFile,plogfile) #else: # steps_remain_end = steps_remain[len(steps_remain)-1] # if steps_remain_end != Steps[len(Steps)-1]: # pp.remove_extra_file1(Route,CaseName,inD,time_array,Steps,steps_remain_end,ppFile,plogfile) #pp.sph_plot(inD,rr,Route,oroute,CaseName,ppFile,6000,'T') #--------------------------sph file-------------------------# for step in e_steps: #for step in steps_remain: pp.sph_plot(inD, rr, Route, oroute, CaseName, ppFile, step, 'T') #step = steps_remain[-1]
def sph_plot(in_dict, rr, route, o_dir, case_name, pp_file, step, vtype='T'): print('plot sph expansion figures, step %d\n' % step) color_mini = 0.05 r_minor = 4.0 r_mini = 2.0 gmt_dir = Mpf.assign_output_dir("./gmt") file_out = ('%s/%s.field.%d.dat' % (gmt_dir, case_name, step)) case_dir = Mpf.assign_output_dir("%s/%s" % (o_dir, case_name)) field_dir = Mpf.assign_output_dir('%s/field' % (case_dir)) radius = readf.get_variable(in_dict, 'radius', 'float') rin = readf.get_variable(in_dict, 'radius_inner', 'float') nprocz = readf.get_variable(in_dict, 'nprocz', 'int') noz = readf.get_variable(in_dict, 'nodez', 'int') ll_max = readf.get_variable(in_dict, 'output_ll_max', 'int') ofile = '%s/%s_field_%s_%d.ps' % (field_dir, case_name, vtype, step) ofile1 = '%s/%s_field_%s_%dl.eps' % (field_dir, case_name, vtype, step) lnoz = int((noz - 1) / nprocz) + 1 nn_max = int((ll_max + 1) * (ll_max + 2) / 2) boundary = np.zeros(noz) boundary[0] = 1 boundary[noz - 1] = 1 #----read in data from .field output----# data = readf.read_field(route, case_name, nprocz, noz, ll_max, step) #----output file for gmt plot----# sph_max = np.zeros(noz) fout = open(file_out, 'w') for nz in range(noz): temp = data[nz, 1:ll_max + 1] ll0 = np.argmax(temp) + 1 if boundary[nz]: sph_max[nz] = 0.0 temp = temp * 0.0 else: sph_max[nz] = temp[ll0 - 1] temp = temp / sph_max[nz] for ll in range(1, ll_max + 1): fout.write('%.4e %d %.4e\n' % (rr[nz], ll, temp[ll - 1])) fout.close() #----plot spectrum output with gmt----# ro = radius / 1e5 ri = radius * rin / 1e5 fig, ax = plt.subplots() plt.plot(sph_max, rr * ro, 'b-') ax.set(xlabel='Amplitude [1.0]', ylabel='Radius [100km]') plt.xlim(0.0, ) plt.ylim(ri, ro) #plt.show() fig.savefig(ofile1) plt.close(fig) bashcommand = [] bashcommand.append( 'gmt nearneighbor -i1,0[s%.1f],2 -R1/%d/%.1f/%.1f -I1.0/0.3 -S1 -N1 -G%s/result.grd -V %s' % (ro, ll_max, ri, ro, gmt_dir, file_out)) bashcommand.append('gmt makecpt -Cno_green -T0/1/%.3f > %s/color.cpt' % (color_mini, gmt_dir)) bashcommand.append( 'gmt grdimage %s/result.grd -R1/%d/%.1f/%.1f/ -C%s/color.cpt -JX6i/3i -X1.0i -Y2.0i -Ba5f1:Degree:/a%.1ff%.1f:Radius/100km:WSen -P -K > %s' % (gmt_dir, ll_max, ri, ro, gmt_dir, r_minor, r_mini, ofile)) bashcommand.append( 'gmt psscale -D3.5i/-0.75i/15.0c/0.5ch -C%s/color.cpt -P -O -U -V -B:Power:0.1f0.1WSne >> %s' % (gmt_dir, ofile)) bashcommand.append('gmt psconvert -A -Tj %s' % ofile) # bashcommand.append('gmt psconvert -A -Tf %s'%ofile) ofile2 = '%s/%s_field_%s_%d.jpg' % (field_dir, case_name, vtype, step) ofile3 = '%s/%s_field_%s_%dl.png' % (field_dir, case_name, vtype, step) bashcommand.append('convert %s -resize x1368 %s' % (ofile1, ofile3)) bashcommand.append('convert %s %s +append %s' % (ofile2, ofile3, ofile2)) #print(bashcommand) #debug #input() readf.run_bash(bashcommand) #os.remove(ofile1) os.remove(ofile3)