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 spatial_corr(data, N=1024, Dt=10):
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='./Corr_functions/',
suffix='',
prefix='',
frmt='pdf',
dpi=300)
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 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 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 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 time_corr(data, param, N=800):
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='./Corr_functions/',
suffix='',
prefix='',
frmt='pdf',
dpi=300)
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 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 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 example(filename):
figs = {}
savedir = '/Users/stephane/Documents/Postdoc_Chicago/Process_data/Scripts/Example/Smoothing/'
M = M_manip.load_Mdata_file(filename, data=True)
M.get('E')
M.get('omega')
nx, ny, nt = M.shape()
x, y = M.x, M.y
i = nt / 2
# display raw energy
graphes.Mplot(M, 'E', i, vmin=0, vmax=50000, fignum=1, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Energy without pre-processing',
cplot=True))
#Display raw vorticity
graphes.Mplot(M, 'omega', i, vmin=0, vmax=80, fignum=2, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity without pre-processing',
cplot=True))
# Look for bada data point in amplitude
E = M.E[..., i]
tup, errors = cdata.rm_baddata(E, borne=2.)
xc = []
yc = []
for t in tup:
xc.append([x[t[0], t[1]]])
yc.append([y[t[0], t[1]]])
graphes.graph(xc, yc, label='ro', fignum=2)
print(figs)
graphes.save_figs(figs, savedir=savedir)
Ux, Uy = M.Ux[..., i], M.Uy[..., i]
#replace component of the velocity
Ux = cdata.replace_data(Ux, tup)[..., 0]
Uy = cdata.replace_data(Uy, tup)[..., 0]
U = np.transpose(np.asarray([Uy, Ux]), (1, 2, 0))
dU = strain.strain_tensor_C(U, b=2.)
omega, enstrophy = strain.vorticity(dU, d=2, norm=False)
E = Ux**2 + Uy**2
graphes.color_plot(x, y, omega, vmin=0, vmax=80, fignum=4)
graphes.plt.colorbar()
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity after pre-processing',
cplot=True))
graphes.color_plot(x, y, E, vmin=0, vmax=50000, fignum=3)
graphes.plt.colorbar()
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Energy after pre-processing',
cplot=True))
### Gaussian filter
omega_filt = filters.gaussian_filter(omega, sigma=2.) #[...,0]
graphes.color_plot(x, y, omega_filt, vmin=0, vmax=80, fignum=5)
graphes.plt.colorbar()
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity after gaussian smoothing',
cplot=True))
graphes.save_figs(figs, savedir=savedir)
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 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 single(filename, display=False):
figs = {}
savedir = '/Users/stephane/Documents/Postdoc_Chicago/Process_data/Scripts/Samples/Smoothing/'
filesave, ext = os.path.splitext(filename)
filesave = filesave + '_processed.hdf5'
M = M_manip.load_Mdata_file(filename, data=True)
M.get('E')
M.get('omega')
nx, ny, nt = M.shape()
i = nt / 2
# display raw energy
if display:
graphes.plt.close('all')
graphes.Mplot(M, 'E', i, vmin=0, vmax=50000, fignum=1, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Energy without pre-processing',
cplot=True))
#Display raw vorticity
graphes.Mplot(M, 'omega', i, vmin=0, vmax=100, fignum=2, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity without pre-processing',
cplot=True))
graphes.save_figs(figs, savedir=savedir, prefix=M.Id.get_id())
graphes.Mplot(M, 'Ux', i, vmin=-200, vmax=200, fignum=3, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Ux after pre-processing',
cplot=True))
M = cdata.remove_spurious(M, borne=1.5)
M.get('E', force=True)
M.get('omega', force=True)
if display:
graphes.Mplot(M, 'E', i, vmin=0, vmax=50000, fignum=4, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Energy after pre-processing',
cplot=True))
#Display raw vorticity
graphes.Mplot(M, 'omega', i, vmin=0, vmax=100, fignum=5, colorbar=True)
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity after pre-processing',
cplot=True))
### Gaussian filter
omega_filt = track.smoothing(M, i, field='omega', sigma=2.5)
graphes.color_plot(M.x, M.y, omega_filt, vmin=0, vmax=100, fignum=6)
graphes.plt.colorbar()
figs.update(
graphes.legende('$x$ (mm)',
'$y$ (mm)',
'Vorticity after gaussian smoothing',
cplot=True))
graphes.save_figs(figs, savedir=savedir, prefix=M.Id.get_id())
### Gaussian filter
# omega_filt = filters.gaussian_filter(omega, sigma=2.)#[...,0]
# graphes.color_plot(x,y,omega_filt,vmin=0,vmax=50,fignum=5)
# graphes.plt.colorbar()
# figs.update(graphes.legende('$x$ (mm)','$y$ (mm)','Vorticity after gaussian smoothing',cplot=True))
# graphes.save_figs(figs,savedir=savedir)
to_hdf5.write(M, filename=filesave, key='Mdata')
def single(M,fun,**args,**kwargs):
"""
call a measurement function fun and generate the following output
"""
data = {}
output = fun(M,**args,**kwargs)
data['X'] = output[0]
data['Y'] = output[1]
data['param'] = output[2:]
figs = {}
graphes.graph(X,Y,fignum=1)
figs.update(graphes.legende('$t$ (s)','$<E>_{x,y}$ (mm^2/s^2)',graphes.title(M)))
savedir = location(M)
graphes.save_figs(figs,savedir=savedir,suffix='label',prefix='',frmt='pdf',dpi=300,display=True)
write_dictionnary(file,keys,List_info,delimiter='\t')
return data
def dict_fun():
functions = [decay.decay,]
def multiple(Mlist):
pass
def location(M):
savedir = './Vortex_Turbulence/Mean_flow/'+date+'/'
def save_graphes(M, figs, method='vorticity'):
graphes.save_figs(figs,
savedir='./Results/' + os.path.basename(M.dataDir) + '/',
suffix='_method_' + method + '_')
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')
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 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 example():
Slist = Sdata_manip.load_all()
graphic(Slist)
graphes.save_figs(figs, savedir='./Figures/')
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 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 serie(Gamma, epsilon, d0=1):
savedir = './Vortex/Advection/Gaussian_noise_linear/Stat/'
n = 10**3
N = 10**4
plist = []
fignum = 1
# graphes.plt.clf()
fig, axes = panel.make([121, 122], fignum=fignum, axis='on')
fig.set_size_inches(10, 5)
# print(figs)
# print(axes)
for i in range(n):
if i % 100 == 0:
print(i)
p = simulate(N, epsilon=epsilon, Gamma=Gamma, d0=d0)
p['d'] = np.sqrt(np.sum((p['r'][..., 0] - p['r'][..., 1])**2, axis=1))
p['n'] = n
p['N'] = N
# graphes.graph(p['r'][:,0,0],p['r'][:,1,0])
# graphes.graph(p['r'][:,0,1],p['r'][:,1,1])
# panel.sca(axes[121])
# graphes.graph(p['r'][:,0,:],p['r'][:,1,:])
# graphes.graph(p['r'][:,0,1],p['r'][:,1,1])
# panel.sca(axes[122])
# graphes.graph(t,p['d'])
plist.append(p)
t = np.arange(N) * p['dt']
figs = graphes.legende(
'X', 'Y', 'Epsilon = ' + str(epsilon) + ', Gamma = ' + str(Gamma))
keys = ['epsilon', 'Gamma', 'n', 'N']
graphes.save_figs(figs, savedir=savedir, prefix=make_prefix(keys, p))
R = np.asarray([p['r'] for p in plist])
print(R.shape)
graphes.graphloglog(t,
np.std(R, axis=0)[..., 1, 0]**2 /
(epsilon**2 * p['dt']),
fignum=2)
#graphes.graphloglog(range(N),np.std(R,axis=0)[...,1,1]/epsilon,fignum=2)
#graphes.graphloglog(range(N),np.std(R,axis=0)[...,1,0]/epsilon,fignum=2)
#graphes.graphloglog(range(N),np.std(R,axis=0)[...,1,1]/epsilon,fignum=2)
#graphes.graphloglog(t,t,fignum=2,label='r--')
Y = t + 2 / 3. * Gamma**2 / d0**4 * t**3 #-np.arctan(t)
graphes.graphloglog(t, Y, fignum=2, label='r--')
# graphes.graphloglog([10**-1,10**1],[10**-2,10**0],fignum=2,label='r--')
# graphes.graphloglog([10**0,10**2],[10**-1,10**5],fignum=2,label='r--')
# graphes.graphloglog([10**3,10**5],[10**6,10**10],fignum=2,label='r--')
figs = graphes.legende('t (#)', 'Variance', '')
graphes.save_figs(figs, savedir=savedir, prefix=make_prefix(keys, p))
return plist, figs
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)
# fig,axes = panel.make([111],fignum=3+3*j)
# fig.set_size_inches(15,15)
# i = 1400
# graphes.Mplot(M,'enstrophy',i,fignum=3)
# graphes.graph(Xmin,Ymin,label='bo',fignum=3+3*j)
# graphes.graph(Xmax,Ymax,label='ro',fignum=3+3*j)
