def get_data(directory): files = build_file_list(0, 1000000, path=directory + '/Shell_Avgs') a = Shell_Avgs(filename=files[-1], path='') nr = a.nr nq = a.nq nmom = 4 niter = a.niter radius = a.radius savg = np.zeros((nr, nmom, nq), dtype='float64') for i in range(niter): savg[:, :, :] += a.vals[:, :, :, i] savg = savg * (1.0 / niter) lut = a.lut thermal = lut[501] return savg[:, 0, thermal], radius
def main(): from rayleigh_diagnostics import build_file_list from mpi4py import MPI import sys ########################### # Initialize Communication comm_world = MPI.COMM_WORLD my_rank = comm_world.rank ncpu = comm_world.size the_qindex = int(sys.argv[1]) the_dpi = int(sys.argv[2]) the_xypix = int(sys.argv[3]) ttext = sys.argv[4] minval = float(sys.argv[5]) maxval = float(sys.argv[6]) ctext = sys.argv[7] if (my_rank == 0): print('') print(' Generating equatorial-slice movie frames.') print('') print(' ///// Parameters //////') print(' DPI: ', the_dpi) print(' XY-PIXELS: ', the_xypix) print(' QUANTITY CODE: ', the_qindex) print(' ') files = build_file_list(0, 1000000, path='Equatorial_Slices') gen_eq_movie(files, my_rank, ncpu, quantity_code=the_qindex, dpi=the_dpi, xypix=the_xypix, minval=minval, maxval=maxval, title_text=ttext, cbar_text=ctext)
def get_data(directory): files = build_file_list(0, 1000000,path=directory+'/G_Avgs') a = G_Avgs(filename=files[0],path='') nfiles = len(files) for i,f in enumerate(files): a = G_Avgs(filename=f,path='') if (i == 0): nq = a.nq niter = a.niter gavgs = np.zeros((niter*nfiles,nq), dtype='float64') iters = np.zeros((niter*nfiles), dtype='int32') time = np.zeros((niter*nfiles), dtype='float64') i0 = i*niter i1 = (i+1)*niter gavgs[i0:i1,:] = a.vals time[i0:i1] = a.time iters[i0:i1] = a.iters lut = a.lut ke = lut[401] return gavgs[:,ke], time
# We demonstrate how to compute the effective pressure force via post-processing in the example below. # In[25]: from rayleigh_diagnostics import Point_Probes, build_file_list import numpy from matplotlib import pyplot as plt #Decide which direction you want to look at (set direction = {radial,theta, or phi}) #This is used to determine the correct quantity codes below radial = 0 theta = 1 phi = 2 direction=radial # Build a list of all files ranging from iteration 0 million to 1 million files = build_file_list(0,1000000,path='Point_Probes') nfiles = len(files)-1 for i in range(nfiles): pp = Point_Probes(files[i],path='') if (i == 0): nphi = pp.nphi ntheta = pp.ntheta nr = pp.nr nq = pp.nq niter = pp.niter vals=numpy.zeros( (nphi,ntheta,nr,nq,niter*nfiles),dtype='float64') time=numpy.zeros(niter*nfiles,dtype='float64') vals[:,:,:,:, i*niter:(i+1)*niter] = pp.vals time[i*niter:(i+1)*niter]=pp.time
# | 1468 |Radial Conductive Heat Flux | # # # In the example that follows, we will plot the spherically-averaged velocity field as a function of radius, the mean temperature profile, and the radial heat flux. We begin with a preamble similar to that used for the Global Averages. Using the help function, we see that the Shell_Avgs data structure is similar to that of the G_Avgs. There are three important differences: # * There is a radius attribute (necessary if we want to plot anything vs. radius) # * The dimensionality of the values array has changed; radial index forms the first dimension. # * The second dimension of the values array has a length of 4. In addition to the spherical mean, the 1st, 2nd and 3rd moments are stored in indices 0,1,2, and 3 respectively. # In[8]: from rayleigh_diagnostics import Shell_Avgs, build_file_list import matplotlib.pyplot as plt import numpy # Build a list of all files ranging from iteration 0 million to 1 million files = build_file_list(0, 1000000, path='Shell_Avgs') a = Shell_Avgs(filename=files[0], path='') # # *** # # While it can be useful to look at instaneous snapshots of Shell Averages, it's often useful to examine these outputs in a time-averaged sense. Let's average of all 200 snapshots in the last file that was output. We could average over data from multiple files, but since the benchmark run achieves a nearly steady state, a single file will do in this case. # In[9]: nfiles = len(files) nr = a.nr nq = a.nq nmom = 4 niter = a.niter
# # # In the example that follows, we demonstrate how to plot azimuthal averages, including how to generate streamlines of mass flux. Note that since the benchmark is Boussinesq, our velocity and mass flux fields are identical. This is not the case when running an anelastic simulation. # # We begin with the usual preamble and also import two helper routines used for displaying azimuthal averages. # # Examining the data structure, we see that the vals array is dimensioned to account for latitudinal variation, and that we have new attributes costheta and sintheta used for referencing locations in the theta direction. # In[13]: from rayleigh_diagnostics import AZ_Avgs, build_file_list, plot_azav, streamfunction import matplotlib.pyplot as plt import pylab import numpy #from azavg_util import * files = build_file_list(30000, 40000, path='AZ_Avgs') az = AZ_Avgs(files[0], path='') # *** # Before creating our plots, let's time-average over the last two files that were output (thus sampling the equilibrated phase). # In[14]: nfiles = len(files) tcount = 0 for i in range(nfiles): az = AZ_Avgs(files[i], path='') if (i == 0): nr = az.nr ntheta = az.ntheta
# In[1]: from rayleigh_diagnostics import G_Avgs, build_file_list import matplotlib.pyplot as plt import numpy # The preamble for each plotting example will look similar to that above. We import the numpy and matplotlib.pyplot modules, aliasing the latter to *plt*. We also import two items from *rayleigh_diagnostics*: a helper function *build_file_list* and the *GlobalAverage* class. # # The *G_Avgs* class is the Python class that corresponds to the full-volume averages stored in the *G_Avgs* subdirectory of each Rayleigh run. # # We will use the build_file_list function in many of the examples that follow. It's useful when processing a time series of data, as opposed to a single snapshot. This function accepts three parameters: a beginning time step, an ending time step, and a subdirectory (path). It returns a list of all files found in that directory that lie within the inclusive range [beginning time step, ending time step]. The file names are prepended with the subdirectory name, as shown below. # In[2]: # Build a list of all files ranging from iteration 0 million to 1 million files = build_file_list(0, 1000000, path='G_Avgs') print(files) # We can create an instance of the G_Avgs class by initializing it with a filename. The optional keyword parameter *path* is used to specify the directory. If *path* is not specified, its value will default to the subdirectory name associated with the datastructure (*G_Avgs* in this instance). # # Each class was programmed with a **docstring** describing the class attributes. Once you created an instance of a rayleigh_diagnostics class, you can view its attributes using the help function as shown below. # In[3]: a = G_Avgs(filename=files[0], path='') # Here, files[0]='G_Avgs/00010000' #a= G_Avgs(filename='00010000') would yield an equivalent result #help(a) # Examining the docstring, we see a few important attributes that are common to the other outputs discussed in this document: # 1. niter -- the number of time steps in the file
def main(): helicity_type = 1 saveplot = True tindex = -1 phi_index = 0 if (helicity_type == 1): # full vr_index = 1 vt_index = 2 vp_index = 3 wr_index = 301 wt_index = 302 wp_index = 303 hr_index = 324 ht_index = 325 hp_index = 326 helicity = 339 print("full helicity check") elif (helicity_type == 2): # u-prime, w-mean vr_index = 4 vt_index = 5 vp_index = 6 wr_index = 307 wt_index = 308 wp_index = 309 hr_index = 336 ht_index = 337 hp_index = 338 helicity = 343 print("prime-mean helicity check") elif (helicity_type == 3): # u-mean, w-prime vr_index = 7 vt_index = 8 vp_index = 9 wr_index = 304 wt_index = 305 wp_index = 306 hr_index = 333 ht_index = 334 hp_index = 335 helicity = 342 print("mean-prime helicity check") elif (helicity_type == 4): # u-mean, w-mean vr_index = 7 vt_index = 8 vp_index = 9 wr_index = 307 wt_index = 308 wp_index = 309 hr_index = 330 ht_index = 331 hp_index = 332 helicity = 341 print("mean-mean helicity check") elif (helicity_type == 5): # u-prime, w-prime vr_index = 4 vt_index = 5 vp_index = 6 wr_index = 304 wt_index = 305 wp_index = 306 hr_index = 327 ht_index = 328 hp_index = 329 helicity = 340 print("prime-prime helicity check") # build file list and get data files = build_file_list(0, 10000000, path="./Meridional_Slices/") F = Meridional_Slices(filename=files[-1], path='') radius = F.radius costh = F.costheta sinth = F.sintheta # extract data vr = F.vals[phi_index, :, :, F.lut[vr_index], tindex] vt = F.vals[phi_index, :, :, F.lut[vt_index], tindex] vp = F.vals[phi_index, :, :, F.lut[vp_index], tindex] wr = F.vals[phi_index, :, :, F.lut[wr_index], tindex] wt = F.vals[phi_index, :, :, F.lut[wt_index], tindex] wp = F.vals[phi_index, :, :, F.lut[wp_index], tindex] hr = F.vals[phi_index, :, :, F.lut[hr_index], tindex] ht = F.vals[phi_index, :, :, F.lut[ht_index], tindex] hp = F.vals[phi_index, :, :, F.lut[hp_index], tindex] hel = F.vals[phi_index, :, :, F.lut[helicity], tindex] # True value hr_T = vr * wr ht_T = vt * wt hp_T = vp * wp hel_T = hr_T + ht_T + hp_T # setup grid fig = plt.figure(1, dpi=100, figsize=(9, 9)) Grid = gridspec.GridSpec(ncols=3, nrows=4) ax = fig.add_subplot(Grid[0, 0]) plot_azav(fig, ax, hr_T, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Radial True") ax = fig.add_subplot(Grid[1, 0]) plot_azav(fig, ax, ht_T, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Theta True") ax = fig.add_subplot(Grid[2, 0]) plot_azav(fig, ax, hp_T, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Phi True") ax = fig.add_subplot(Grid[3, 0]) plot_azav(fig, ax, hel_T, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Total True") ax = fig.add_subplot(Grid[0, 1]) plot_azav(fig, ax, hr, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Radial Diag") ax = fig.add_subplot(Grid[1, 1]) plot_azav(fig, ax, ht, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Theta Diag") ax = fig.add_subplot(Grid[2, 1]) plot_azav(fig, ax, hp, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Phi Diag") ax = fig.add_subplot(Grid[3, 1]) plot_azav(fig, ax, hel, radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Total Diag") ax = fig.add_subplot(Grid[0, 2]) plot_azav(fig, ax, np.abs(hr_T - hr), radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Radial Error") print("Max error, radial", np.amax(np.abs(hr_T - hr))) ax = fig.add_subplot(Grid[1, 2]) plot_azav(fig, ax, np.abs(ht_T - ht), radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Theta Error") print("Max error, theta", np.amax(np.abs(ht_T - ht))) ax = fig.add_subplot(Grid[2, 2]) plot_azav(fig, ax, np.abs(hp_T - hp), radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Phi Error") print("Max error, phi", np.amax(np.abs(hp_T - hp))) ax = fig.add_subplot(Grid[3, 2]) plot_azav(fig, ax, np.abs(hel_T - hel), radius, costh, sinth, mycmap='RdYlBu_r', boundsfactor=4.5, boundstype='rms') ax.set_title("Total Error") print("Max error, total", np.amax(np.abs(hel_T - hel))) fig.tight_layout() if (saveplot): output = "test_helicity_{}.png".format(helicity_type) plt.savefig(output, bbox_inches='tight', dpi=300) else: plt.show()
# | 2 | 0,1,2 | # | 4 | 0,1,2,3,4 | # | 8 | 0,1,2,3,4,5,6,7,8 | # # # In[26]: from rayleigh_diagnostics import SPH_Modes, build_file_list import matplotlib.pyplot as plt import numpy qind = 1 # Radial velocity rind = 0 # First radius stored in file files = build_file_list(0, 1000000, path='SPH_Modes') nfiles = len(files) for i in range(nfiles): spm = SPH_Modes(files[i], path='') if (i == 0): nell = spm.nell nr = spm.nr nq = spm.nq niter = spm.niter lvals = spm.lvals max_ell = numpy.max(lvals) nt = niter * nfiles vr = spm.lut[qind] vals = numpy.zeros((max_ell + 1, nell, nr, nq, nt), dtype='complex64') time = numpy.zeros(nt, dtype='float64') vals[:, :, :, :, i * niter:(i + 1) * niter] = spm.vals
my_rank = comm_world.rank ncpu = comm_world.size this_batch = int(sys.argv[1]) nbatch = int(sys.argv[2]) if (len(sys.argv) > 3): qindex = int(sys.argv[3]) else: qindex = 1 if (len(sys.argv) > 4): hsize = float(sys.argv[4]) else: hsize = 0.005 files = build_file_list(0, 1000000, path='Shell_Slices') nfiles = len(files) dfile = nfiles / nbatch file_mod = nfiles % nbatch fstart = dfile * (this_batch - 1) fend = fstart + dfile #Add any leftovers to the last batch if (this_batch == nbatch): if (file_mod != 0): fend = fend + file_mod files = files[fstart:fend] if (my_rank == 0):
print(records[5] + ": " + str(kappa)) return rmin, rmax, luminosity, cp, nu, kappa, omega # Loop over several subdirectories and extract values from each main_input file. for i in dirlist: os.chdir(rootdir + "/" + i) print() print("Working directory: " + os.getcwd()) # Define variables rmin, rmax, luminosity, cp, nu, kappa, omega = extract_input('main_input') b = ReferenceState(filename='', path='reference') # Change values to get Shell_Avgs at different times files = build_file_list(400000,500000, path='Shell_Avgs') c = Shell_Avgs(filename=files[0], path='') nfiles = len(files) nr = c.nr nq = c.nq nmom = 4 niter = c.niter radius = c.radius savg = np.zeros((nr,nmom,nq),dtype='float64') for i in range(niter): savg[:,:,:] += c.vals[:,:,:,i] savg = savg*(1.0/niter) lut = c.lut