def plot_avg_vel(
ax,
search_parameters: dict,
scalarMap=None,
logx=True,
data_path: str = "Experiments/Data.nosync/",
yaml_path: str = "Experiments/positive_phi_no_of_clusters",
end_time_step: int = -1,
):
"""Plots average velocity of particles on log scale, colours lines according to
number of clusters in the inital condition
"""
if scalarMap is None:
cm = plt.get_cmap("coolwarm")
cNorm = mpl.colors.DivergingNorm(vmin=0, vcenter=2, vmax=4)
scalarMap = mpl.cm.ScalarMappable(norm=cNorm, cmap=cm)
history = get_master_yaml(yaml_path)
list_of_names = match_parameters(search_parameters, history)
print(list_of_names)
cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"]
for file_name in list_of_names:
simulation_parameters = history[file_name]
t, x, v = load_traj_data(file_name, data_path)
cluster_count = _get_number_of_clusters(
simulation_parameters["initial_dist_x"])
if logx:
ax.semilogx(
t,
v.mean(axis=1),
color=cycle[cluster_count -
1], # simulation_parameters["gamma"]),
label=f"{cluster_count} Clusters",
alpha=0.1,
zorder=1,
)
else:
ax.plot(
t,
v.mean(axis=1),
color=cycle[cluster_count -
1], # simulation_parameters["gamma"]),
label=f"{cluster_count} Clusters",
alpha=0.1,
zorder=1,
)
# plt.tight_layout()
return ax
def plot_convergence_from_clusters(
ax,
search_parameters: dict,
yaml_path: str,
data_path: str = "Experiments/Data.nosync/",
logx=True,
):
history = get_master_yaml(yaml_path)
file_names = match_parameters(search_parameters, history)
cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"]
for file_name in file_names:
print(file_name)
simulation_parameters = history[file_name]
t, x, v = load_traj_data(file_name, data_path)
error = calculate_l1_convergence(t, x, v, plot_hist=False)
cluster_count = _get_number_of_clusters(
simulation_parameters["initial_dist_x"])
print(cluster_count)
cluster_label = f"{cluster_count} cluster{'' if cluster_count==1 else 's'}"
if logx:
ax.semilogx(
t,
error,
label=cluster_label,
color=cycle[cluster_count - 1],
alpha=0.25,
)
else:
ax.plot(
t,
error,
label=cluster_label,
color=cycle[cluster_count - 1],
alpha=0.25,
)
ax.set(xlabel="Time", ylabel=r"$\ell^1$ Error")
handles, labels = ax.get_legend_handles_labels()
# sort both labels and handles by labels
labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
ax.legend(handles, labels)
plt.tight_layout()
return ax
def plot_ODE_solution(data_path: str,
yaml_path: str,
search_parameters: dict = {},
**kwargs):
os.chdir("E:/")
history = processing.get_master_yaml(yaml_path)
fig, ax = plt.subplots()
timestep_range = processing.get_parameter_range("dt", history, **kwargs)
for timestep in timestep_range:
search_parameters["dt"] = timestep
file_names = processing.match_parameters(search_parameters, history,
**kwargs)
for file_name in file_names:
t, x, v = processing.load_traj_data(file_name, data_path)
# print(len(t))
if file_name == file_names[0]:
sum_avg_vel = np.zeros(len(v[:, 0]))
print(file_name)
# sum_avg_vel += v.mean(axis=1)
ax.plot(t, v.mean(axis=1), "r--", alpha=0.1)
def first_moment_ode(t, M):
return G.step(M) - M
sol = solve_ivp(
first_moment_ode,
(t.min(), t.max()),
[v[0].mean()],
t_eval=t.ravel(),
rtol=10**-9,
atol=10**-9,
)
t = sol.t
M = sol.y
ax.plot(t, M.ravel(), label="Numerical Sol")
ax.plot(t, sum_avg_vel / len(file_names))
ax.legend()
plt.show()
return
def phi_one_convergence(time_ax="linear"):
# sns.set(style="white", context="paper")
sns.set_style("ticks")
fig1, ax1 = plt.subplots(figsize=(12, 6))
cm = plt.get_cmap("coolwarm")
cNorm = colors.DivergingNorm(vmin=-25, vcenter=0.0, vmax=25)
scalarMap = mplcm.ScalarMappable(norm=cNorm, cmap=cm)
yaml_path = "./Experiments/phi_one_convergence"
history = get_master_yaml(yaml_path)
file_names = match_parameters({}, history)
dt = 0.01
print(yaml_path)
for file_name in file_names:
x, v = load_traj_data(file_name, data_path="./Experiments/Data/")
t = np.arange(0, len(v) * dt, dt)
if time_ax == "linear":
ax1.plot(
t[:int(20 / dt)],
v[:int(20 / dt)].mean(axis=1),
color=scalarMap.to_rgba(np.sign(v[0].mean()) * v[0].var()),
)
else:
ax1.semilogx(
t[:int(20 / dt)],
v[:int(20 / dt)].mean(axis=1),
color=scalarMap.to_rgba(np.sign(v[0].mean()) * v[0].var()),
)
ax1.plot([0, 20], [1, 1], "k--", alpha=0.25)
ax1.plot([0, 20], [-1, -1], "k--", alpha=0.25)
ax1.set(xlabel="Time", ylabel=r"Average Velocity, $M^N(t)$")
plt.subplots_adjust(top=0.905,
bottom=0.135,
left=0.115,
right=0.925,
hspace=0.2,
wspace=0.2)
plt.show()
return
def avg_vel(
ax,
scalarMap,
file_path: str = "Experiments/Data/",
yaml_path: str = "Experiments/vary_large_gamma_local",
search_parameters: dict = {
"particle_count": 450,
"G": "Step",
"scaling": "Local",
"phi": "Gamma",
"initial_dist_x": "two_clusters_2N_N",
"initial_dist_v": "2N_N_cluster_const",
"T_end": 100,
"dt": 0.01,
},
):
list_of_names = []
print(yaml_path)
history = get_master_yaml(yaml_path)
list_of_names = match_parameters(search_parameters, history)
for file_name in list_of_names:
simulation_parameters = history[file_name]
t, x, v = load_traj_data(file_name, data_path=file_path)
if t is None:
t = np.arange(0,
len(x) * simulation_parameters["dt"],
simulation_parameters["dt"])
if simulation_parameters["gamma"] >= 0.05:
ax.semilogx(
t,
v.mean(axis=1),
color=scalarMap.to_rgba(simulation_parameters["gamma"]),
label="{:.2f}".format(simulation_parameters["gamma"]),
# alpha=0.75,
)
return ax
if not file_names:
print("Skipping...")
continue
metric_store = []
l1_store = []
if len(file_names) > 15:
file_names = file_names[:15]
for file_name in file_names:
simulation_parameters = history[file_name]
cluster_count = _get_number_of_clusters(
simulation_parameters["initial_dist_x"])
colour = cluster_colour[cluster_count - 1]
cluster_label = f"{cluster_count} cluster{'' if cluster_count==1 else 's'}"
t, x, v = load_traj_data(file_name, data_path=data_path)
metric_result = calculate_avg_vel(t, x, v)
l1_result = corrected_calculate_l1_convergence(t, x, v)
metric_store.append(metric_result)
l1_store.append(l1_result)
short_time_ax.plot(
t[:vel_break_time_step],
metric_result[:vel_break_time_step],
label=cluster_label,
color=colour,
alpha=0.1,
zorder=1,
)
if include_traj:
long_time_axes[idx].plot(
# Create colour bar and scale
cm = plt.get_cmap("coolwarm")
cNorm = colors.DivergingNorm(vmin=0, vcenter=0.25, vmax=0.5)
scalarMap = mplcm.ScalarMappable(norm=cNorm, cmap=cm)
# Set tick locations
cbar = fig.colorbar(scalarMap, ticks=np.arange(0, 0.5, 0.05))
# For each matching desired parameters, calculate the l1 error and plot
for diffusion in np.arange(0.05, 0.5, 0.05).tolist():
search_parameters["D"] = diffusion
file_names = match_parameters(search_parameters, history)
first_iter = True
for idx, file_name in enumerate(file_names):
simulation_parameters = history[file_name]
t, x, v = load_traj_data(file_name)
error = calculate_l1_convergence(t,
x,
v,
final_plot_time=final_plot_time)
avg_vel = calculate_avg_vel(t, x, v)
if first_iter:
avg_vel_store = np.zeros((len(file_names), len(avg_vel)))
error_store = np.zeros((len(file_names), len(error)))
first_iter = False
avg_vel_store[idx, :] = avg_vel
error_store[idx, :] = error
# ax1.semilogx(
# t,
# error,
yaml_path = "../Experiments/PSMean0"
history = get_main_yaml(yaml_path)
rc("text", usetex=True)
# fig, ax = plt.subplots(1, 1, figsize=(15, 5), sharex=True)
cm = plt.get_cmap("coolwarm")
cNorm = colors.TwoSlopeNorm(vmin=0.01, vcenter=0.05, vmax=0.25)
scalarMap = mplcm.ScalarMappable(norm=cNorm, cmap=cm)
file_names = match_parameters(search_parameters, history)
os.chdir("D:/InteractingParticleSystems/noisysystem_temp/")
# Path to YAML file relative to current directory
yaml_path = "./Experiments/one_cluster_vary_gamma_50_runs_higher_particles"
for idx, file_name in enumerate(file_names):
print(file_name)
# t, error = calculate_l1_convergence(file_name, plot_hist=False)
t, x, v = load_traj_data(file_name, data_path="Experiments/parquet_data/")
avg_vel = v.mean(axis=1)
if idx == 0:
avg_vel_store = np.zeros((len(file_names), len(avg_vel)))
avg_vel_store[idx, :] = avg_vel
# fig, ax = plt.subplots()
# ax.plot(
# t,
# np.mean(avg_vel_store, axis=0),
# color="k",
# label=f"{history[file_name]['gamma']}",
# alpha=0.8,
# zorder=2,
# )
grid = sns.JointGrid(x=t.flatten(), y=np.mean(avg_vel_store, axis=0))
# }
if os.name == "nt":
# rc("text", usetex=True) # I only have TeX on Windows :(
os.chdir("D:/InteractingParticleSystems/noisysystem_temp")
elif os.name == "posix":
os.chdir(
"/Volumes/Extreme SSD/InteractingParticleSystems/noisysystem_temp")
# Path to YAML file relative to current directory
# yaml_path = "../Experiments/one_cluster_low_gamma_ten_runs"
yaml_path = "./Experiments/OneClusterVaryGammaGlobalGarnierG" # "./Experiments/one_cluster_vary_noise_scale_dt_100_runs_larger_gamma"
data_path = "Experiments/Data.nosync/"
history = get_main_yaml(yaml_path)
file_names = match_parameters(search_parameters, history)
t, x, v = load_traj_data(file_names[0], data_path)
h = search_parameters["alpha"]
xi = 5 * np.sqrt((h - 4) / h)
ani = anim_torus(t.flatten(),
x,
v,
mu_v=xi,
subsample=200,
variance=search_parameters["D"])
# variance=history[file_names[0]]["D"]
plt.show()
# #
# Writer = animation.writers["ffmpeg"]
# writer = Writer(fps=15, bitrate=-1)
def multiple_timescale_plot(
search_parameters,
break_time_step,
metric,
parameter,
parameter_range,
history,
include_traj=False,
data_path="Experiments/Data.nosync/",
):
"""Create figure with plot for beginning dynamics and split into one axis
for each parameter value
Example usage:
fig = multiple_timescale_plot(search_parameters,break_time_step=40,metric=calculate_avg_vel,parameter="D", parameter_range=get_parameter_range("D", history), include_traj=False)
plt.show()
"""
parameter_labels = {
"gamma": r"Interaction $\gamma$",
"D": r"Diffusion $\sigma$",
"dt": "Timestep",
}
metric_labels = {
"calculate_avg_vel": r"Average Velocity $\bar{M}^N(t)$",
"calculate_variance": "Variance",
"calculate_l1_convergence": r"$\ell^1$ Error",
}
expected_error = {
"480": 7.52,
"600": 6.69,
"700": 6.26,
"1000": 5.25,
}
# Create figure and arrange plots
fig = plt.figure(figsize=(12, 4))
grid = plt.GridSpec(len(parameter_range), 3, wspace=0.35, bottom=0.13)
short_time_ax = fig.add_subplot(grid[:, 0])
long_time_axes = []
for idx, elem in enumerate(parameter_range):
try:
long_time_axes.append(
fig.add_subplot(grid[idx, 1:],
sharey=long_time_axes[0],
sharex=long_time_axes[0]))
except IndexError:
long_time_axes.append(fig.add_subplot(grid[idx, 1:]))
if idx != len(parameter_range) - 1:
plt.setp(long_time_axes[idx].get_xticklabels(), visible=False)
# Reverse so that plots line up with colorbar
long_time_axes = long_time_axes[::-1]
# Create colorbar and labels
fig.text(
0.355,
0.48,
metric_labels[metric.__name__],
ha="center",
va="center",
rotation=90,
)
short_time_ax.set(xlabel="Time", ylabel=metric_labels[metric.__name__])
long_time_axes[0].set(xlabel="Time")
cm = plt.get_cmap("coolwarm")
cNorm = colors.BoundaryNorm(parameter_range + [parameter_range[-1]], cm.N)
scalarMap = mplcm.ScalarMappable(norm=cNorm, cmap=cm)
cbar = fig.colorbar(
scalarMap,
use_gridspec=True,
ax=long_time_axes,
ticks=np.array(parameter_range), # + 0.025,
)
cbar.ax.set_yticklabels([f"{x:.2}" for x in parameter_range])
try:
cbar.set_label(parameter_labels[parameter], rotation=270)
except KeyError:
cbar.set_label(parameter, rotation=270)
cbar.ax.get_yaxis().labelpad = 15
# Populate the plots
for idx, parameter_value in enumerate(parameter_range):
search_parameters[parameter] = parameter_value
file_names = match_parameters(search_parameters,
history,
exclude={"dt": [1.0]})
if not file_names:
print("Skipping...")
continue
metric_store = []
for file_name in file_names:
simulation_parameters = history[file_name]
t, x, v = load_traj_data(file_name, data_path=data_path)
metric_result = metric(t, x, v)
metric_store.append(metric_result)
short_time_ax.plot(
t[:break_time_step],
metric_result[:break_time_step],
color=scalarMap.to_rgba(parameter_value),
label=f"{parameter_value}",
alpha=0.1,
zorder=1,
)
if include_traj:
long_time_axes[idx].plot(
t[break_time_step:],
metric_result[break_time_step:],
color=scalarMap.to_rgba(parameter_value),
label=f"{parameter_value}",
alpha=0.05,
zorder=1,
)
metric_store = np.array(metric_store)
long_time_axes[idx].plot(
t[break_time_step:],
metric_store.mean(axis=0)[break_time_step:],
color=scalarMap.to_rgba(parameter_value),
label=f"{parameter_value}",
alpha=1,
zorder=2,
)
if metric == calculate_avg_vel:
long_time_axes[idx].plot(
[t[break_time_step], t[-1]],
[np.sign(metric_result[0]),
np.sign(metric_result[0])],
"k--",
alpha=0.25,
)
elif metric == calculate_l1_convergence:
long_time_axes[idx].plot(
[t[break_time_step], t[-1]],
[
expected_error[str(
simulation_parameters["particle_count"])],
expected_error[str(
simulation_parameters["particle_count"])],
],
"k--",
alpha=0.25,
)
elif metric == calculate_variance:
long_time_axes[idx].plot(
[t[break_time_step], t[-1]],
[simulation_parameters["D"], simulation_parameters["D"]],
"k--",
alpha=0.25,
)
return fig
def plot_averaged_convergence_from_clusters(ax,
search_parameters: dict,
yaml_path: str,
data_path: str,
logx=True):
history = get_master_yaml(yaml_path)
for initial_dist_x in [
"one_cluster",
"two_clusters",
"three_clusters",
"four_clusters",
]:
search_parameters["initial_dist_x"] = initial_dist_x
file_names = match_parameters(search_parameters, history)
cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"]
for idx, file_name in enumerate(file_names):
print(file_name)
simulation_parameters = history[file_name]
cluster_count = _get_number_of_clusters(
simulation_parameters["initial_dist_x"])
cluster_label = f"{cluster_count} cluster{'' if cluster_count==1 else 's'}"
if idx == 0:
t, x, v = load_traj_data(file_name, data_path)
t = t.flatten()
error = calculate_l1_convergence(t[t <= 10],
x[t <= 10],
v[t <= 10],
plot_hist=False)
error_store = np.zeros((len(file_names), len(error)))
error_store[idx, :] = error
else:
t, x, v = load_traj_data(file_name, data_path)
t = t.flatten()
error = calculate_l1_convergence(t[t <= 10],
x[t <= 10],
v[t <= 10],
plot_hist=False)
error_store[idx, :] = error
if logx:
t = t[t <= 10]
ax.semilogx(
t,
np.mean(error_store, axis=0),
label=cluster_label,
color=cycle[cluster_count - 1],
)
else:
t = t[t <= 10]
ax.plot(
t,
np.mean(error_store, axis=0),
label=cluster_label,
color=cycle[cluster_count - 1],
)
# ax.plot(
# t[9:], moving_average(np.mean(error_store, axis=0), n=10), "r",
# )
ax.set(xlabel="Time", ylabel=r"$\ell^1$ Error")
handles, labels = ax.get_legend_handles_labels()
# sort both labels and handles by labels
labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
ax.legend(handles, labels)
plt.tight_layout()
return ax
def plot_averaged_avg_vel(
ax,
search_parameters: dict,
logx=True,
include_traj=True,
scalarMap=None,
data_path: str = "Experiments/Data.nosync/",
yaml_path: str = "Experiments/positive_phi_no_of_clusters",
start_time_step: int = 0,
end_time_step: int = -1,
):
"""Plots average velocity of particles on log scale, colours lines according to
number of clusters in the inital condition
"""
if scalarMap is None:
cm = plt.get_cmap("coolwarm")
cNorm = mpl.colors.DivergingNorm(vmin=1, vcenter=2, vmax=4)
scalarMap = mpl.cm.ScalarMappable(norm=cNorm, cmap=cm)
history = get_master_yaml(yaml_path)
# for initial_dist_x in [
# "one_cluster",
# "two_clusters",
# "three_clusters",
# "four_clusters",
# ]:
# search_parameters["initial_dist_x"] = initial_dist_x
list_of_names = match_parameters(search_parameters, history)
# print(list_of_names)
cycle = plt.rcParams["axes.prop_cycle"].by_key()["color"]
for idx, file_name in enumerate(list_of_names):
simulation_parameters = history[file_name]
cluster_count = _get_number_of_clusters(
simulation_parameters["initial_dist_x"])
cluster_label = f"{cluster_count} cluster{'' if cluster_count==1 else 's'}"
t, x, v = load_traj_data(file_name, data_path)
t = t[start_time_step:end_time_step]
v = v[start_time_step:end_time_step]
avg_vel = v.mean(axis=1)
cluster_count = _get_number_of_clusters(
history[file_name]["initial_dist_x"])
if include_traj and logx:
ax.semilogx(t,
avg_vel,
color=cycle[cluster_count - 1],
alpha=0.1,
zorder=1)
if include_traj and not logx:
ax.plot(t,
avg_vel,
color=cycle[cluster_count - 1],
alpha=0.1,
zorder=1)
if idx == 0:
avg_vel_store = np.zeros((len(list_of_names), len(avg_vel)))
avg_vel_store[idx, :] = avg_vel
if logx:
ax.semilogx(
t,
np.mean(avg_vel_store, axis=0),
color=cycle[cluster_count - 1], # history[file_name]["gamma"]),
label=cluster_label,
# alpha=0.5,
zorder=2,
)
else:
ax.plot(
t,
np.mean(avg_vel_store, axis=0),
color=cycle[cluster_count - 1], # history[file_name]["gamma"]),
label=cluster_label,
# alpha=0.5,
zorder=2,
)
# plt.tight_layout()
return ax
simulation_parameters = history[file_name]
t, error = calculate_l1_convergence(
file_name,
plot_hist=False,
yaml_path=yaml_path,
data_path=data_path,
final_plot_time=final_plot_time,
)
ax.semilogx(
t,
error,
color=scalarMap.to_rgba(simulation_parameters["D"]),
label=f"{simulation_parameters['D']}",
alpha=0.5,
)
if simulation_parameters["D"] == 0.05:
_t = load_traj_data(file_name, data_path)
ax.plot([0, _t[-1]], [7.5, 7.5], "k--", alpha=0.2)
ax.set(xlabel="Time", ylabel=r"$\ell^1$ Error")
cbar.set_label(r"Diffusion $\sigma$", rotation=270)
cbar.ax.get_yaxis().labelpad = 15
plt.tight_layout()
# plt.show()
# ani = anim_torus(_t, _x, _v, subsample=50)
plt.show()
# fig.savefig(f"OneClusterVaryNoiselargerGamma.jpg", dpi=300)
gammas = get_parameter_range("gamma", history)
# np.array([0.25]) # np.arange(0.05, 0.15, 0.05)
# np.concatenate(([0.01], np.arange(0.05, 0.3, 0.05)))
# np.arange(0.01, 0.3, 0.05)
# np.concatenate(
# ([0.01], np.arange(0.05, 0.2, 0.05))
# )
for gamma in gammas:
search_parameters["gamma"] = gamma
file_names = match_parameters(search_parameters, history)
for idx, file_name in enumerate(file_names):
print(file_name)
t, x, v = load_traj_data(file_name,
data_path="Experiments/Data.nosync/")
error = calculate_l1_convergence(t, x, v)
avg_vel = calculate_avg_vel(t, x, v)
if idx == 0:
avg_vel_store = np.zeros((len(file_names), len(avg_vel)))
error_store = np.zeros((len(file_names), len(error)))
ax1.plot(
t,
error,
color=scalarMap.to_rgba(history[file_name]["gamma"]),
label=f"{history[file_name]['gamma']}",
alpha=0.1,
zorder=1,
)
ax2.plot(
t,