tag=['0pourc','10pourc','20pourc','30pourc','40pourc','50pourc','60pourc']
legend=['8, 10*40', '8, 10*40','8, 10*40','8, 10*40','8, 10*40','8, 10*40','8, 10*40']
marker=['.','v','p','s','*','<','>']
output_max=[41, 99, 93, 100, 97, 110, 97]
#t1=[0.09912+6.95e-6, 0.09708-5.41e-4, 0.09653+5.72e-4-6.75e-5, 0.09243+2.72e-5, 0.09068-5.16e-4, 0.09068+1.84e-6, 0.0]
#t1=[0,0,0,0,0,0,0]
base_simu='B335_noturb_norot_hydro_pert_asym_aleatoire_shr_bigbox_'
t1=[]
seuil_rho = 1e-10
for i in range(len(tag)):
path_analyses='/home/averliat/these/analyses/'+base_simu+tag[i]+'/'
if os.path.isfile(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') == False:
ref = np.array(t_0.temps_0_simu(path_t0, seuil_rho, sortie_output=1))
np.savetxt(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt', ref)
else:
ref=np.loadtxt(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt')
t1.append(ref[1])
width_bar=[1,1,1,1,1,1,1]
hist=False
diff_abs=True
diff_relat=True
moyenne_glissante=True
path_simu_ref_t0 = path_simu_ref path_simu_a_comparer_t0 = path_simu_a_comparer num_output_max = 1000 #Ne pas modifier a priori, peut depassser le nombre max d'output pour tout lire sortie_output_ref=1 #Voir dans "pipeline_temps_0_simulation" a quoi ca sert #ATTENTION, PLUS UTILISER, LAISSER A 1 sortie_output_a_comparer=1 #Voir dans "pipeline_temps_0_simulation" a quoi ca sert #IDEM #--------------------------------------------------------------------------------- #Calcul des t_0 de chaque simulation ou lecture des fichiers si calculs deja faits #--------------------------------------------------------------------------------- if recalage_temporel == True: if os.path.isfile(path_simu_ref_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') == False: ref = np.array(t_0.temps_0_simu(path_simu_ref_t0, seuil_rho, sortie_output=sortie_output_ref)) np.savetxt(path_simu_ref_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt', ref) else: ref=np.loadtxt(path_simu_ref_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') if os.path.isfile(path_simu_a_comparer_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') == False: a_comparer = np.array(t_0.temps_0_simu(path_simu_a_comparer_t0, seuil_rho, sortie_output=sortie_output_a_comparer)) np.savetxt(path_simu_a_comparer_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt', a_comparer) else: a_comparer=np.loadtxt(path_simu_a_comparer_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') #Erreur si on cherche a etudier un fichier inferieur au t0 de la simulation de reference if num_output_ref < ref[0]: print
if owner == 'averliat_alfven':
path='/drf/projets/alfven-data/averliat/'+simu+'/'
if owner=='sapanais':
path='/dsm/anais/storageA/magmist/'+simu+'/'
if owner=='phennebe':
path='/drf/projets/capucine/phennebe/'+simu+'/'
path_analyses='/home/averliat/these/analyses/'+simu+'/'
#---------------------------------------------------------------------
#Lecture du temps et de l'output initial recale si output_min = 'None'
#---------------------------------------------------------------------
if os.path.isfile(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt') == False:
ref = np.array(t_0.temps_0_simu(path, seuil_rho))
np.savetxt(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt', ref)
else:
ref=np.loadtxt(path_analyses+'t0_seuil_rho_'+str(seuil_rho)+'.txt')
output_0 = int(ref[0])
time_0 = ref[1]
if output_min == 'None':
output_min = output_0
nmbr_output = output_max - output_min + 1
def image(simu, owner, num_output, dir_save):
save = True
radius_zoom = 1
v_proj = True
title_time = True
title_time_cor = False
seuil_rho = 1e-10
fleche_vel = False
nbre_fleche = 20 #En fait plus c'est faible plus y'a de fleches...
selon_x = True
selon_y = True
selon_z = True
vmin_vel = None #-4.5
vmax_vel = None #-vmin_vel
vmin_dens = None #22.7
vmax_dens = None #28.9
color_sink_colmap = 'firebrick'
transparence_sink_colmap = 0.4
color_sink_velmap = 'limegreen'
transparence_sink_velmap = 0.7
reposition_fig = False #Pour repositionner les figures ouvertes par matplotlib
#Pour fermer toutes les figures avec matplotlib : plt.close('all')
#--------------------------------------------------------------
#Chemin de la simulation et du dossier de sauvegarde des images
#--------------------------------------------------------------
if owner == 'averliat':
path = '/mnt/magmist/magmist/simu_B335_averliat/' + simu + '/'
if owner == 'phennebe':
path = '/drf/projets/capucine/' + owner + '/' + simu + '/'
if owner == 'sapanais':
path = '/dsm/anais/storageA/magmist/' + simu + '/'
if owner == 'averliat_alfven':
path = '/drf/projets/alfven-data/averliat/' + simu + '/'
path_save = '/home/averliat/these/analyses/' + simu + '/' + dir_save + '/'
path_analyse = '/home/averliat/these/analyses/' + simu + '/'
#if simu == 'B335_noturb_norot_hydro_pert_asym_aleatoire50_vhr':
# path_t0='/mnt/magmist/magmist/simu_B335_averliat/'+simu+'/'
#else:
# path_t0=path
path_t0 = path
if save == True:
if os.path.isdir(path_save) == False:
os.mkdir(path_save)
#-------------------
#Lecture de l'output
#-------------------
ro = pymses.RamsesOutput(path, num_output)
lbox_pc = ro.info['unit_length'].express(cst.pc)
amr = ro.amr_source(["rho", "vel", "P", "phi", "g"])
cell_source = CellsToPoints(amr)
cells = cell_source.flatten()
pos = cells.points
rho = cells["rho"]
#------------------------------------------------------------
#Facteur de conversion des unites de code en unites physiques
#------------------------------------------------------------
lbox = ro.info['boxlen']
lbox_m = ro.info['unit_length'].express(cst.m)
lbox_au = ro.info['unit_length'].express(cst.au)
lbox_cm = ro.info['unit_length'].express(cst.cm)
factor_time_yr = ro.info['unit_time'].express(cst.year)
factor_vel_km_s = ro.info['unit_velocity'].express(cst.km / cst.s)
simulation_time = ro.info['time'] * factor_time_yr
#---------------------------------------------------------------------------------
#Calcul des t_0 de chaque simulation ou lecture des fichiers si calculs deja faits
#---------------------------------------------------------------------------------
if title_time_cor == True:
if os.path.isfile(path_analyse + 't0_seuil_rho_' + str(seuil_rho) +
'.txt') == False:
ref = np.array(
t_0.temps_0_simu(path_t0, seuil_rho, sortie_output=1))
np.savetxt(
path_analyse + 't0_seuil_rho_' + str(seuil_rho) + '.txt', ref)
else:
ref = np.loadtxt(path_analyse + 't0_seuil_rho_' + str(seuil_rho) +
'.txt')
#Erreur si on cherche a etudier un fichier inferieur au t0 de la simulation de reference
if num_output < ref[0]:
print
print
print("=================================================")
print("=================================================")
print("/!\ output_ref < output_ref_t0 /!\ ")
print("=================================================")
print("=================================================")
title_time_cor = 0
#---------------------------------------------------------
#Definition du centre des images et de leur niveau de zoom
#---------------------------------------------------------
#Position du "centre" de la simulation = endroit le plus dense
if radius_zoom == 5:
center = [0.5, 0.5, 0.5]
else:
arg_centre = np.argmax(rho)
center = [
pos[:, 0][arg_centre], pos[:, 1][arg_centre], pos[:, 2][arg_centre]
]
zoom_v = [0.045, 0.015, 0.005, 0.005 / 3., 0.5]
if 'bigbox' or 'jet' in simu:
zoom_v = [
0.045 / 2, 0.015 / 2, 0.005 / 2, 0.005 / 3. / 2, 0.5, 0.5 / 2,
0.005 / 20.
]
if radius_zoom == 6:
center = [0.5, 0.5, 0.5]
if 'hugebox' in simu:
zoom_v = [
0.045 / 4, 0.015 / 4, 0.005 / 4, 0.005 / 3. / 4, 0.5, 0.5 / 4
]
if radius_zoom == 6:
center = [0.5, 0.5, 0.5]
radius = zoom_v[radius_zoom - 1]
#radius=float(zoom_v[np.where(zoom_v==radius_zoom)]) #0.015#0.005 #Niveau de zoom correspondant au niveau '3' des images de "pipeline_image_unique.py"
#------------------------------------------------------------------------
#Get the properties of the particules with just the particules' positions
#Copie depuis module_extract.py
#------------------------------------------------------------------------
def read_sink_csv(num, directory, no_cvs=None):
name = directory + 'output_' + str(num).zfill(5) + '/sink_' + str(
num).zfill(5) + '.csv'
print 'read sinks from ', name
if (no_cvs is None):
sinks = np.loadtxt(name,
delimiter=',',
ndmin=2,
usecols=(0, 1, 2, 3, 4, 5, 6, 7,
8)) #,9,10,11,12))
else:
sinks = np.loadtxt(name,
ndmin=2,
usecols=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12))
return sinks
#------------------------------
#Pour visualiser les sinks
#Adapted from module_extract.py
#------------------------------
def visualise_sink_AU(path, num_output):
sinks = read_sink_csv(num_output, path)
if len(sinks) != 0:
mass_sinks = sinks[:, 1] #masse des sinks en masses solaires
x_sinks = sinks[:,
3] * lbox_au / lbox #coordonnees x des sinks en AU
y_sinks = sinks[:,
4] * lbox_au / lbox #coordonnees y des sinks en AU
z_sinks = sinks[:,
5] * lbox_au / lbox #coordonnees z des sinks en AU
return mass_sinks, x_sinks, y_sinks, z_sinks
#---------------------------------------
#Lecture du fichier sink.csv s'il existe
#---------------------------------------
sink_plot = False
if os.path.isfile(path + 'output_' + str(num_output).zfill(5) + '/sink_' +
str(num_output).zfill(5) + '.csv') == True:
#sink_plot=True
sinks = read_sink_csv(num_output, path)
if len(sinks) != 0:
sink_plot = True
if sink_plot == True:
m_sinks, x_sinks, y_sinks, z_sinks = visualise_sink_AU(
path, num_output)
#size_sinks=20*np.tanh(25*m_sinks)
size_sinks = 20 * np.sqrt(m_sinks)
if radius_zoom != 5: #centrage sur la plus grosse sink au lieu de rho max
arg_biggest_sink = np.argmax(m_sinks)
x_biggest_sink = x_sinks[arg_biggest_sink] / lbox_au
y_biggest_sink = y_sinks[arg_biggest_sink] / lbox_au
z_biggest_sink = z_sinks[arg_biggest_sink] / lbox_au
center = [x_biggest_sink, y_biggest_sink, z_biggest_sink]
#---------------------------------------------------------------------------------------------------------------
#Definition prise sur https://stackoverflow.com/questions/20144529/shifted-colorbar-matplotlib/20146989#20146989
#pour avoir le centre de la colorbar a 0
#---------------------------------------------------------------------------------------------------------------
class MidpointNormalize(Normalize):
def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
self.midpoint = midpoint
Normalize.__init__(self, vmin, vmax, clip)
def __call__(self, value, clip=None):
# I'm ignoring masked values and all kinds of edge cases to make a
# simple example...
x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
return np.ma.masked_array(np.interp(value, x, y))
#-----------------
#-----------------
#Calcul des cartes
#-----------------
#-----------------
if selon_x == True:
#--------------------------------------------
#Calcul de la carte ou l'on regarde suivant x
#--------------------------------------------
cam_x = Camera(center=center,
line_of_sight_axis='x',
region_size=[2. * radius, 2. * radius],
distance=radius,
far_cut_depth=radius,
up_vector='z',
map_max_size=512)
rho_op = ScalarOperator(lambda dset: dset["rho"],
ro.info["unit_density"])
rt = raytracing.RayTracer(amr, ro.info, rho_op)
datamap = rt.process(cam_x, surf_qty=True)
map_col = np.log10(datamap.map.T * lbox_cm)
if v_proj == True:
Vx_op = ScalarOperator(
lambda dset: dset["vel"][..., 0] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vx_op)
datamap_vx = rt.process(cam_x, surf_qty=True)
map_Vx = datamap_vx.map.T / datamap.map.T * factor_vel_km_s
if fleche_vel == True:
Vy_depuis_x_op = ScalarOperator(
lambda dset: dset["vel"][..., 1] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vy_depuis_x_op)
datamap_vy_depuis_x = rt.process(cam_x, surf_qty=True)
map_vy_depuis_x = datamap_vy_depuis_x.map.T / datamap.map.T * factor_vel_km_s
map_vy_depuis_x_red = map_vy_depuis_x[::nbre_fleche, ::nbre_fleche]
Vz_depuis_x_op = ScalarOperator(
lambda dset: dset["vel"][..., 2] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vz_depuis_x_op)
datamap_vz_depuis_x = rt.process(cam_x, surf_qty=True)
map_vz_depuis_x = datamap_vz_depuis_x.map.T / datamap.map.T * factor_vel_km_s
map_vz_depuis_x_red = map_vz_depuis_x[::nbre_fleche, ::nbre_fleche]
plt.figure()
im = plt.imshow(map_col,
extent=[(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au,
(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au],
origin='lower')
plt.xlabel('$y$ (AU)')
plt.ylabel('$z$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_x_' + str(radius_zoom) + '_' +
str(num_output) + '.pdf',
bbox_inches='tight')
nx = map_vy_depuis_x_red.shape[0]
ny = map_vy_depuis_x_red.shape[1]
vec_x = (np.arange(nx) * 2. / nx * radius - radius + center[0] +
radius / nx) * lbox_au
vec_y = (np.arange(ny) * 2. / ny * radius - radius + center[1] +
radius / nx) * lbox_au
xx, yy = np.meshgrid(vec_x, vec_y)
plt.quiver(xx, yy, map_vy_depuis_x_red, map_vz_depuis_x_red)
else:
plt.figure()
plt.imshow(map_col,
extent=[(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au,
(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au],
origin='lower',
vmin=vmin_dens,
vmax=vmax_dens)
if sink_plot == True:
for i in range(len(m_sinks)):
if (y_sinks[i] > (-radius + center[1]) * lbox_au) & (
y_sinks[i] <
(radius + center[1]) * lbox_au) & (
z_sinks[i] > (-radius + center[2]) * lbox_au) & (
z_sinks[i] < (radius + center[2]) * lbox_au):
plt.plot(y_sinks[i],
z_sinks[i],
'.',
color=color_sink_colmap,
markersize=size_sinks[i],
alpha=transparence_sink_colmap)
plt.xlabel('$y$ (AU)')
plt.ylabel('$z$ (AU)')
cbar = plt.colorbar()
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_x_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if v_proj == True:
plt.figure()
norm = MidpointNormalize(
midpoint=0) #Pour avoir le centre de la colormap a 0
plt.imshow(map_Vx,
extent=[(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au,
(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au],
origin='lower',
cmap='RdBu_r',
norm=norm,
vmin=vmin_vel,
vmax=vmax_vel)
if sink_plot == True:
for i in range(len(m_sinks)):
if (y_sinks[i] > (-radius + center[1]) * lbox_au) & (
y_sinks[i] <
(radius + center[1]) * lbox_au) & (
z_sinks[i] > (-radius + center[2]) * lbox_au) & (
z_sinks[i] < (radius + center[2]) * lbox_au):
plt.plot(y_sinks[i],
z_sinks[i],
'.',
color=color_sink_velmap,
markersize=size_sinks[i],
alpha=transparence_sink_velmap)
plt.xlabel('$y$ (AU)')
plt.ylabel('$z$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$v_x \, (km.s^{-1})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'vel_x_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if selon_y == True:
#--------------------------------------------
#Calcul de la carte ou l'on regarde suivant y
#--------------------------------------------
cam_y = Camera(center=center,
line_of_sight_axis='y',
region_size=[2. * radius, 2. * radius],
distance=radius,
far_cut_depth=radius,
up_vector='x',
map_max_size=512)
rho_op = ScalarOperator(lambda dset: dset["rho"],
ro.info["unit_density"])
rt = raytracing.RayTracer(amr, ro.info, rho_op)
datamap = rt.process(cam_y, surf_qty=True)
map_col = np.log10(datamap.map.T * lbox_cm)
if v_proj == True:
Vy_op = ScalarOperator(
lambda dset: dset["vel"][..., 1] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vy_op)
datamap_vy = rt.process(cam_y, surf_qty=True)
map_Vy = datamap_vy.map.T / datamap.map.T * factor_vel_km_s
if fleche_vel == True:
Vx_depuis_y_op = ScalarOperator(
lambda dset: dset["vel"][..., 0] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vx_depuis_y_op)
datamap_vx_depuis_y = rt.process(cam_y, surf_qty=True)
map_vx_depuis_y = datamap_vx_depuis_y.map.T / datamap.map.T * factor_vel_km_s
map_vx_depuis_y_red = map_vx_depuis_y[::nbre_fleche, ::nbre_fleche]
Vz_depuis_y_op = ScalarOperator(
lambda dset: dset["vel"][..., 2] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vz_depuis_y_op)
datamap_vz_depuis_y = rt.process(cam_y, surf_qty=True)
map_vz_depuis_y = datamap_vz_depuis_y.map.T / datamap.map.T * factor_vel_km_s
map_vz_depuis_y_red = map_vz_depuis_y[::nbre_fleche, ::nbre_fleche]
plt.figure()
im = plt.imshow(map_col,
extent=[(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au,
(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au],
origin='lower')
plt.xlabel('$z$ (AU)')
plt.ylabel('$x$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_y_' + str(radius_zoom) + '_' +
str(num_output) + '.pdf',
bbox_inches='tight')
nx = map_vx_depuis_y_red.shape[0]
ny = map_vx_depuis_y_red.shape[1]
vec_x = (np.arange(nx) * 2. / nx * radius - radius + center[0] +
radius / nx) * lbox_au
vec_y = (np.arange(ny) * 2. / ny * radius - radius + center[1] +
radius / nx) * lbox_au
xx, yy = np.meshgrid(vec_x, vec_y)
plt.quiver(xx, yy, map_vz_depuis_y_red, map_vx_depuis_y_red)
else:
plt.figure()
im = plt.imshow(map_col,
extent=[(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au,
(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au],
origin='lower',
vmin=vmin_dens,
vmax=vmax_dens)
if sink_plot == True:
for i in range(len(m_sinks)):
if (z_sinks[i] > (-radius + center[2]) * lbox_au) & (
z_sinks[i] <
(radius + center[2]) * lbox_au) & (
x_sinks[i] > (-radius + center[0]) * lbox_au) & (
x_sinks[i] < (radius + center[0]) * lbox_au):
plt.plot(z_sinks[i],
x_sinks[i],
'.',
color=color_sink_colmap,
markersize=size_sinks[i],
alpha=transparence_sink_colmap)
plt.xlabel('$z$ (AU)')
plt.ylabel('$x$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_y_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if v_proj == True:
plt.figure()
norm = MidpointNormalize(
midpoint=0) #Pour avoir le centre de la colormap a 0
plt.imshow(map_Vy,
extent=[(-radius + center[2]) * lbox_au,
(radius + center[2]) * lbox_au,
(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au],
origin='lower',
cmap='RdBu_r',
norm=norm,
vmin=vmin_vel,
vmax=vmax_vel)
if sink_plot == True:
for i in range(len(m_sinks)):
if (z_sinks[i] > (-radius + center[2]) * lbox_au) & (
z_sinks[i] <
(radius + center[2]) * lbox_au) & (
x_sinks[i] > (-radius + center[0]) * lbox_au) & (
x_sinks[i] < (radius + center[0]) * lbox_au):
plt.plot(z_sinks[i],
x_sinks[i],
'.',
color=color_sink_velmap,
markersize=size_sinks[i],
alpha=transparence_sink_velmap)
plt.xlabel('$z$ (AU)')
plt.ylabel('$x$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$v_y \, (km.s^{-1})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'vel_y_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if selon_z == True:
#--------------------------------------------
#Calcul de la carte ou l'on regarde suivant z
#--------------------------------------------
cam_z = Camera(center=center,
line_of_sight_axis='z',
region_size=[2. * radius, 2. * radius],
distance=radius,
far_cut_depth=radius,
up_vector='y',
map_max_size=512)
rho_op = ScalarOperator(lambda dset: dset["rho"],
ro.info["unit_density"])
rt = raytracing.RayTracer(amr, ro.info, rho_op)
datamap = rt.process(cam_z, surf_qty=True)
map_col = np.log10(datamap.map.T * lbox_cm)
if v_proj == True:
Vz_op = ScalarOperator(
lambda dset: dset["vel"][..., 2] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vz_op)
datamap_vz = rt.process(cam_z, surf_qty=True)
map_Vz = datamap_vz.map.T / datamap.map.T * factor_vel_km_s
if fleche_vel == True:
Vx_depuis_z_op = ScalarOperator(
lambda dset: dset["vel"][..., 0] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vx_depuis_z_op)
datamap_vx_depuis_z = rt.process(cam_z, surf_qty=True)
map_vx_depuis_z = datamap_vx_depuis_z.map.T / datamap.map.T * factor_vel_km_s
map_vx_depuis_z_red = map_vx_depuis_z[::nbre_fleche, ::nbre_fleche]
Vy_depuis_z_op = ScalarOperator(
lambda dset: dset["vel"][..., 1] * dset["rho"],
ro.info["unit_velocity"])
rt = raytracing.RayTracer(amr, ro.info, Vy_depuis_z_op)
datamap_vy_depuis_z = rt.process(cam_z, surf_qty=True)
map_vy_depuis_z = datamap_vy_depuis_z.map.T / datamap.map.T * factor_vel_km_s
map_vy_depuis_z_red = map_vy_depuis_z[::nbre_fleche, ::nbre_fleche]
plt.figure()
im = plt.imshow(map_col,
extent=[(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au,
(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au],
origin='lower')
plt.xlabel('$x$ (AU)')
plt.ylabel('$y$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_z_' + str(radius_zoom) + '_' +
str(num_output) + '.pdf',
bbox_inches='tight')
nx = map_vx_depuis_z_red.shape[0]
ny = map_vx_depuis_z_red.shape[1]
vec_x = (np.arange(nx) * 2. / nx * radius - radius + center[0] +
radius / nx) * lbox_au
vec_y = (np.arange(ny) * 2. / ny * radius - radius + center[1] +
radius / nx) * lbox_au
xx, yy = np.meshgrid(vec_x, vec_y)
plt.quiver(xx, yy, map_vx_depuis_z_red, map_vy_depuis_z_red)
else:
plt.figure()
im = plt.imshow(map_col,
extent=[(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au,
(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au],
origin='lower',
vmin=vmin_dens,
vmax=vmax_dens)
if sink_plot == True:
for i in range(len(m_sinks)):
if (x_sinks[i] > (-radius + center[0]) * lbox_au) & (
x_sinks[i] <
(radius + center[0]) * lbox_au) & (
y_sinks[i] > (-radius + center[1]) * lbox_au) & (
y_sinks[i] < (radius + center[1]) * lbox_au):
plt.plot(x_sinks[i],
y_sinks[i],
'.',
color=color_sink_colmap,
markersize=size_sinks[i],
alpha=transparence_sink_colmap)
plt.xlabel('$x$ (AU)')
plt.ylabel('$y$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$log(N) \, \, (cm^{-2})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'dens_z_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if v_proj == True:
plt.figure()
norm = MidpointNormalize(
midpoint=0) #Pour avoir le centre de la colormap a 0
plt.imshow(map_Vz,
extent=[(-radius + center[0]) * lbox_au,
(radius + center[0]) * lbox_au,
(-radius + center[1]) * lbox_au,
(radius + center[1]) * lbox_au],
origin='lower',
cmap='RdBu_r',
norm=norm,
vmin=vmin_vel,
vmax=vmax_vel)
if sink_plot == True:
for i in range(len(m_sinks)):
if (x_sinks[i] > (-radius + center[0]) * lbox_au) & (
x_sinks[i] <
(radius + center[0]) * lbox_au) & (
y_sinks[i] > (-radius + center[1]) * lbox_au) & (
y_sinks[i] < (radius + center[1]) * lbox_au):
plt.plot(x_sinks[i],
y_sinks[i],
'.',
color=color_sink_velmap,
markersize=size_sinks[i],
alpha=transparence_sink_velmap)
plt.xlabel('$x$ (AU)')
plt.ylabel('$y$ (AU)')
cbar = plt.colorbar()
cbar.set_label(r'$v_z \, (km.s^{-1})$')
if title_time == True:
plt.title('Time = ' + str(int(simulation_time)) + ' years')
if title_time_cor == True:
plt.title('Time = ' + str(int(simulation_time)) +
' years \n Corrected time = ' +
str(int(simulation_time - ref[1] * 1e6)) + ' years')
if radius_zoom == 5:
plt.xlim([0, lbox_au])
plt.ylim([0, lbox_au])
if save == True:
plt.savefig(path_save + 'vel_z_' + str(radius_zoom) +
'_%05d' % num_output + '.png',
bbox_inches='tight')
plt.close()
if v_proj == True and reposition_fig == True:
for i in range(3):
i *= 2
for j in range(2):
plt.figure(i + j + 1)
mngr = plt.get_current_fig_manager()
geom = mngr.window.geometry()
x, y, dx, dy = geom.getRect()
mngr.window.setGeometry(1920 / 3 * (i / 2), 1080 / 2 * j, dx,
dy)
plt.figure(1) #Oblige sinon figure 1 mal placee...
mngr = plt.get_current_fig_manager()
geom = mngr.window.geometry()
x, y, dx, dy = geom.getRect()
#mngr.window.setGeometry(65,52,dx,dy)
mngr.window.setGeometry(1, 1, dx, dy)
return
