def make_2dmovie(M, name, Range=None, fignum=1, local=True, log=False, vmin=0, vmax=1, filt=False): """ Movie of the colormap of the velocity modulus U over time INPUT ----- M : Mdata class instance, or any other object that contains the following fields : methods : shape() attributes : Ux, Uy Sdata object Ids object ... name : name of the field to be plotted. example : Ux,Uy, vorticity, strain Range : np array fignum : int. default value is 1 Dirname : string Directory to save the figures log : bool. default value is True OUTPUT ----- None """ if Range is not None: start, stop, step = tuple(Range) else: start, stop, step = tuple([0, M.shape()[-1], 5]) # U=np.sqrt(S.Ux**2+S.Uy**2) # by default, pictures are save here : if local: Dirlocal = '/Users/stephane/Documents/Experiences_local/Accelerated_grid' else: Dirlocal = os.path.dirname(M.Sdata.fileCine) Dirname = name if filt: Dirname = Dirname + '_filtered' Dir = Dirlocal + '/PIV_data/' + M.Id.get_id() + '/' + Dirname + '/' print(Dir) fig = graphes.set_fig(fignum) graphes.set_fig(0) # clear current figure print('Compute ' + name) M, field = vgradient.compute(M, name, filter=filt) for i in range(start, stop, step): # Z = energy(M,i) graphes.Mplot(M, field, i, fignum=fignum, vmin=vmin, vmax=vmax, log=log, auto_axis=True) # graphes.color_plot(Xp,Yp,-Z,fignum=fignum,vmax=700,vmin=0) if i == start: cbar = graphes.colorbar() # fignum=fignum,label=name+'(mm^2 s^{-2})') else: print('update') # cbar.update_normal(fig) filename = Dir + 'V' + str(i) graphes.save_fig(fignum, filename, frmt='png')
def make_movie(M, Range=None, field=['E', 'vorticity'], Dirbase=None, Dt=1): if Dirbase == None: Dirbase = '/Users/stephane/Documents/Experiences_local/Accelerated_grid/PIV_data' # local saving nx, ny, nt = M.shape() axes = panel(M) if Range is not None: start, stop, step = tuple(Range) else: start, stop, step = tuple([0, nt, 1]) frames = range(start, stop, step) # field = ['Ux','Uy'] # field = ['E','vorticity'] figs = {} Dirname = Dirbase + '/' + M.Id.get_id() + '/' + graphes.remove_special_chars(str(field)) + '/' print(Dirname) for i, f in enumerate(field): if not hasattr(M, f): M, field_n[i] = vgradient.compute(M, field[i], Dt=Dt) field = field_n # M,field[1] = vgradient.compute(M,field[1],Dt=Dt) if Dt > 1: print('Smoothed data') Dirname = Dirname + 'Smooth_Dt_' + str(int(Dt)) + '/' for i in frames: graphes.set_fig(1) for axe in axes: plt.sca(axe) plt.cla() axes = panel(M, fignum=1) plt.sca(axes[1]) print(i) graphes.Mplot(M, field[0], i, fignum=1, log=True) plt.text(-10, 80, field[0], fontsize=20) plt.sca(axes[2]) graphes.Mplot(M, field[1], i, fignum=1, log=True) plt.text(-10, 80, field[1], fontsize=20) figs.update(graphes.legende('', '', 'Front view', cplot=True)) graphes.save_figs(figs, savedir=Dirname, suffix='_' + str(i), dpi=100, frmt='png', display=False) return axes
def spatial_decay(M, field='E', indices=None): from mpl_toolkits.axes_grid.inset_locator import inset_axes import stephane.vortex.track as track fields, names, vmin, vmax, labels, units = std_fields() j = fields.index(field) Z = np.nanmean(getattr(M, field)[..., indices], axis=2) X, Y = [], [] for i in indices: tup = track.positions(M, i, field=field, indices=indices, step=1, sigma=10.) X.append(tup[1]) Y.append(tup[3]) X0, Y0 = np.nanmean(X), np.nanmean(Y) R, Theta = Smath.cart2pol(M.x - X0, M.y - Y0) R0 = M.param.Diameter Z_flat = np.ndarray.flatten(Z) R_flat = np.ndarray.flatten(R) Theta_flat = np.ndarray.flatten(Theta) phi = np.pi / 2 C = np.mod((Theta_flat + phi + np.pi) / 2 / np.pi, 1) cmap = matplotlib.cm.hot color = [matplotlib.colors.rgb2hex(cmap(c)[:3]) for c in C] fig, ax2 = graphes.set_fig(1, subplot=122) fig.set_size_inches(20, 6) ax2.scatter(R_flat, Z_flat, marker='o', facecolor=color, alpha=0.3, lw=0, cmap=cmap) Rth = np.arange(10 ** 1, 10 ** 2, 1.) # graphes.graphloglog(Rth, 10 ** 5 * (Rth / R0) ** -3.2, label='k--') # graphes.graphloglog(Rth, 5 * 10 ** 4 * (Rth / R0) ** -4.5, label='k--') graphes.set_axis(10 ** 0, 10 ** 2, 10 ** 2, 8 * 10 ** 4) figs = graphes.legende('$R$ (mm)', 'Energy (mm$^2$/s$^{2}$)', 'Spatial decay') fig, ax1 = graphes.set_fig(1, subplot=121) graphes.color_plot(M.x, M.y, Z, fignum=1, vmin=0, vmax=40000, subplot=121) graphes.colorbar(label=names[j] + ' (' + units[j] + ')') figs.update(graphes.legende('X (mm)', 'Y (mm)', 'Time averaged ' + field, cplot=True)) inset_ax = inset_axes(ax2, height="50%", width="50%", loc=3) inset_ax.pcolormesh(M.x / 10 - 10, M.y / 10 - 10, Theta, cmap=cmap) inset_ax.axis('off') return figs
def draw_fieldofview(S, ax, fignum=None, color='r', view='side'): """ Draw the field view of the camera, currently side view only. """ if fignum is not None: graphes.set_fig(fignum) # print(S.fileCine) u0, L = field_of_view(S) if view == 'side': graphic_run(ax, u0[1], u0[2], L[1], L[2], color=color) if view == 'front': graphic_run(ax, u0[0], u0[2], L[1], L[2], color=color) graphic_run(ax, u0[0] + L[0], u0[2], L[1], L[2], color=color) graphic_run(ax, u0[0], u0[2], L[0], L[1], color=color) graphic_run(ax, u0[0], u0[2] + L[2], L[0], L[1], color=color) if view == 'bottom': pass
def example(M, Range=None, field=['E', 'vorticity']): nx, ny, nt = M.shape() axes = panel(M) if Range is not None: start, stop, step = tuple(Range) else: start, stop, step = tuple([0, nt, 1]) frames = range(start, stop, step) # field = ['Ux','Uy'] # field = ['E','vorticity'] figs = {} Dirbase = '/Users/stephane/Documents/Experiences_local/Accelerated_grid/PIV_data' # local saving Dirname = Dirbase + '/' + M.Id.get_id() + '/' + graphes.remove_special_chars(str(field)) + '/' print(Dirname) M, field[0] = vgradient.compute(M, field[0]) M, field[1] = vgradient.compute(M, field[1]) for i in frames: graphes.set_fig(1) for axe in axes: plt.sca(axe) plt.cla() axes = panel(M, fignum=1) plt.sca(axes[1]) graphes.Mplot(M, field[0], i, log=True) plt.text(-10, 20, field[0], fontsize=20) plt.sca(axes[2]) graphes.Mplot(M, field[1], i, fignum=1, log=True) plt.text(-10, 20, field[1], fontsize=20) figs.update(graphes.legende('', '', 'Front view', cplot=True)) graphes.save_figs(figs, savedir=Dirname, suffix='_' + str(i), dpi=100, frmt='png') return axes
def plot(p, tmin, tmax, label='', c=True, fignum=0): """ Plot the position of the vortex as a function time. pos is a dictionnary obtained from track.position tmin : minimum index tmax : maximum index """ figs = {} keys = ['Xmax', 'Xmin', 'Ymin', 'Ymax'] subplot = {'Xmax': 121, 'Xmin': 121, 'Ymax': 122, 'Ymin': 122} fig1 = graphes.set_fig(fignum + 1) fig1.set_size_inches(10, 4) accurate = {key: None for key in keys} for key in keys: # print(p[key][tmin:tmax]) if c: p[key][tmin:tmax], accurate[key] = correct(p[key][tmin:tmax], a=5.) else: accurate[key] = True if 'Y' in key: # print('invert !') if np.nanmean(p[key]) < 0: p[key] = -np.asarray(p[key]) # X axis is inverted ! if accurate[key]: graphes.set_fig(fignum + 1, subplot[key]) graphes.graph(p['t'], p[key], fignum=fignum + 1, label=label) figs.update( graphes.legende('Time (s)', key[0] + ' position (mm)', '')) if 'Y' in key: graphes.set_axis(0.05, p['t'][tmax], 0, 100) else: graphes.set_axis(0.05, p['t'][tmax], -50, 50) p['d'] = np.sqrt((np.asarray(p['Xmin']) - np.asarray(p['Xmax']))**2 + (np.asarray(p['Ymin']) - np.asarray(p['Ymax']))**2) graphes.graph(p['t'], p['d'][tmin:tmax], fignum=fignum + 2, label=label) graphes.set_axis(0, p['t'][tmax], 0, 50) figs.update(graphes.legende('Time (s)', 'Distance (mm)', '')) if accurate['Xmin'] and accurate['Ymin']: graphes.graph(p['Ymin'][tmin:tmax], p['Xmin'][tmin:tmax], fignum=fignum + 3, label=label) figs.update(graphes.legende('X position (mm)', 'Y position (mm)', '')) graphes.set_axis(0, 60, -50, 50) if accurate['Xmax'] and accurate['Ymax']: graphes.graph(p['Ymax'][tmin:tmax], p['Xmax'][tmin:tmax], fignum=fignum + 3, label=label) graphes.graph(p['t'], p['Gammamax'], fignum=fignum + 4, label=label) figs.update(graphes.legende('Time (s)', 'Circulation (mm^2/s)', '')) graphes.set_axis(p['t'][tmin], p['t'][tmax], 0, 5 * 10**4) return figs, accurate
def fit_core_size(x, y, Z, fignum=1, display=False): """ Find the half width of a gaussian bump INPUT ----- x : 2d np array spatial coordinates (columns) y : 2d np array spatial coordinates (lines) Z : 2d np array data to be fitted (typically vorticity field ) fignum : int figure number for the output. Default 1 display : bool OUTPUT ----- a : float parameter of the gaussian bump center : 2 elements np array center coordinates """ ny, nx = Z.shape X, Y, data, center, factor = normalize(x, y, Z) R, theta = Smath.cart2pol(X, Y) a0 = 1 fun = gaussian res = opt.minimize(distance_fit, a0, args=(fun, R, data)) cond = ((center[0] > 5) and (center[0] < nx - 5) and (center[1] > 5) and (center[1] < ny - 5)) if cond: a = np.sqrt(res.x) else: a = None if display: figs = {} graphes.graph(R, factor * data, fignum=3, label='ko') graphes.graph(R, factor * gaussian(res.x, R), label='r.', fignum=fignum + 2) graphes.set_axis(0, 20, 0, factor * 1.1) figs.update(graphes.legende('r (mm)', 'Vorticity s^{-1})', '')) fig = graphes.set_fig(fignum + 3) graphes.plt.clf() fig, ax, c = graphes.color_plot(X, Y, factor * data, fignum=fignum + 3) fig.colorbar(c) # graphes.colorbar() figs.update( graphes.legende('X (mm)', 'Y (mm)', 'Vorticity', display=False, cplot=True)) return a, center, figs else: return a, center
def compute_Ct(M, tlist=None, t0=20, axes=['Ux', 'Ux'], p=1, display=False, label='ko', fignum=1): """ Parameters ---------- M : tlist : t0 : int frame number to start correlation function if tlist is None axes : p : display : label : fignum : Returns ------- tf : float array of dim len(tlist) x 1 or, if tlist==None, len(range(t0, dimensions[2] - t0, Dt)) x 1 the times probed for auto correlation tau : float array of dim len(tlist) x 1 or, if tlist==None, len(range(t0, dimensions[2] - t0, Dt)) x 1 the correlation timescales evaluated at each time tf """ display_part = False if tlist is None: Dt = 50 dimensions = M.shape() tlist = range(t0, dimensions[2] - t0, Dt) tau = np.zeros(len(tlist)) tf = np.zeros(len(tlist)) for i, t in enumerate(tlist): X, Y, Yerr = stat_corr_t(M, t, axes=axes, p=1, display=False) try: popt, pcurv = scipy.optimize.curve_fit(fitting.exp, np.abs(X), Y) except ValueError: print("NaN values encountered, fit skipped") X, Y, Yerr = stat_corr_t(M, t, axe='E', p=1, display=True) # input() pcurv = [] popt = [1] except RuntimeError: print( "Fitting did not converge, arbitrarly chosen to previous value" ) pcurv = [] if i == 0: popt = [1] else: popt = [tau[i - 1]] tf[i] = M.t[t] tau[i] = -1 / popt[0] # print(str(M.t[t]) + ' : ' +str(tau[i])) if display_part: texp = np.abs(X) graphes.set_fig(1) graphes.errorbar(texp, Y, texp * 0, Yerr, fignum=0, label='ko') graphes.graph(texp, np.exp(texp, -1 / tau[i]), fignum=1, label='r') graphes.legende('$t/u^{2m}$', '$C_t$', '$m=1/2$') if display: graphes.graphloglog(tf, tau, fignum=fignum, label=label) graphes.legende('t (s)', 't_c', graphes.title(M)) return tf, tau
def spatial_correlation(M, compute=True, rootdir='Corr_functions', label='k^', fignum=1, display=True, save=False): """Compute the spatial correlation function or display the correlation length as a function of time save the correlations function in txt files Fit using turbulence.tools.fitting.exp function Parameters ----- M : Mdata object compute : bool default value : True if True, the correlations functions are computed, and save in txt files if False, load the previously computed correlations functions and display the correlation length as a function of timme rootdir : string subdirectory name for saving the corr functions. Base directory correspond to the location of the associated dataset. save : bool Whether to save the autocorrelation functions to disk Returns ------- Corr_functions : list of numpy float arrays (size?) [Cxx, Cyy, Cxy, CEE] """ if compute: # chose randomly the pair of indices that will be used for computing the spatial correlation function dlist = range(int(max(M.shape()) / 2)) indices = {} N = 10**3 for i, d in enumerate(dlist): indices[i] = d_2pts_rand(M.Ux[:, :, 0], d, N) print('Pair of indices computed') (ny, nx, nt) = M.shape() # tref, d, Cxx, Cyy, Cxy, CEE = correlation_functions(M,dlist,indices,Dt=Dt) # print('Correlation functions computed') step = 100 Dt = 20 tref, d, Cxx, Cyy, Cxy, CEE = display_corr_vs_t(M, dlist, indices, step=step, Dt=Dt, label='-', display=True) # How to save matrices in a single txt file ? # filename = os.path.dirname(M.filename) + '/Corr_functions/' + name + '.txt' axes = ['xx', 'yy', 'xy', 'CEE'] keys = ['d', 't'] + ['Corr_' + p for p in axes] Corr_functions = [Cxx, Cyy, Cxy, CEE] List_info = [d, tref] + Corr_functions if save: name = 'Corr_spatial_' + M.Id.get_id() filename = os.path.dirname( M.filename) + '/Corr_functions/' + name + '.txt' print(filename) rw_data.write_matrix(filename, keys, List_info) # for C in [Cxx,Cyy,Cxy,CEE]: # rw_data.write_matrix(tref,D,C) print('Correlation functions saved in ' + filename) return Corr_functions else: # try first to load the data rfrom the Corr_functions directory Dir = os.path.dirname(M.filename) + '/' + rootdir filename = Dir + '/Corr_spatial_' + M.Id.get_id( ) + '.txt' # print(filename) Header, Data, axes = rw_data.read_matrix(filename, Hdelimiter='\t', Ddelimiter='\t') print(Data.keys()) nd = axes['d'] nt = axes['t'] print((nd, nt)) Dt = 20 for key in Data.keys(): Data[key] = np.reshape(np.asarray(Data[key]), (nd, nt)) # Data[key]=cdata.smooth(Data[key],Dt) dimensions = M.shape() tlist = range(Dt, dimensions[2] - 3 * Dt, 1) lc = np.zeros(len(tlist)) tf = np.zeros(len(tlist)) display_part = True for i, t in enumerate(tlist): d = Data['d'][:, i] key = 'Corr_xx' Cd = Data[key][:, i] / Data[key][0, i] popt = fitting.fit(fitting.exp, d[0:10], Cd[0:10]) tf[i] = M.t[t] lc[i] = -1 / popt[0] # print(str(M.t[t]) + ' : ' +str(lc[i])) if display_part: if i % 100 == 0: graphes.set_fig(1) graphes.graph(d, Cd, fignum=0, label='ko') graphes.graph(d, np.exp(d, -1 / lc[i]), label='r') # graphes.graph(d,parabola(d,-1/lc[i])+1,label='r') graphes.legende('$d (mm)$', '$C_d$', '') graphes.set_axes(0, 3, -1, 1.1) # input() cdata.rm_nans([lc], d=2) if display: graphes.graphloglog(tf, lc, fignum=fignum, label=label) graphes.legende('$t (s)$', '$d (mm)$', graphes.title(M)) return None
def plot(x, y, U, fignum=1, vectorScale=10 ** 8): """ Plot a 2d velocity fields with color coded vectors Requires fields for the object M : Ux and Uy INPUT ----- M : Mdata set of measure frame : number of the frame to be analyzed fignum (opt) : asking for where the figure should be plotted OUTPUT ------ None """ Ux = U[:, 0] Uy = U[:, 1] colorCodeVectors = False refVector = 1. # vectorScale = 100 vectorColormap = 'jet' # bounds # chose bounds from the histograme of E values ? scalarMinValue = 0 scalarMaxValue = 100 # make the right figure active graphes.set_fig(fignum) # get axis handle ax = plt.gca() ax.set_yticks([]) ax.set_xticks([]) E = np.sqrt(Ux ** 2 + Uy ** 2) Emoy = np.nanmean(E) if colorCodeVectors: Q = ax.quiver(x, y, Ux / Emoy, Uy / Emoy, E, \ scale=vectorScale / refVector, scale_units='width', cmap=plt.get_cmap(vectorColormap), clim=(scalarMinValue, scalarMaxValue), edgecolors=('none'), zorder=4) # elif settings.vectorColorValidation: # v = 1 # #ax.quiver(x[v==0], y[v==0], ux[v==0], uy[v==0], \ # scale=vectorScale/refVector, scale_units='width', color=[0, 1, 0],zorder=4) # Q = ax.quiver(x[v==1], y[v==1], ux[v==1], uy[v==1], \ # scale=vectorScale/refVector, scale_units='width', color='red',zorder=4) else: Q = ax.quiver(x, y, Ux / E, Uy / E, scale=vectorScale / refVector, scale_units='width', zorder=4) # , color=settings.vectorColor graphes.legende('$x$ (mm)', '$y$ (mm)', '') # add reference vector # if settings.showReferenceVector: # plt.quiverkey(Q, 0.05, 1.05, refVector, str(refVector) + ' m/s', color=settings.vectorColor) # overwrite existing colorplot graphes.refresh(False)
graphes.save_figs(figs, savedir=savedir) ######################################################## # Creates a folder with png files of E/omega/enstrophy for each frame ######################################################## graphes.movie(Mlist[0], 'E', Dirname=savedir, vmin=0, vmax=3 * 10**5) graphes.movie(Mlist[0], 'omega', Dirname=savedir, vmin=-300, vmax=300) graphes.movie(Mlist[0], 'enstrophy', Dirname=savedir, vmin=0, vmax=90000) ######################################################## # Energy vs time ######################################################## M = Mlist[0] field = 'E' fig, ax = graphes.set_fig(1, subplot=111) fig.set_size_inches(20, 4) Y_moy = np.nanmean(getattr(M, field), axis=(0, 1)) nx, ny, nt = M.shape() indices = range(nt) graphes.semilogy(M.t[indices], Y_moy[indices], label='ks-', fignum=1) i0 = 28 T = 60 t0 = M.t[range(1, T - 9)] print(M.t[i0]) # for i in range(nt//T-3): # ind = range(i0,i0+T-10) # graphes.graph([M.t[i0]],[Y_moy[i0]],label='rs',fignum=1) figs = graphes.legende('Time (s)', 'Energy (mm$^2$/s$^{2}$)', '') graphes.set_axis(0, 8, 10**1, 10**5) # graphes.graphloglog(t0,Y_moy[ind],label='.-',fignum=2)
def spreading(Mlist, logscale=False): labels = ['k^', 'ro', 'bs'] M = Mlist[0] nx, ny, nt = M.shape() # for i,M in enumerate(Mlist): # vertical_spreading(M,10,Dt=20,label=labels[i]) print(M.shape()) frame = range(10, 350, 10) Dt = np.asarray( [M.t[frame[i]] - M.t[frame[i - 1]] for i in range(1, len(frame))]) # print(Dt) # Ux_adv = np.zeros(nx) # Uy_adv = np.zeros(ny) D = 5 * 10**2 z_init, U_init = initial_shape(offset=140) t_init = 0.026 for i, t0 in enumerate(frame[:-1]): z, Ux_moy, Uy_moy, Ux_rms, Uy_rms = profile_average(Mlist, t0, Dt=10, display=False) print(M.t[t0]) z_dif, U_dif = solve_diffusion(-z_init, U_init, D, M.t[t0] - t_init) # print(U_dif) if i == 0: fx = interp.splrep(z, Ux_rms, s=2) # kind='cubic') fy = interp.splrep(z, Uy_rms, s=2) # interp1d(z, Ux_rms, kind='cubic') Ux_adv = interp.splev(z, fx) Uy_adv = interp.splev(z, fy) figs = display_profile(Mlist[0], i, t0, z, Ux_moy, Uy_moy, Ux_rms, Uy_rms, Dt=Dt[i], fig=i, logscale=logscale) # Ux_adv,Uy_adv = advection(Dt[i],i,z,Ux_moy,Uy_moy,Ux_adv,Uy_adv,display=True) graphes.semilogx(U_dif, z_dif, fignum=i, label='r-') graphes.set_axis(10**0, 10**4, -300, -120) graphes.save_figs(figs, savedir='./Spreading/Diffusion_noNoise/', suffix='', prefix='2015_12_28_front_' + str(t0), frmt='png') figs = {} graphes.set_fig(1) figs.update(graphes.legende('$t$ (s)', '$Front position z$ (mm)', '')) graphes.set_fig(2) figs.update(graphes.legende('$t$ (s)', '$Front position z (log)$ (mm)', '')) graphes.set_fig(3) figs.update(graphes.legende('$t$ (s)', '$U_{rms}$ (mm/s)', '')) graphes.save_figs(figs, savedir='./Spreading/', suffix='', prefix='2015_12_28_all_')
def vertical_spreading(M, N, Dt=10, label='k^'): """ Compute the vertical profile of RMS velocity as a function of time INPUT ----- OUTPUT ----- figs : dict key correspond to figure index, value to their standarzied filename """ n = 160 ti = 50 figs = {} z0 = -M.param.stroke # !!! z_1 = np.zeros(n) z_2 = np.zeros(n) t = np.zeros(n) E = np.zeros(n) indices = [(i + 1) * N + ti for i in range(n)] for i, t0 in enumerate(indices): z_1[i], z_2[i], E[i], std_E = velocity_profile(M, i, t0, Dt=Dt, display=True) t[i] = M.t[t0] # average on horizontal line (if rotated, correspond to vertical line) # compute the vertical RMS velocity profile fig = 1 graphes.set_fig(fig) graphes.graph(t, z_1 - z0, fignum=fig, label=label) graphes.graph(t, z_2 - z0, fignum=fig, label=label) figs.update(graphes.legende('$t$ (s)', '$Front position z$ (mm)', '')) fig = 2 graphes.set_fig(fig) graphes.graphloglog(t, np.abs(z0 - z_1), fignum=fig, label=label) graphes.graphloglog(t, np.abs(z0 - z_2), fignum=fig, label=label) graphes.graphloglog(t, np.power(t, 0.5) * 10**2, fignum=fig, label='r--') figs.update(graphes.legende('$t$ (s)', '$Front position z (log)$ (mm)', '')) fig = 3 graphes.set_fig(fig) graphes.graphloglog(t, E, fignum=fig, label=label) figs.update(graphes.legende('$t$ (s)', '$U_{rms}$ (mm/s)', '')) t_min = 6 * 10**-2 t_max = 4 * 10**-1 indices = np.where(np.logical_and(t < t_max, t > t_min)) t_part = t[indices] z_part = np.abs(z0 - z_1[indices]) P = np.polyfit(np.log(t_part / t_min), np.log(z_part), 1) C = np.exp(P[1]) nu = C**2 / t_min print(P[0], C) print('Effective diffusion coefficient : ' + str(nu) + ' mm^2/s') graphes.graphloglog(t, C * np.power(t / t_min, P[0]), fignum=2, label='r-') figs.update(graphes.legende('$t$ (s)', '$Front position z (log)$ (mm)', '')) graphes.save_figs(figs, savedir='./Spreading/', suffix='', prefix='2015_12_28_front_both_C') return figs
def make_plot(M, Range=None, color='k', field=['E', 'vorticity'], Dirbase=None, Dt=1, example=False, total=True, fignum=1, save=True): if Dirbase == None: Dirbase = '/Users/stephane/Documents/Experiences_local/Accelerated_grid/PIV_data/Test6/' # local saving Dirbase = './Stat_avg/Panel/' + M.Id.date axes = flex_panel(M, fignum=fignum) # for axe in axes: # plt.sca(axe) # plt.cla() frames = select_range(M, Range) # field = ['Ux','Uy'] # field = ['E','vorticity'] figs = {} if hasattr(M, 'id'): Dirname = Dirbase + '/' + M.Id.get_id() + '/' + graphes.remove_special_chars(str(field)) + '/' else: Dirname = Dirbase + '/JHTD_Data/' + graphes.remove_special_chars(str(field)) + '/' print(Dirname) if Dt > 1: print('Smoothed data') Dirname = Dirname + 'Smooth_Dt_' + str(int(Dt)) + '/' # Dt = 50 t_moy, E_moy = access.avg_vs_t(M, 'E', frames, Dt=Dt) t_moy, Omega_moy = access.avg_vs_t(M, 'omega', frames, Dt=Dt) t_moy, Strain_moy = access.avg_vs_t(M, 'strain', frames, Dt=Dt) t_moy, Y_pdf_moy = access.avg_vs_t(M, field[1], frames, Dt=Dt) epsilon = scale.dissipation_rate(Omega_moy) # dissipation rate eta = scale.K_scale(epsilon) # dissipative scale micro_1 = np.sqrt(1. / 4 * E_moy / Strain_moy ** 2) micro_2 = np.sqrt(E_moy / (Omega_moy) ** 2) Re = scale.Re(micro_1, eta) Re_lambda_1 = scale.Re_lambda(E_moy, micro_1) Re_lambda_2 = scale.Re_lambda(E_moy, micro_2) L = scale.I_scale(Re, E_moy) # plt.sca(axes[2]) # graphes.graphloglog(t_moy,E_moy,fignum=1,label=color+'o-') # Fourier.add_theory(t_moy,E_moy,[-2.],fignum=1) # graphes.graphloglog(t_moy,Y_pdf_moy,fignum=1,label=color+'s-') # graphes.graphloglog(t_moy,epsilon,fignum=1,label='gv-') # Fourier.add_theory(t_moy,epsilon,[-3.],fignum=1) # figs.update(graphes.legende('t (s)','E (mm^2/s^2), epsilon(mm^2/s^-3)','')) plt.sca(axes[1]) graphes.graphloglog(t_moy, eta, fignum=fignum, label=color + 'o-') graphes.graphloglog(t_moy, micro_1, fignum=fignum, label=color + 's-') graphes.graphloglog(t_moy, micro_2, fignum=fignum, label='cp-') graphes.graphloglog(t_moy, L, fignum=fignum, label='gv-') figs.update(graphes.legende('t (s)', 'eta (mm), lambda (mm)', '')) plt.sca(axes[2]) graphes.graphloglog(t_moy, Re, fignum=fignum, label=color + 'o-') graphes.graphloglog(t_moy, Re_lambda_1, fignum=fignum, label=color + 's-') graphes.graphloglog(t_moy, Re_lambda_2, fignum=fignum, label='cp-') figs.update(graphes.legende('t (s)', 'Re , Re_lambda', '')) # print(t_moy) # print(Y_moy) # print(t) # print(Y_moy) indices = [0, 1] # indices = [1,4] cla_axes = [axes[i] for i in indices] if save: graphes.save_figs(figs, savedir=Dirname, prefix='General', suffix='_vs_t', dpi=300, frmt='png', display=True) individual = False if example: frames_disp = [1200] else: step = frames[1] - frames[0] frames_disp = range(frames[0] + step * 10, frames[-1], step * 10) if individual: for frame in frames_disp: # print(frame) # print(frames) i = frames.index(frame) graphes.set_fig(1) for axe in cla_axes: plt.sca(axe) plt.cla() axes = flex_panel(M, fignum=1) if total: plt.sca(axes[0]) graphes.Mplot(M, field[0], frame, fignum=1, log=True) plt.text(-10, 80, field[0], fontsize=20) plt.sca(axes[1]) # graphes.graphloglog(t_moy,eta,fignum=1,label='ko-') # graphes.graphloglog(t_moy,micro,fignum=1,label='ks-') graphes.graph([t_moy[i]], [eta[i]], fignum=1, label='ro') graphes.graph([t_moy[i]], [micro_1[i]], fignum=1, label='rs') graphes.graph([t_moy[i]], [micro_2[i]], fignum=1, label='rp') graphes.graphloglog([t_moy[i]], [L[i]], fignum=1, label='rv-') plt.sca(axes[2]) graphes.graphloglog([t_moy[i]], [Re[i]], fignum=1, label='ro-') graphes.graphloglog([t_moy[i]], [Re_lambda_1[i]], fignum=1, label='rs-') graphes.graphloglog([t_moy[i]], [Re_lambda_2[i]], fignum=1, label='rp-') plt.sca(axes[3]) figs.update(graphes.pdf(M, 'Ux', frame, Dt=Dt, fignum=1, label='m^')) figs.update(graphes.pdf(M, 'Uy', frame, Dt=Dt, fignum=1, label='b>')) figs.update(graphes.legende('t (s)', 'Re , Re_lambda', '')) plt.sca(axes[4]) figs.update(graphes.pdf(M, field[1], frame, Dt=Dt, fignum=1, label=color + '-')) # graphes.Mplot(M,field[1],i,fignum=1,log=True) # plt.text(-10,80,'PDF '+field[1],fontsize=20) # figs.update(graphes.legende('','','Front view',cplot=True)) graphes.save_figs(figs, savedir=Dirname, suffix='_' + str(frame), dpi=100, frmt='png', display=False) return axes
def display_fft_vs_t(m, dimension='1d', Dt=20, fignum=0, label='^', display=False): """ Parameters ---------- m : dimension: Dt: fignum: label: display: Returns ------- t, E_t """ display_part = True # plt.close(1) if dimension == '1d': S_k_2d, kx, ky = energy_spectrum_2d(m, Dt=Dt) S_k, k = energy_spectrum_1d(m, Dt=Dt) if dimension == '2d': S_k, kx, ky = energy_spectrum_2d(m, Dt=Dt) # start=580 # end=700 # step=10 # print(S_k) if dimension == '1d': x = [10 ** 0, 10 ** 1.5] y = [10 ** -0.5, 10 ** -3] # graphes.graph(x,y,-1,'r-') # t0=590 # time_serie=range(t0+10,10000,50)#[round(t0*i**2) for i in np.arange(1,4,0.3)] # origin of time t0 = 0. # .51 tref = np.asarray(m.t) - t0 # tref=1-tref nt = len(tref) # time_serie=[600,900,1200,1600,1900,2900,5000,8000] # time_serie=[i for i in np.arange(400,650,10)] # time_serie=range(10,nt-2) step = 1 time_serie = range(Dt + 1, nt - Dt * 3 - 11, step) # [50,120,200,300,400,450,550] # print(nt-Dt*3-11) # t0=500 # time_serie=[round(i)+t0 for i in np.logspace(1,3.973) if round(i)+t0<nt] # time_serie=range(start,end,50) alpha = np.zeros(len(time_serie)) beta = np.zeros(len(time_serie)) epsilon = np.zeros(len(time_serie)) t_alpha = np.zeros(len(time_serie)) # graphes.hist(k) kmin = -2.7 kmax = -1.7 # print(np.log10(k)) tmax = 300; for i, t in enumerate(time_serie): # print(t) if tref[t] < tmax: if dimension == '1d': k_log = np.log10(k) S_log = np.log10(S_k[:, t]) indices = np.logical_and(k_log > kmin, k_log < kmax) # print(indices) # print(S_log) k_log = k_log[indices] S_log = S_log[indices] P = np.polyfit(k_log, S_log, 1) alpha[i] = 10 ** P[1] # *np.mean(k)**P[0] beta[i] = P[0] C_k = 0.55 epsilon[i] = (alpha[i] / C_k) ** (3 / 2) t_alpha[i] = tref[t] # if t>min(time_serie): # Dt=tref[time_serie.index(t)]-tref[time_serie.index(t-1)] # print(Dt,alpha[time_serie.index(t)]) # print((t_alpha,alpha)) if display_part: graphes.set_fig(1) # graphes.subplot(1,2,1) k0 = np.min(k); display_fft_1d(k, (k / k0) ** (5 / 3) * S_k[:, t] / alpha[i], fignum=1, label='') display_fft_1d(k, (k / k0) * S_k[:, t] / alpha[i], fignum=2, label='') # normalized # print(t_alpha[i]) # display_fft_1d(k,np.abs(S_k[:,t]/t_alpha[i]),fignum=1) # graphes.graphloglog(k[indices],10**np.polyval(P,k_log),label='r--') display_fft(m, t, dimension) # graphes.subplot(1,2,2) # graphes.vfield_plot(m,t,fignum=2) # there is a slighlty degeneracy of the spectrum along both axis. Removes |kx| < epsilon and |ky| < epsilon for every k ? # display_fft_2d(kx,ky,S_k_2d[:,:,t],fignum=3) # display_fft(m,t,dimension) # input() if dimension == '2d': display_fft_2d(kx, ky, S_k[:, :, t]) display_fft(m, t, dimension) if display: # title='$Z$ = '+str(m.Sdata.param.Zplane/10)+' cm' # graphes.legende('$t$ (s)','$E (a.u.)$',title graphes.graphloglog(t_alpha, alpha, label=label, fignum=7) graphes.graphloglog([10 ** -1, 10 ** 3], [10 ** 8, 10 ** 0], label='r--', fignum=7) graphes.legende('$t$ (s)', '$E_{\lambda}$ (a.u.)', graphes.set_title(m)) graphes.semilogx(t_alpha, beta, label=label, fignum=8) # graphes.semilogx(t_alpha,beta,label=label,fignum=0) graphes.semilogx([10 ** -1, 10 ** 3], [-5 / 3, -5 / 3], label='r-', fignum=8) graphes.set_axis(10 ** -1, 10 ** 3, -2.5, 0) graphes.legende('$t$ (s)', 'exponent', graphes.set_title(m)) # plot the dissipative scale as a function of time nu = 1 # in mm^2/s eta = (nu ** 3 / np.asarray(epsilon)) ** (1 / 4) graphes.graphloglog(t_alpha, eta, label=label, fignum=9) graphes.graphloglog([10 ** -1, 10 ** 3], [10 ** 8, 10 ** 0], label='r--', fignum=9) graphes.legende('$t$ (s)', '$\eta$ (mm)', graphes.set_title(m)) E_t = epsilon t = t_alpha return t, E_t
def dispersion(Data, j, savedir): tmin = 20 tmax = 160 accurate = Data['accurate'][j] pos = Data['pos'][j] Mlist = Data['M'][j] A = Data['A'][j] figs = {} graphes for c, key in enumerate(accurate[0].keys()): Y = [] for i, M in enumerate(Mlist): if accurate[i][key]: # c+=1 Y.append(pos[i][key][tmin:tmax]) else: print("not accurate") Y = np.asarray(Y) # print(key) t = np.asarray(pos[i]['t'][tmin:tmax]) graphes.set_fig(1) # graphes.errorbar(t,np.nanmean(Y,axis=0),0*t,np.nanstd(Y,axis=0),label='k',fignum=c+4) # graphes.graph(t,np.nanstd(Y,axis=0),fignum=1,label=label) # graphes.set_axis(0.05,0.45,0,15) # figs.update(graphes.legende('Time (s)',key,'')) # graphes.graph(t**3,np.nanstd(Y,axis=0)**2,fignum=2,label=label) # graphes.graph(t**3,1000*t**3,fignum=2,label='r-') # graphes.set_axis(0.05**3,0.05,0,70) # figs.update(graphes.legende('t^3',key+'^2','')) print(A) if A == 0: label = 'c' else: label = 'k-' if 'X' in key: graphes.graphloglog(t, np.nanstd(Y, axis=0), fignum=3, label=label) graphes.graphloglog(t, 30 * t**1.5, fignum=3, label='r--') # graphes.graphloglog(t,8*t**0.5,fignum=3,label='r--') graphes.set_axis(0.05, 0.6, 0.01, 50) figs.update(graphes.legende('t', key + '', '')) if 'Y' in key: # label='b-' graphes.graphloglog(t, np.nanstd(Y, axis=0), fignum=4, label=label) graphes.graphloglog(t, 30 * t**1.5, fignum=4, label='r--') # graphes.graphloglog(t,8*t**0.5,fignum=4,label='r--') graphes.set_axis(0.05, 0.6, 0.01, 50) figs.update(graphes.legende('t', key + '', '')) # graphes.graphloglog(t**3,1000*t**3,fignum=2,label='r-') # figs.update(graphes.legende('t',key+'','')) # print(c) return figs
def display_profile(M, i, t0, z, Ux_moy, Uy_moy, Ux_rms, Uy_rms, Dt=1, fig=1, logscale=True): t = M.t[t0] U_noise_low, U_noise_high = check.bounds(M, t0) graphes.set_fig(fig) title = 't=' + str(int(t * 1000)) + ' ms' + 'Urms_zprofile' Dir = M.fileDir + 'Velocity_distribution_log_M_2015_12_28_Meanfield' + '/' z, Ux_th = fit_profile(M, t0, z, Ux_rms, p=9, log=True) z, Uy_th = fit_profile(M, t0, z, Uy_rms, p=9, log=True) # Ux_adv,Uy_adv = advection(Dt,z,Ux_moy,Uy_moy,Ux_rms,Uy_rms) # print(Ux_adv/Ux_rms) # print(Ux_adv) figs = {} if logscale: # graphes.semilogx(Ux_rms,z,fignum=0,label='bo--') graphes.semilogx(Uy_rms, z, fignum=i, label='k^--') graphes.semilogx([U_noise_low, U_noise_low], [-400, -100], fignum=i, label='r--') graphes.semilogx([U_noise_high, U_noise_high], [-400, -100], fignum=i, label='r--') # graphes.semilogx(np.sqrt(np.power(Ux_moy,2)),z,fignum=i,label='b+--') # graphes.semilogx(np.sqrt(np.power(Uy_moy,2)),z,fignum=i,label='c ^--') graphes.set_axis(10**0, 10**4, -300, -120) figs.update(graphes.legende('$U_{rms} (t/t_0)$', '$z$ (m)', '')) file = graphes.set_title(M, title) filename = Dir + file else: graphes.graph(Ux_rms, z, fignum=0, label='bo--') graphes.graph(Uy_rms, z, fignum=i, label='k^--') # graphes.semilogx(Ux_th,z,fignum=i,label='r-') # graphes.semilogx(Uy_th,z,fignum=i,label='r-') graphes.graph([U_noise_low, U_noise_low], [-400, -100], fignum=i, label='r--') graphes.graph([U_noise_high, U_noise_high], [-400, -100], fignum=i, label='r--') graphes.graph(np.sqrt(np.power(Ux_moy, 2)), z, fignum=i, label='b+--') graphes.graph(np.sqrt(np.power(Uy_moy, 2)), z, fignum=i, label='c ^--') graphes.set_axis(0, 2.5 * 10**3, -300, -120) figs.update(graphes.legende('$U_{rms} (t/t_0)$', '$z$ (m)', '')) file = graphes.set_title(M, title) filename = Dir + file graphes.save_figs(figs, savedir='./Spreading/Stat_average_lin/', suffix='', prefix='2015_12_28_front_' + str(t0), frmt='png') return figs
def profile_1d(M, Dt=10, direction='v', start=20, fignum=1): """ Compute the 1d averaged profile> Averaging is performed along a Dt window in time, and along the specified axis, either 'v' or 'h' INPUT ----- M : Mdata object. Dt : int. Default 10 time windows width for the averaging direction : string. default 'v'. Only option now start : int starting index fignum : int number for the figure output OUTPUT ----- Ux,Uy,Ux_std,Uy_std """ dimensions = M.shape() if M.param.typeplane == 'vp': if M.param.angle == 0.: z = M.y[:, 0] axis = [1, 0] if M.param.angle == 90.: z = M.x[0, :] axis = [0, 1] else: z = M.y[:, 0] axis = [1, 0] for i in range(start, dimensions[2], Dt): # averaging over Dt in time, and along one dimension in space Ux = np.nanmean(np.nanmean(M.Ux[..., i:i + Dt], axis=2), axis=axis[0]) Uy = np.nanmean(np.nanmean(M.Uy[..., i:i + Dt], axis=2), axis=axis[0]) # standard deviation computation # print(dimensions[axis[1]]) # print(tuple(axis+[Dt])) orientation = tuple([axis[0] + 1, axis[1] + 1] + [0]) Ux_mean = np.asarray( np.transpose([[dict2list.to_1d_list(Ux) for k in range(dimensions[axis[0]])] for t in range(Dt)], orientation)) Uy_mean = np.asarray( np.transpose([[dict2list.to_1d_list(Uy) for k in range(dimensions[axis[0]])] for t in range(Dt)], orientation)) # Uy_mean = np.asarray([[dict2list.to_1d_list(Uy) for k in range(dimensions[axis[0]])] for t in range(Dt)],tuple(axis+[Dt])) std_Ux = np.sqrt(np.mean(np.mean(np.abs(M.Ux[..., i:i + Dt] - Ux_mean) ** 2, axis=2), axis=axis[0])) std_Uy = np.sqrt(np.mean(np.mean(np.abs(M.Uy[..., i:i + Dt] - Uy_mean) ** 2, axis=2), axis=axis[0])) graphes.set_fig(0) # clear current axis graphes.graph(z, Ux, label='k^', fignum=fignum) # ,std_Ux) graphes.graph(z, Uy, label='ro', fignum=fignum) # ,std_Ux) graphes.set_axis(-400, -100, -100, 100) fig = graphes.legende('z (mm)', 'V_{rms} (mm/s)', 'Ux, Uy') filename = './Results/Mean_profile_' + M.id.get_id() + '/' + fig[fignum] + '_t_' + str(i) # print(filename) graphes.save_fig(fignum, filename, frmt='png') # graphes.graph(z,Uy,std_Uy) # graphes.legende('z (m)','V (m/s)','Uy') # raw_input() return Ux, Uy, std_Ux, std_Uy