def spatial_corr(data, N=1024, Dt=10, outdir='/Users/npmitchell/Dropbox/Soft_Matter/turbulence/jhtd/'):
"""Compute spatial correlation
Parameters
----------
data
N
Dt
Returns
-------
"""
Cxx = np.zeros((N / 2, Dt))
d = np.arange(N / 2)
figs = {}
for p in range(3):
for k in range(Dt):
key = data.keys()[k]
Z = np.asarray(data[key])
Ex = np.nanmean(np.power(Z[:N / 2, 0, 0, p], 2))
Cxx[:, k] = np.nanmean(
np.asarray([[Z[i, 0, 0, p] * Z[i + j, 0, 0, p] / Ex for i in range(N / 2)] for j in range(N / 2)]),
axis=1)
# print(Cxx[0,:])
C = np.nanmean(Cxx, axis=1)
graphes.graph(d, C, fignum=1)
graphes.set_axis(0, N / 4, -1, 1.5)
figs.update(graphes.legende('d', 'C', ''))
graphes.save_figs(figs, savedir=outdir + 'corr_functions/', suffix='', prefix='', frmt='pdf', dpi=300)
def make_figures(M, indices=None, version=0):
suffix = graphes.set_name(M, param=['freq', 'v'])
savedir = '/Users/stephane/Documents/Experiences_local/Results/Vortex_collision/' + M.Id.date + '/' + M.Id.get_id() + '/'
###### Field examples ##############
subdir = 'Example/'
figs = example(M, i=None)
graphes.save_figs(figs, savedir=savedir + subdir, prefix=suffix)
graphes.plt.close('all')
####### Time average fields #############
subdir = 'Time average/'
figs = time_average(M, indices=indices)
graphes.save_figs(figs, savedir=savedir + subdir, prefix=suffix)
graphes.plt.close('all')
######## Energy vs time ##############
subdir = 'Spatial average/'
figs = spatial_average(M, indices=indices)
graphes.save_figs(figs, savedir=savedir + subdir, prefix=suffix)
graphes.plt.close('all')
######### 2d spectrum, average in time ##############
subdir = 'Spectrum/'
figs = spectrum_2d(M, indices=indices)
graphes.save_figs(figs, savedir=savedir + subdir, prefix=suffix)
graphes.plt.close('all')
######### 1d spectrum, average in time ##############
subdir = 'Spectrum/'
figs = spectrum_1d(M, indices=indices)
graphes.save_figs(figs, savedir=savedir + subdir, prefix=suffix, suffix=str(version))
graphes.plt.close('all')
def comparison(Mlist, indices=None, version=0, save=False):
M = Mlist[0]
# suffix = graphes.set_name(M,param=['freq','v'])
savedir = '/Users/stephane/Documents/Experiences_local/Results/Vortex_collision/' + M.Id.date + '/'
subdir = 'Summary/'
######### Comparison spectrum ##############
for M, ind in zip(Mlist, indices):
figs = spectrum_1d(M, indices=ind, norm_factor=(M.param.v / 100.) ** (2. / 3))
graphes.save_figs(figs, savedir=savedir + subdir, prefix='norm', suffix=str(version))
def make_plot_lin(Mlist, Range=None, color='k', label=None, field=[['Ux', 'Uy'], ['omega']], Dirbase=None, Dt=1,
example=False, total=True, fignum=1, save=True):
M = Mlist[0]
if Dirbase == None:
Dirbase = '/Users/stephane/Documents/Experiences_local/Accelerated_grid/PIV_data/Test6/' # local saving
Dirbase = './Stat_avg/Panel/' + M.Id.date
axes = panel_graphs(M, subplot=[2, 3], fignum=fignum)
frames = select_range(M, Range)
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)) + '/'
figs.update(plot_scales(Mlist, axes, fignum=fignum, color=color, label=label))
plt.sca(axes[2])
frame = 1500
Dt = 1400
if label is None:
labels = ['m^', 'b>', 'ko']
else:
labels = [label, label, label]
for i, f in enumerate(field[0]): # should contain either one or two fields
figs.update(graphes.pdf_ensemble(Mlist, f, frame, Dt=Dt, fignum=fignum, label=labels[i], norm=False))
figs.update(graphes.legende(f, 'pdf of ' + f, ''))
plt.sca(axes[3])
for f in field[1]:
figs.update(graphes.pdf_ensemble(Mlist, f, frame, Dt=Dt, fignum=fignum, label=labels[2], norm=False))
figs.update(graphes.legende(f, 'pdf of ' + f, ''))
plt.sca(axes[4])
corr.corr_v_t(Mlist, frame, axes=['Ux', 'Ux'], N=200, p=1, display=True, save=False, label=labels[0], fignum=fignum)
corr.corr_v_t(Mlist, frame, axes=['Uy', 'Uy'], N=200, p=1, display=True, save=False, label=labels[1], fignum=fignum)
plt.sca(axes[5])
corr.corr_v_t(Mlist, frame, axes=['omega', 'omega'], N=200, p=1, display=True, save=False, label=labels[2],
fignum=fignum)
if save:
graphes.save_figs(figs, savedir=Dirname, prefix='General', suffix='_vs_t', dpi=300, frmt='png', display=True)
else:
return figs, Dirname
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 vfield(sigma, modes, fignum=1):
names = {
'sigma': sigma,
'n': modes
} # name:eval(name) for name in ['sigma','n','N_p']}# this piece of code does not work
t = distribution(sigma, modes)
B = 1.
n = 100
dx = 2 * B / n
x = np.arange(-B, B, dx)
y = 0.
z = np.arange(-B, B, dx)
P = np.asarray(np.meshgrid(x, y, z))
dim = P.shape
N = np.prod(dim[1:])
X = np.reshape(P[0, ...], (N, ))
Y = np.reshape(P[1, ...], (N, ))
Z = np.reshape(P[2, ...], (N, ))
Pos = [np.asarray([x0, y0, z0]) for x0, y0, z0 in zip(X, Y, Z)]
V = biot.velocity_from_line(t.paths, Pos, Gamma=1, d=3)
V_2d = np.reshape(V, (n, n, 3))
E = np.sum(np.power(V_2d, 2), axis=2)
subplot = [111]
fig, axes = panel.make(subplot, fignum=fignum)
fig.set_size_inches(10, 10)
graphes.color_plot(x, z, E, fignum=fignum, vmin=0, vmax=0, log=True)
c = graphes.colorbar()
figs = {}
figs.update(graphes.legende('X', 'Z', 'E'))
graphes.save_figs(figs,
prefix='Random_path/V_Distributions/Fields/',
suffix=suf(names),
dpi=300,
display=True,
frmt='png')
def time_corr(data, param, N=800, outdir='/Users/npmitchell/Dropbox/Soft_Matter/turbulence/jhtd/'):
"""
Parameters
----------
data
param
N
Returns
-------
"""
keys = data.keys()
figs = {}
for p in range(3):
print(p)
keys = np.sort(keys)
[data[key] for key in keys]
t = np.asarray([param[key]['t0'] for key in keys[0:N / 2]])
C = np.zeros(N / 2)
Dt = np.zeros(N / 2)
for i in range(N / 2):
if i % 100 == 0:
print(i)
C[i] = np.nanmean(
np.asarray([data[key1][..., p] * data[keys[i + j]][..., p] for j, key1 in enumerate(keys[0:N / 2])]),
axis=(0, 1, 2))
Dt[i] = np.nanmean(np.asarray([param[keys[j + i]]['t0'] - param[keys[j]]['t0'] for j in range(N / 2)]))
# print(Dt)
graphes.graph(Dt, C / C[0], fignum=4)
graphes.set_axis(0, 400, -1, 1.1)
figs.update(graphes.legende('t', 'C', 'JHTD corr functions'))
graphes.save_figs(figs, savedir=outdir + 'corr_functions/', suffix='', prefix='', frmt='pdf', dpi=300)
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 compute_tc(Mlist, Corr_fun, fields, log=True):
M = Mlist[0]
labels = ['ro', 'k^']
s = ''
figs = {}
for i, field in enumerate(fields):
C = Corr_fun[field]
t = []
tau = []
for tup in C:
tc = tup[1]
C_norm = tup[2]
N = len(C_norm) / 2
ind1 = np.argmin(np.abs(C_norm[N + 1] / 2. - C_norm[1:N]))
ind2 = np.argmin(np.abs(C_norm[N + 1] / 2. - C_norm[N:]))
tau.append(tc[ind2 + N] - tc[ind1])
t.append(tc[N])
if log:
graphes.graphloglog(t, tau, fignum=1, label=labels[i])
# graphes.set_axis(min(t),max(t),min(t),0.1)
else:
graphes.graph(t, tau, fignum=1, label=labels[i])
graphes.set_axis(0, 0.4, 0, 0.1)
s = s + field + ', '
figs.update(graphes.legende('t (s)', 't_c (s)', s[:-2]))
name = 'fx_' + str(int(np.floor(M.fx * 1000))) + 'm'
graphes.save_figs(figs,
prefix='./Stat_avg/Time_correlation/Overview/' +
field + '/' + name,
dpi=300,
display=True,
frmt='png')
def main(Mlist):
savedir = title(Mlist[0])
indices = range(400, 2000, 10)
n = len(indices)
N = len(Mlist)
print(N)
figs = {}
X = np.zeros((N, n, 2))
Y = np.zeros((N, n, 2))
for j, M in enumerate(Mlist):
print(j)
Xmin = []
Xmax = []
Ymin = []
Ymax = []
Vmin = []
Vmax = []
Gammamin = []
Gammamax = []
t = []
field = 'omega'
Omega = access.get_all(M, field)
for i in indices:
Z = Omega[:, 5:, i]
t.append(M.t[i])
xmin, xmax, ymin, ymax = positions(M, i)
vmin, vmax, G = amplitude(M, i)
Gammamin.append(G[0])
Gammamax.append(G[1])
Vmin.append(vmin)
Vmax.append(vmax)
Xmin.append(xmin)
Xmax.append(xmax)
Ymin.append(ymin)
Ymax.append(ymax)
X[j, :, 0] = np.asarray(Xmin)
X[j, :, 1] = np.asarray(Xmax)
Y[j, :, 0] = np.asarray(Ymin)
Y[j, :, 1] = np.asarray(Ymax)
graphes.graph(t, Xmin, label='bo', fignum=1)
graphes.graph(t, Xmax, label='ro', fignum=1)
figs.update(graphes.legende('Time (s)', 'Horizontal position (mm)',
''))
graphes.graph(Xmin, Ymin, label='bo', fignum=2)
graphes.graph(Xmax, Ymax, label='ro', fignum=2)
figs.update(graphes.legende('X (mm)', 'Y(mm)', ''))
graphes.graph(t, Vmin, label='b', fignum=3)
graphes.graph(t, Vmax, label='r', fignum=3)
figs.update(graphes.legende('Time (s)', 'Maximum vorticity (s^-1)',
''))
graphes.graph(t, Gammamin, label='b', fignum=4)
graphes.graph(t, Gammamax, label='r', fignum=4)
figs.update(graphes.legende('Time (s)', 'Circulation mm^2/s', ''))
graphes.set_axis(0, 0.32, -25000, 25000)
Dx = (X - np.tile(np.nanmean(X, axis=0), (N, 1, 1)))
Dy = (Y - np.tile(np.nanmean(Y, axis=0), (N, 1, 1)))
D = np.sqrt(Dx**2 + Dy**2)
D_moy = np.nanmean(D, axis=0)
# print(t)
# print(D[j,:,1])
# for j in range(N):
# graphes.graph(t,D[j,:,0],label='bo',fignum=4)
# graphes.graph(t,D[j,:,1],label='ro',fignum=4)
graphes.graph(t, D_moy[:, 0], label='b', fignum=6)
graphes.graph(t, D_moy[:, 1], label='r', fignum=6)
figs.update(
graphes.legende('Time (s)', 'Distance (mm)', 'Spreading of vortices'))
graphes.set_axis(0, 0.3, 0, 20)
graphes.graph(np.power(t, 3),
np.power(D_moy[:, 0], 2),
label='b',
fignum=5)
graphes.graph(np.power(t, 3),
np.power(D_moy[:, 1], 2),
label='r',
fignum=5)
graphes.set_axis(0, 0.3**3, 0, 100)
figs.update(
graphes.legende('t^3 (s^3)', 'd^2 (mm^2)',
'Spreading of vortices : rescaling'))
graphes.save_figs(figs,
savedir=savedir,
suffix='',
prefix='',
frmt='pdf',
dpi=300,
display=True)
def profile_avg(Mlist, i, display=False, fignum=1):
field = 'omega'
R_list = np.arange(0.25, 15., 0.25)
R = np.arange(0., 15., 0.25)
n = len(Mlist)
figs = {}
Gamma = np.zeros((n, len(R), 2))
Flux = np.zeros((n, len(R), 2))
for k, M in enumerate(Mlist):
x = M.x[0, 5:]
y = -M.y[:, 0]
dx = M.x[0, 1] - M.x[0, 0]
U, d = vgradient.make_Nvec(M, i) # Z : d+1 dimension np array
imin, imax, jmin, jmax, Zfilt, X, Y = position_index(M,
i,
field=field,
display=display)
G = [[] for j in range(len(R_list) + 1)]
G[0].append(0)
G[0].append(0)
D = [[] for j in range(len(R_list) + 1)]
D[0].append(0)
D[0].append(0)
for j, b in enumerate(R_list):
tau1 = strain.strain_tensor_loc(U, imin, jmin, d, b=b)
tau2 = strain.strain_tensor_loc(U, imax, jmax, d, b=b)
for tau in [tau1, tau2]:
omega, enstrophy = strain.vorticity(tau, d=2, norm=False)
div = strain.divergence_2d(tau, d=2)
G[j + 1].append(
(omega[0, 0]) * np.pi * b**2 * dx**2) # -div[0,0]
D[j + 1].append(
(div[0, 0]) * np.pi * b**2 * dx**2) # -div[0,0]
Gamma[k, ...] = np.asarray(G)
Flux[k, ...] = np.asarray(D)
graphes.graph(R, -Gamma[k, :, 0], label='kv', fignum=fignum * 2)
graphes.graph(R, Gamma[k, :, 1], label='k^', fignum=fignum * 2)
graphes.graph(R, Flux[k, :, 0], label='kv', fignum=fignum * 2 + 1)
graphes.graph(R, Flux[k, :, 1], label='k^', fignum=fignum * 2 + 1)
Gamma_moy = np.nanmean(Gamma, axis=0)
Flux_moy = np.nanmean(Flux, axis=0)
graphes.graph(R, -Gamma_moy[:, 0], label='r--', fignum=fignum * 2)
graphes.graph(R, Gamma_moy[:, 1], label='r--', fignum=fignum * 2)
graphes.graph(R,
np.nanmean(np.asarray([Gamma_moy[:, 1], -Gamma_moy[:, 0]]),
axis=0),
label='rs',
fignum=fignum * 2)
figs.update(
graphes.legende('Distance to center (mm)', 'Circulation (mm^2/s)', ''))
graphes.graph(R, Flux_moy[:, 0], label='r--', fignum=fignum * 2 + 1)
graphes.graph(R, Flux_moy[:, 1], label='r--', fignum=fignum * 2 + 1)
graphes.graph(R,
np.nanmean(np.asarray([Flux_moy[:, 1], Flux_moy[:, 0]]),
axis=0),
label='rs',
fignum=fignum * 2 + 1)
figs.update(
graphes.legende('Distance to center (mm)', 'Divergence (mm^2/s)', ''))
savedir = title(Mlist[0])
graphes.save_figs(figs,
savedir=savedir,
suffix='',
prefix='frame_' + str(i),
frmt='pdf',
dpi=300,
display=True)
M_profile = np.nanmean(np.asarray([Gamma_moy[:, 1], -Gamma_moy[:, 0]]),
axis=0)
return np.mean(M_profile[-10:]), np.std(Gamma[:, -10:, 1])
def compile(Mlist, V=None, method='circulation'):
symbol = {'50': '^', '125': 'o', '250': 's'}
color = {'circulation': 'r', 'vorticity': 'b', 'joseph': 'k'}
labels = {key: color[method] + symbol[key] for key in symbol.keys()}
if V == None:
sub_labels = labels
piston_v = None
else:
piston_v = str(V)
sub_labels = {piston_v: labels[piston_v]} # ,'125':'ro','250':'bs'}
figs = {}
for i, M in enumerate(Mlist):
piston1 = browse.get_string(M.Sdata.fileCine,
'_v',
end='.cine',
shift=0,
display=False,
from_end=True)
piston2 = browse.get_string(M.Sdata.fileCine,
'_v',
end='_p30mum',
shift=0,
display=False,
from_end=True)
error = 0.25
for piston in [piston1, piston2]:
if piston in sub_labels.keys():
print(M.dataDir)
dx = np.mean(np.diff(M.x[0, :]))
print('Spatial scale : ' + str(dx) + ' mm/box')
lc, std_lc, Gamma, std_Gamma = compute(M,
method=method,
display=False,
fignum=(i + 1) * 2)
# print(piston,dx,lc,std_lc)
if std_lc / lc < error:
graphes.errorbar(dx,
lc, [0],
std_lc,
label=labels[piston],
fignum=250)
figs.update(graphes.legende('mm/box', 'Core size (mm)',
''))
graphes.set_axis(0, 1.5, 0, 6.)
if method == 'circulation':
# if np.abs(std_Gamma/Gamma)<error:
graphes.errorbar(dx,
Gamma, [0],
std_Gamma,
label=labels[piston],
fignum=251)
figs.update(
graphes.legende('mm/box', 'Circulation (mm^2/s)',
''))
graphes.set_axis(0, 1.5, -2 * 10**4, 0)
# print(piston,dx,lc,std_lc
print('')
print('figure', figs)
print(figs)
graphes.save_figs(figs,
suffix='Compilation_method_' + method + '_v' + piston_v)
def save_graphes(M, figs, method='vorticity'):
graphes.save_figs(figs,
savedir='./Results/' + os.path.basename(M.dataDir) + '/',
suffix='_method_' + method + '_')
def corr_v_d(Mlist,
t,
axes=['Ux', 'Ux'],
N=100,
Dt=1,
p=1,
display=False,
save=False,
label='^',
fignum=1):
"""
compute the correlation function in space at a given time. Average over space (ie along d-1 dimensions of Mlist[axes[0]]),and eventually over time
INPUT
------
M : Mdata object
must have attributes : t, fields ('Ux','Uy', ...)
must have method shape()
t : int
time index
axes : 2 elements string list
attributes of M to be used for the correlation function
N : int
Number of frames before and after time t.
p : int. default value is 1
power of the fields C_p(Dt) = U1**p * U2**p / <U1**2p >
display : bool. default value is false
"""
# Ct=[]
# how to average ?? -> need a mean on several realization ? or just substract the average value (in space) ?
M = Mlist[0]
tlist = M.t
# print("Compute mean values")
tmin = max(0, t - N)
tmax = min(len(tlist) - 1, t + N)
# print(tmin)
# print(tmax)
t_c = np.asarray(M.t)[np.arange(tmin, tmax)] # -M.t[t]
# print(np.mean(np.diff(t_c)))
# max number of time step
# print("Compute mean values 2")
# Compute the average flow
Xm = []
Ym = []
for M in Mlist:
Xref, Yref = chose_axe(M, t, axes)
Xm.append(Xref)
Ym.append(Yref)
Xm = np.asarray(Xm)
Ym = np.asarray(Ym)
# print(Xm.shape)
Xmoy_ref, Xstd_ref = statP.average(Xref, axis=())
# idea : compute the flow average over several realizations (ensemble avg)
Ct = []
for tc in range(tmin, tmax):
Sp = []
Xt_moy = []
XDt_moy = []
for M in Mlist:
Xref, Yref = chose_axe(M, t, axes)
Xt_m, Xstd_ref = statP.average(Xref)
Xt_moy.append(Xt_m)
X, Y = chose_axe(M, tc, axes)
XDt_m, Xstd = statP.average(X)
XDt_moy.append(XDt_m)
Xt_ref = statP.average(Xt_moy)
XDt_ref = statP.average(XDt_moy)
for M in Mlist:
Xref, Yref = chose_axe(M, t, axes)
# Xmoy_ref,Xstd_ref=statP.average(Xref)
X, Y = chose_axe(M, tc, axes)
# Xmoy,Xstd=statP.average(X)
Sp.append((X - XDt_ref)**p * (Xref - XDt_ref)**p)
# print(np.shape(Sp))
Ct.append(statP.average(Sp)[0])
# print(Ct)
C0 = Ct[t - tmin]
C_norm = np.asarray(Ct) / C0
indices = np.argsort(t_c)
t_c = t_c[indices] - M.t[t]
C_norm = C_norm[indices]
# plot distribution of Sp values ?
figs = {}
if display or save:
field = axes[0]
title = str(axes[0]) + ', ' + str(axes[1])
graphes.graph(t_c, C_norm, fignum=fignum, label=label)
figs.update(graphes.legende('$t (s)$', '$C$', title))
if save:
name = 'fx_' + str(int(np.floor(M.fx * 1000))) + 'm_t_' + str(
int(np.floor(M.t[t] * 1000))) + 'm_'
graphes.save_figs(figs,
prefix='./Stat_avg/Time_correlation/Serie/' +
field + '/' + name,
dpi=300,
display=True,
frmt='png')
return t_c, C_norm
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 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_')
graphes.color_plot(M.x, M.y, E_moy, fignum=j + 1, vmin=0, vmax=80000)
graphes.colorbar(label=names[j] + ' (' + units[j] + ')')
figs.update(
graphes.legende('X (mm)', 'Y (mm)', 'Time averaged ' + field, cplot=True))
X, Y = [], []
for i in indices:
X.append(
track.positions(M, i, field='E', indices=indices, step=1,
sigma=10.)[1])
Y.append(
track.positions(M, i, field='E', indices=indices, step=1,
sigma=10.)[3])
X0, Y0 = np.nanmean(X), np.nanmean(Y)
# graphes.graph([X0],[Y0],label='ko',fignum=j+1)
graphes.save_figs(figs, savedir=savedir, suffix='smooth')
########################################################
# Time averaged Fluctuating Energy
########################################################
figs = {}
fields, names, vmin, vmax, labels, units = comp.std_fields()
# print(M.param.v)
indices = range(50, Mfluc.Ux.shape[2])
field = 'E'
j = 3 # index to put right units on the graph (j=3 (energy), j=4 (enstrophy))
print(fields)
E_moy = np.nanmean(getattr(Mfluc, field)[..., indices], axis=2)
graphes.color_plot(Mfluc.x, Mfluc.y, E_moy, fignum=j + 1, vmin=0, vmax=80000)
graphes.colorbar(label=names[j] + ' \'' + ' (' + units[j] + ')')
figs.update(
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 make_stat_panel(Mlist, fignum=1, **kwargs):
for M in Mlist:
make_plot_lin([M], fignum=fignum, **kwargs)
figs, Dirname = make_plot_lin(Mlist, fignum=fignum, label='r', **kwargs)
graphes.save_figs(figs, savedir=Dirname, prefix='General', suffix='_vs_t', dpi=300, frmt='png', display=True)
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 V_distribution2(n, sigma, fignum=1):
N = 10**4
N_p = 10
# names = {name:eval(name) for name in ['sigma','n','N_p']}# this piece of code does not work systematically
names = {
'sigma': sigma,
'n': n,
'Np': N_p
} # name:eval(name) for name in ['sigma','n','N_p']}# this piece of code does not work systematically
B = 1.
V_tot = []
d = 3
subplot = ['131', '132', '133']
labels = ['Ux', 'Uy', 'Uz']
fig, axes = panel.make(subplot, fignum=fignum + 1, axis='on')
fig.set_size_inches(20, 5)
figs = {}
title = 'sigma=' + str(sigma) + ', n=' + str(n) + ', Np=' + str(N_p)
V_tot = np.zeros((N, N_p, d))
for p in range(N_p):
Theta = 2 * np.pi * np.random.random(
N) # uniform distribution between 0 and 2pi
Phi = np.pi * np.random.random(
N) # uniform distribution between 0 and pi
R = B * np.random.random(N)
X = R * np.cos(Theta) * np.sin(Phi)
Y = R * np.sin(Theta) * np.sin(Phi)
Z = R * np.cos(Phi)
Pos = [np.asarray([x0, y0, z0]) for x0, y0, z0 in zip(X, Y, Z)]
t = distribution(sigma, n)
V = biot.velocity_from_line(t.paths, Pos, Gamma=1, d=3)
if p == 0:
t_tot = t
else:
t_tot.paths = t_tot.paths + t.paths
V_tot[:, p, :] = V
figs = radial_density(t, fignum=fignum, label='k')
figs.update(graphes.legende('R', 'PDF(R)', title))
for i, num in enumerate(subplot):
panel.sca(axes[num])
graphes.distribution(V[..., i],
normfactor=1,
a=10.,
label='k',
fignum=fignum + 1,
norm=True)
figs.update(graphes.legende(labels[i], 'PDF ' + labels[i], title))
figs = radial_density(t_tot, fignum=fignum, label='r')
figs.update(graphes.legende('R', 'PDF(R)', title))
for i, num in enumerate(subplot):
panel.sca(axes[num])
graphes.distribution(V_tot[..., i],
normfactor=N_p,
a=10.,
label='r',
fignum=fignum + 1,
norm=True)
figs.update(graphes.legende(labels[i], 'PDF ' + labels[i], title))
graphes.save_figs(figs,
prefix='Random_path/V_Distributions/Compilation/',
suffix=suf(names),
dpi=300,
display=True,
frmt='png')
