def W_accuracy(Mdict, Dt=1, frames=None): """ Compute the error value for adjacent values of Dt Mdict is a dictionnary of Mdata. The key correspond to the couple of parameters (W,Dt) """ # W=16 key = (Dt, W) M = Mdict[key] frames = get_frames(M, frames) n = min(len(frames), 10) Dtlist = range(1, 20) dim = Mdict[key].shape() U = np.zeros(dim[:-1] + (n, len(Dtlist))) Ux = np.zeros(dim[:-1] + (n, len(Dtlist))) Uy = np.zeros(dim[:-1] + (n, len(Dtlist))) for i, Dt in enumerate(Dtlist): key = (Dt, W) Ux[..., i] = np.sqrt(access.get(Mdict[key], 'Ux', frames[0], Dt=n)) Uy[..., i] = np.sqrt(access.get(Mdict[key], 'Uy', frames[0], Dt=n)) U[..., i] = np.sqrt(access.get(Mdict[key], 'E', frames[0], Dt=n)) for i, Dt in enumerate(Dtlist[:-1]): std_moy_Ux, std_Ux = compare(Ux, U, start=i, n=2, b=2) std_moy_Uy, std_Uy = compare(Uy, U, start=i, n=2, b=2) std_moy_U = (std_moy_Ux + std_moy_Ux) / 2 print(std_moy_U) return std_moy_U
def accuracy(var, M, frames=None, **kwargs): frames = get_frames(M, frames) n = min(len(frames), 10) Ux = access.get(M, 'Ux', frames[0], Dt=n) Uy = access.get(M, 'Uy', frames[0], Dt=n) U = np.sqrt(access.get(M, 'E', frames[0], Dt=n)) dim = Ux.shape d = len(dim)
def velocity(M, frame, scale=True, display=True, W=None): """ Test the velocity criterion for each individual vector Ux = access.get(M,'Ux',frame) Uy = access.get(M,'Uy',frame) U = np.asarray([Ux,Uy]) dim = U.shape N = np.prod(dim[1:]) d = len(dim) U = np.transpose(U,tuple(range(1,d))+(0,)) U = np.sqrt(np.sum(np.power(U,2),axis=d-1)) #velocity modulus """ U = np.sqrt(access.get(M, 'E', frame)) N = np.prod(U.shape) if scale: Umin, Umax = bounds(M) else: Umin, Umax = bounds_pix(W) if N == 0: # print(U.shape) N = np.prod(U.shape[:-1]) r = len(np.where(np.logical_and(U > Umin, U < Umax))[0]) * 100. / N if display: print("Percentage of good values (velocity test) : " + str(r) + " %") return r
def pdf(M, field, frame, Dt=10, Dx=1024, label='ko-', fignum=1, a=15., norm=True, sign=1): import turbulence.manager.access as access Up = access.get(M, field, frame, Dt=Dt) limits = [(0, Dx), (0, Dx)] Up = sign * access.get_cut(M, field, limits, frame, Dt=Dt) normfactor = M.Ux.shape[0] * M.Ux.shape[1] figs = distribution(Up, normfactor=normfactor, a=a, label=label, fignum=fignum, norm=norm) return figs
def shear_limit_M(M, W, Dt, type=1, **kwargs): """ Test the shear criterion : dU/W < 0.1 """ values = access.get(M, 'strain', frame) M, field = vgradient.compute(M, 'strain', step=1, filter=False, Dt=1, rescale=False, type=type, compute=False) values = getattr(M, field) # /W dUmin, dUmax = check.shear_limit_M(M, W) xbin, n = graphes.hist(values, normalize=False, num=200, range=(-0.5, 0.5), **kwargs) # xfactor = Dt maxn = max(n) * 1.2 graphes.graph([dUmin, dUmin], [0, maxn], label='r-', **kwargs) graphes.graph([dUmax, dUmax], [0, maxn], label='r-', **kwargs) graphes.legende('', '', '')
def Dt_accuracy(Mdict, W=32, frames=None): """ Compute the error value for adjacent values of Dt Mdict is a dictionnary of Mdata. The key correspond to the couple of parameters (W,Dt) """ key = (1, W) M = Mdict[key] frames = get_frames(M, frames) n = min(len(frames), 10) Dtlist = range(1, 20) dim = Mdict[key].shape() U = np.zeros(dim[:-1] + (n, len(Dtlist))) Ux = np.zeros(dim[:-1] + (n, len(Dtlist))) Uy = np.zeros(dim[:-1] + (n, len(Dtlist))) dU = np.zeros(dim[:-1] + (2, 2, n, len(Dtlist))) dU2 = np.zeros(dim[:-1] + (2, 2, n, len(Dtlist))) for i, Dt in enumerate(Dtlist): key = (Dt, W) Ux[..., i] = access.get(Mdict[key], 'Ux', frames[0], Dt=n) Uy[..., i] = access.get(Mdict[key], 'Uy', frames[0], Dt=n) U[..., i] = np.sqrt(access.get(Mdict[key], 'E', frames[0], Dt=n)) dU[..., i] = access.get(Mdict[key], 'dU', frames[0], Dt=n) dU_norm = np.sqrt(np.sum(np.power(dU[..., i], 2), axis=(2, 3))) dU2[..., i] = np.transpose(np.tile(dU_norm, (2, 2, 1, 1, 1)), (2, 3) + (0, 1, 4)) for i, Dt in enumerate(Dtlist[:-1]): std_moy_Ux, std_Ux = compare(Ux, U, start=i, n=2, b=2) std_moy_Uy, std_Uy = compare(Uy, U, start=i, n=2, b=2) std_moy_U = (std_moy_Ux + std_moy_Ux) / 2 std_moy_dU, std_dU = compare(dU, dU2, start=i, n=2, b=2) print(std_moy_U, std_moy_dU) return std_moy_U
def v_accuracy(M, frames=None, display=True, **kwargs): frames = get_frames(M, frames) n = min(len(frames), 10) Ux = access.get(M, 'Ux', frames[0], Dt=n) Uy = access.get(M, 'Uy', frames[0], Dt=n) U = np.sqrt(access.get(M, 'E', frames[0], Dt=n)) dim = Ux.shape d = len(dim) std_moy_Ux, std_Ux = compare(Ux, U, n=10, b=3) std_moy_Uy, std_Uy = compare(Uy, U, n=10, b=3) std_moy_U = (std_moy_Ux + std_moy_Ux) / 2 if display == True: print('Relative error velocity : ' + str(std_moy_U * 100) + " %") # print('Relative error along y : '+str(std_moy_Uy*100)+ " %") return std_moy_U, std_Ux, std_Uy
def accuracy(M, frames): """ from a serie of adjacent frames compute : the ratio of measurements in the boundaries (Umin, Umax). Compute the noise level on the velocity field by averaging over adjacent frames in time (hypothesis of well resolved dynamics) the ratio of measurements within the shear limit (dUmax) Compute the velocity gradient noise level using the same time-averaging technic """ for frame in frames: Ux = access.get(M, 'Ux', frame)
def chose_axe(M, t, axes, Dt=1): """ Chose N axis of a Mdata set INPUT ----- M : Madata object t : int time index axes : string list Possible values are : 'E', 'Ux', 'Uy', 'strain', 'omega' OUTPUT ----- """ data = tuple([access.get(M, ax, t, Dt=Dt) for ax in axes]) return data
def circulation_2(M, i, fignum=1, display=False): Omega = access.get(M, 'omega', i) x, y = space_axis_vorticity(M) X, Y, data, center, factor = normalize(x, y, Omega[..., 0]) dx = M.x[0, 1] - M.x[0, 0] # print(dx) U, d = vgradient.make_Nvec(M, i) # Z : d+1 dimension np array nx, ny = X.shape R_list = np.arange(1., 15., 0.5) Gamma = [] divergence = [] for b in R_list: # print(b) tau = strain_tensor.strain_tensor_loc(U, center[0], center[1], d=2, b=b) omega, enstrophy = strain_tensor.vorticity(tau, d=2, norm=False) div = strain_tensor.divergence_2d(tau, d=2) G = (omega[0, 0] - div[0, 0]) * np.pi * b**2 * dx**2 Gamma.append(G) divergence.append(div[0, 0] / np.abs(omega[0, 0])) R_list = np.asarray(R_list) * dx if display: graphes.graph(R_list, Gamma, fignum=fignum, label='bo') graphes.legende('r (mm)', 'Circulation (mm^2/s)', '') graphes.graph(R_list, divergence, fignum=fignum + 1, label='ko') graphes.graph(R_list, np.zeros(len(R_list)), fignum=fignum + 1, label='r--') graphes.legende('r (mm)', 'Relative 2d divergence', '') graphes.set_axis(0, 30 * dx, -0.3, 0.3) return R_list, Gamma, center, factor
def gradient(M, frame, W=32, scale=True, display=True): dU = access.get(M, 'dU', frame) N = np.prod(dU.shape) if N == 0: # print(dU.shape) N = np.prod(dU.shape[:-1]) dUmin, dUmax = shear_limit(W) r = len(np.where(np.logical_and(dU > dUmin, dU < dUmax))[0]) * 100. / N dU_opt = shear_optimum(W) dU_moy = np.nanstd(dU) ropt = dU_moy / dU_opt if display: print("Percentage of good values (gradient test) : " + str(r) + " %") print("ratio measured shear / optimal value : " + str(ropt)) # greater than 1 start to be bad return r, ropt
def dv_accuracy(M, frames=None, display=True, **kwargs): frames = get_frames(M, frames) n = min(len(frames), 10) dU = access.get(M, 'dU', frames[0], Dt=n) dim = dU.shape d = len(dim) dU2 = np.sqrt(np.sum(np.power(dU, 2), axis=(d - 3, d - 2))) # dU2 = np.reshape(np.tile(dU2,dim),dim+(n,)) d = len(dU2.shape) # std_moy_U1 = compare(dU[...,0,0,:],n=10,b=3) #need to normalizeby dU2 std_U1 = np.nanmean([ np.nanstd(dU[..., 0, 0, slice(i, i + 3)], axis=d - 1) / np.nanmean(dU2[..., slice(i, i + 3)], axis=d - 1) for i in range(10) ]) # standard deviation along x axis std_U2 = np.nanmean([ np.nanstd(dU[..., 0, 1, slice(i, i + 3)], axis=d - 1) / np.nanmean(dU2[..., slice(i, i + 3)], axis=d - 1) for i in range(10) ]) std_U3 = np.nanmean([ np.nanstd(dU[..., 1, 0, slice(i, i + 3)], axis=d - 1) / np.nanmean(dU2[..., slice(i, i + 3)], axis=d - 1) for i in range(10) ]) std_U4 = np.nanmean([ np.nanstd(dU[..., 1, 1, slice(i, i + 3)], axis=d - 1) / np.nanmean(dU2[..., slice(i, i + 3)], axis=d - 1) for i in range(10) ]) std_moy_dU = np.median((std_U1 + std_U2 + std_U3 + std_U4) / 4) if display == True: print('Relative error velocity gradient : ' + str(std_moy_dU * 100) + " %") return std_moy_dU, std_U1, std_U2, std_U3, std_U4
def Space(M, field, tlist, N=30, Np=10**4, norm_d=1.): dlist = range(N) dx = np.diff(M.x[0, :])[0] indices = {} Corr_d = {} U = access.get(M, field, 0) for d in dlist: indices[d] = corr.d_2pts_rand(U[..., 0], d, Np) for i in tlist: C = np.zeros(len(dlist)) for d in dlist: C[d] = compute(M, i, indices[d], axes=[field, field]) Corr_d[(i, 'd_' + field)] = np.asarray(dlist) * dx / norm_d Corr_d[(i, 'C_' + field)] = C return Corr_d
def pdf_ensemble(Mlist, field, frame, Dt=10, Dx=1024, label='r-', fignum=1, a=10., norm=True, model=False): import turbulence.manager.access as access U_tot = [] for M in Mlist: pdf(M, field, frame, Dt=Dt, Dx=Dx, label='k', fignum=fignum, a=a, norm=False) Up = access.get(M, field, frame, Dt=Dt) # limits = [(0,Dx),(0,Dx)] # Up = access.get_cut(M,field,limits,frame,Dt=Dt) # if Dx is larger than the box size, just keep all the data U_tot = U_tot + np.ndarray.tolist(Up) N = len(Mlist) U_tot = np.asarray(U_tot) x, y, figs = distribution(U_tot, normfactor=N, a=a, label=label, fignum=fignum, norm=norm) if model: n = len(y) b = y[n // 2] Dy = np.log((y[n // 2 + n // 8] + y[n // 2 - n // 8]) / 2. / b) a = - Dy / x[n // 2 + n // 8] ** 2 P = b * np.exp(-a * x ** 2) semilogy(x, P, label='b.-', fignum=fignum) set_axis(min(x), max(x), 1, max(y) * 2) if field == 'omega' or field == 'strain': unit = ' (s^-1)' elif field == 'E': unit = 'mm^2/s^2' else: unit = ' (mm/s)' figs = {} figs.update(legend(field + unit, field + ' PDF', time_label(M, frame))) return figs
def Test_dv(M, frames=None, W=32, display=True, scale=True, type=1, **kwargs): frames = get_frames(M, frames) r = 0. ropt = 0. dU = access.get(M, 'dU', frames[0], Dt=len(frames), compute=False, rescale=False, type=type) for frame in frames: r0, ropt0 = gradient(M, frame, display=False, W=W, scale=scale) r += r0 ropt += ropt0 R = r / len(frames) Ropt = ropt / len(frames) if display: import turbulence.display.graphes as graphes dUmin, dUmax = shear_limit(W) xbin, n = graphes.hist(dU, normalize=False, num=200, range=(-0.5, 0.5), **kwargs) # xfactor = Dt maxn = max(n) * 1.2 graphes.graph([dUmin, dUmin], [0, maxn], label='r-', **kwargs) graphes.graph([dUmax, dUmax], [0, maxn], label='r-', **kwargs) graphes.legende('', '', '') print("Percentage of good values (gradient test) : " + str(R) + " %") print("ratio measured shear / optimal value : " + str(Ropt)) # greater than 1 start to be bad return R
def smoothing(M, i, field='omega', sigma=1.): Z = access.get(M, field, i) return filters.gaussian_filter(Z, sigma=sigma)[..., 0]
def Mplot(M, field, frame, auto_axis=False, step=1, W=None, Dt=None, fignum=1, show=False, vmin=0, vmax=0, log=False, display=False, tstamp=False, compute=False, cbar=False, colorbar=False): """ Parameters ---------- M : field : frame : auto_axis : step : W : Dt : fignum : show : vmin : vmax : log : display : tstamp : compute : cbar : colorbar : Returns ------- """ import turbulence.pprocess.check_piv as check import turbulence.manager.access as access data = access.get(M, field, frame, step=1, compute=compute) dimensions = data.shape if field == 'strain': # tensor variable. chose the trace (2d divergence !): data = data[..., 1, 1, :] + data[..., 0, 0, :] # print(data) X, Y = get_axis_coord(M) jmin = 0 data = data[:, jmin:] X = X[:, jmin:] Y = Y[:, jmin:] t = M.t[frame] ft = M.t[frame + 1] - M.t[frame] dx = np.mean(np.diff(M.x[0, :])) if dx == 0: dx = 1 if vmin == 0 and vmax == 0: if auto_axis: std = np.sqrt(np.nanmedian(np.power(data, 2))) vmax = 10 * std vmin = -vmax if field in ['E', 'enstrophy']: vmin = 0 else: if W is None: vmin, vmax = check.bounds(M, t0=frame) else: vmin, vmax = check.bounds_pix(W) if Dt is not None: data = data / Dt if field in ['Ux', 'Uy']: vmax = np.abs(vmax) vmin = -np.abs(vmax) # *100 if field in ['omega']: data = data vmax = np.abs(vmax) / 5. # *15#/5. vmin = -np.abs(vmax) # *10#*100#vmax if field in ['strain']: data = data vmax = np.abs(vmax) / 20. # *15#/5. vmin = -np.abs(vmax) # *10#*100#vmax if field in ['E']: # std = np.std(data[...,frame]) vmax = vmax ** 2 vmin = vmin ** 2 if field in ['enstrophy']: vmax = (vmax / 5.) ** 2 vmin = (vmin) ** 2 if log: vmax = np.log10(vmax) if vmin > 0: vmin = np.log10(vmin) else: vmin = vmax / 100. n = (X.shape[0] - dimensions[0]) / 2 if n != 0: X = X[n:-n, n:-n] Y = Y[n:-n, n:-n] color_plot(X, Y, data[..., 0], show=show, fignum=fignum, vmin=vmin, vmax=vmax, log10=False, cbar=cbar) # time_stamp(M,frame) if colorbar == True: plt.colorbar() # plt.axis('equal') if tstamp: t = M.t[frame] Dt = M.t[frame + 1] - M.t[frame] s = ', t = ' + str(np.round(t * 1000) / 1000) + ' s, Dt = ' + str(np.round(Dt * 10000) / 10) + 'ms' else: s = '' figs = {} figs.update(legend('X (mm)', 'Y (mm)', field + s, display=display, cplot=True, show=show)) return figs