{ "cells": [ { "cell_type": "markdown", "id": "086f9d1b", "metadata": {}, "source": [ "Copyright 2025 Marc Kamionkowski and Kris Sigurdson.\n", "Licensed under Apache-2.0 (http://www.apache.org/licenses/LICENSE-2.0).\n", "\n", "This notebook provides some simple python scripts to make plots and movies from the output of NSphere-SIDM. \n", "\n", "The scripts use data produced by `nsphere --sidm --ntimesteps 12500000 --dtwrite 25000 --nout 250 --tfinal 1100 --sort 3` (the parameters used for the plots in the paper). This is then run with 100000 particles, the default halo profile, an NFW profile with scale radius $r_s = 1.18$ kpc, mass $= 1.15 \\times 10^{-9}$ M$_\\odot$, and a large-radius cutoff function $[1+(r/r_{\\text{vir}})^{10}]^{-1}$ with $r_{\\text{vir}} = 19$ (concentration parameter). The SIDM cross section (per unit mass) is isotropic and velocity-independent, and taken to be 50 cm$^2$/g. All of these can be changed using command line options, run `nsphere --help` for more information.\n", "\n", "The jupyter notebook is set up to be run from the NSphere-SIDM directory. It was run with Python 3.12.4" ] }, { "cell_type": "markdown", "id": "e55c1626", "metadata": {}, "source": [ "## SIDM Core Collapse Analysis, Visualization and Plots" ] }, { "cell_type": "code", "execution_count": 1, "id": "bbf95eff", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using 154 x 153 bins\n", "Histogram data shape: (251, 154, 153)\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Import necessary libraries\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter # 2D smoothing filter\n", "from IPython.display import HTML\n", "from matplotlib.colors import PowerNorm\n", "import os\n", "\n", "# Define the path to the data files and the time steps\n", "# Adjust the path to your data files as necessary\n", "\n", "path_template = \"../data/Rank_Mass_Rad_VRad_unsorted_t00{timestep:03d}_100000_12500001_1100.dat\"\n", "time_steps = range(0, 501, 2) # Time steps (251 snapshots from 0 to 500)\n", "\n", "# Convert time steps to actual time in Gyr\n", "time_in_gyr = [19.605 * t / 500 for t in time_steps]\n", "\n", "# Define bin edges for radius (R) and radial velocity (Vrad)\n", "# Fine-tuned for optimal resolution while staying under 20MB limit\n", "bin_edges_R = np.arange(0, 10, 10/154) # 154 bins\n", "bin_edges_V = np.arange(-50, 50, 100/154) # 154 bins\n", "\n", "print(f\"Using {len(bin_edges_R)-1} x {len(bin_edges_V)-1} bins\")\n", "\n", "# Define the record dtype (as in your original code)\n", "record_dtype = np.dtype([\n", " ('rank', np.int32),\n", " ('mass', np.float32),\n", " ('R', np.float32),\n", " ('Vrad', np.float32),\n", " ('PsiA', np.float32),\n", " ('E', np.float32),\n", " ('L', np.float32)\n", "])\n", "\n", "# Storage for 2D histograms\n", "all_histograms = []\n", "\n", "# Loop over time steps and process each file\n", "for time_step in time_steps:\n", " file_path = path_template.format(timestep=time_step)\n", " try:\n", " # Read the binary file\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " # Extract radius and radial velocity data\n", " data_R = alldata['R']\n", " data_Vrad = alldata['Vrad']/1.023e-3 # Convert to km/s\n", " \n", " if np.isnan(data_R).any() or np.isnan(data_Vrad).any():\n", " print(f\"Warning: NaN values found in file at time step {time_step}\")\n", " if not (np.isfinite(data_R).all() and np.isfinite(data_Vrad).all()):\n", " print(f\"Warning: Non-finite values found in file at time step {time_step}\")\n", " \n", " # Compute 2D histogram: counts for each (R, Vrad) bin\n", " hist, _, _ = np.histogram2d(data_R, data_Vrad, bins=[bin_edges_R, bin_edges_V])\n", " \n", " # Optionally, apply 2D Gaussian smoothing\n", " # Adjust sigma=(sigma_R, sigma_V) as appropriate\n", " smoothed_hist = gaussian_filter(hist, sigma=(0.1, 0.1))\n", " \n", " # Optionally, you could apply a normalization/scaling here if desired\n", " \n", " all_histograms.append(smoothed_hist)\n", " except Exception as e:\n", " print(f\"Error reading file {file_path}: {e}\")\n", " # Append a zero histogram if file is missing or cannot be read\n", " all_histograms.append(np.zeros((len(bin_edges_R)-1, len(bin_edges_V)-1)))\n", "\n", "# Convert list to numpy array for easier handling\n", "all_histograms = np.array(all_histograms)\n", "print(\"Histogram data shape:\", all_histograms.shape) # (time_steps, n_R_bins, n_V_bins)\n", "\n", "# Determine common color scale for the animation\n", "vmin = 0\n", "vmax = np.max(all_histograms) # Use data maximum across all frames\n", "\n", "# Create the animation with power-law color scaling\n", "fig, ax = plt.subplots(figsize=(8, 6))\n", "# Note: We transpose the histogram so that the horizontal axis corresponds to R and vertical to Vrad.\n", "# Use PowerNorm with gamma=1/4 for x^(1/4) scaling\n", "# Use 'hot' colormap for better distinction of high-density regions (black->red->yellow->white)\n", "im = ax.imshow(all_histograms[0].T, origin='lower',\n", " extent=[bin_edges_R[0], bin_edges_R[-1], bin_edges_V[0], bin_edges_V[-1]],\n", " aspect='auto', cmap='viridis', norm=PowerNorm(gamma=3/4, vmin=vmin, vmax=vmax))\n", "\n", "ax.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\")\n", "ax.set_ylabel(r\"$v_r\\;\\;$[$\\mathrm{km}/\\mathrm{s}$]\")\n", "ax.set_title(r\"$t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % time_in_gyr[0])\n", "fig.colorbar(im, ax=ax, label=r\"Counts per bin\")\n", "\n", "def update(frame):\n", " im.set_data(all_histograms[frame].T) # update image data\n", " ax.set_title(r\"$t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % time_in_gyr[frame])\n", " return im,\n", "\n", "ani = FuncAnimation(fig, update, frames=len(time_steps), repeat=True, interval=200, blit=True)\n", "\n", "# Uncomment to show initial static image\n", "# plt.show()\n", "\n", "# Uncomment this line to save the animation as a GIF\n", "# ani.save(\"results/phasespace.gif\", writer=\"pillow\", fps=10)\n", "\n", "# Close the figure to prevent static display\n", "plt.close(fig)\n", "\n", "# For displaying in a Jupyter Notebook:\n", "HTML(ani.to_jshtml())" ] }, { "cell_type": "code", "execution_count": 2, "id": "7eccfcc4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Core region using 29 x 29 bins\n", "Time range: 12.4 to 16.4 Gyr (52 frames)\n", "Core histogram data shape: (52, 29, 29)\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "### SECOND ANIMATION: CORE REGION DURING LATE EVOLUTION (12.4-16.4 Gyr)\n", "\n", "# Import necessary libraries (if not already imported)\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter\n", "from IPython.display import HTML\n", "from matplotlib.colors import PowerNorm\n", "\n", "# Define focused ranges for core region analysis with square bin grid\n", "core_bin_edges_R = np.arange(0, 0.5, 0.5/30) # 30 bins from 0 to 0.5 kpc (0.0167 kpc per bin)\n", "core_bin_edges_V = np.arange(-30, 30, 60/30) # 30 bins from -30 to +30 km/s (2.0 km/s per bin)\n", "\n", "print(f\"Core region using {len(core_bin_edges_R)-1} x {len(core_bin_edges_V)-1} bins\")\n", "\n", "# Select time range from 12.4 to 16.4 Gyr to focus on peak core collapse phase\n", "# time_in_gyr = 19.605 * t / 500, so for 12.4 Gyr: t ≈ 316, for 16.4 Gyr: t ≈ 418\n", "# Since time_steps = range(0, 501, 2), we need frame indices:\n", "start_frame_idx = 158 # corresponds to time_step 316 (12.4 Gyr)\n", "end_frame_idx = 209 # corresponds to time_step 418 (16.4 Gyr)\n", "\n", "core_time_steps = list(range(start_frame_idx, end_frame_idx + 1))\n", "core_time_in_gyr = [time_in_gyr[i] for i in core_time_steps]\n", "\n", "print(f\"Time range: {core_time_in_gyr[0]:.1f} to {core_time_in_gyr[-1]:.1f} Gyr ({len(core_time_steps)} frames)\")\n", "\n", "# Storage for core region 2D histograms (30x30 bins for balanced resolution)\n", "core_histograms = []\n", "\n", "# Process the selected time range focusing on peak core collapse period\n", "for frame_idx in core_time_steps:\n", " time_step = time_steps[frame_idx]\n", " file_path = path_template.format(timestep=time_step)\n", " \n", " try:\n", " # Read the binary file\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " # Extract radius and radial velocity data\n", " data_R = alldata['R']\n", " data_Vrad = alldata['Vrad']/1.023e-3 # Convert to km/s\n", " \n", " # Filter data to core region (r ≤ 0.5 kpc, |v_r| ≤ 30 km/s)\n", " core_mask = (data_R <= 0.5) & (data_Vrad >= -30) & (data_Vrad <= 30)\n", " core_R = data_R[core_mask]\n", " core_Vrad = data_Vrad[core_mask]\n", " \n", " # Compute 2D histogram for core region with square bin grid\n", " hist, _, _ = np.histogram2d(core_R, core_Vrad, bins=[core_bin_edges_R, core_bin_edges_V])\n", " \n", " # Apply 2D Gaussian smoothing for noise reduction\n", " smoothed_hist = gaussian_filter(hist, sigma=(0.5, 0.5))\n", " \n", " core_histograms.append(smoothed_hist)\n", " \n", " except Exception as e:\n", " print(f\"Error reading file {file_path}: {e}\")\n", " # Append a zero histogram if file is missing or cannot be read\n", " core_histograms.append(np.zeros((len(core_bin_edges_R)-1, len(core_bin_edges_V)-1)))\n", "\n", "# Convert to numpy array for efficient processing\n", "core_histograms = np.array(core_histograms)\n", "print(\"Core histogram data shape:\", core_histograms.shape) # (52 frames, 30 R-bins, 30 V-bins)\n", "\n", "# Determine color scale for core animation using data maximum across all frames\n", "core_vmin = 0\n", "core_vmax = np.max(core_histograms)\n", "\n", "# Create the core region animation with square bin grid\n", "fig_core, ax_core = plt.subplots(figsize=(8, 6))\n", "\n", "# Initial plot for core region (12.4-16.4 Gyr evolution)\n", "im_core = ax_core.imshow(core_histograms[0].T, origin='lower',\n", " extent=[core_bin_edges_R[0], core_bin_edges_R[-1], \n", " core_bin_edges_V[0], core_bin_edges_V[-1]],\n", " aspect='auto', cmap='hot', \n", " norm=PowerNorm(gamma=5/3, vmin=core_vmin, vmax=core_vmax))\n", "\n", "ax_core.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\")\n", "ax_core.set_ylabel(r\"$v_r\\;\\;$[$\\mathrm{km}/\\mathrm{s}$]\")\n", "ax_core.set_title(r\"Core Region: $t = %.1f\\;\\;$[$\\mathrm{Gyr}$]\" % core_time_in_gyr[0])\n", "fig_core.colorbar(im_core, ax=ax_core, label=r\"Counts per bin\")\n", "\n", "def update_core(frame):\n", " im_core.set_data(core_histograms[frame].T)\n", " ax_core.set_title(r\"Core Region: $t = %.1f\\;\\;$[$\\mathrm{Gyr}$]\" % core_time_in_gyr[frame])\n", " return im_core,\n", "\n", "# Create animation with 15fps for smooth viewing of peak core collapse\n", "ani_core = FuncAnimation(fig_core, update_core, frames=len(core_time_steps), \n", " repeat=True, interval=66.67, blit=True) # 66.67ms -> 15fps\n", "\n", "# Uncomment to show initial static image\n", "# plt.show()\n", "\n", "# Close the figure to prevent static display\n", "plt.close(fig_core)\n", "\n", "# Display the core animation focusing on 12.4-16.4 Gyr peak collapse period\n", "HTML(ani_core.to_jshtml())" ] }, { "cell_type": "code", "execution_count": 3, "id": "194902f6", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "###### THIS CELL MAKES AN ANIMATION OF THE EVOLUTION OF THE RADIAL NUMBER DISTRIBUTION\n", "\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter1d\n", "from IPython.display import HTML\n", "\n", "\n", "bin_edges = np.arange(0, 10, 0.02) # Bin edges for radii between 0 and 10\n", "bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2 # Calculate bin centers\n", "\n", "# Storage for smoothed histograms\n", "all_smoothed_counts = []\n", "\n", "record_dtype = np.dtype([\n", " ('rank', np.int32),\n", " ('mass', np.float32),\n", " ('R', np.float32),\n", " ('Vrad', np.float32),\n", " ('PsiA', np.float32),\n", " ('E', np.float32),\n", " ('L', np.float32)\n", "])\n", "\n", "# Process each file\n", "for time_step in time_steps:\n", " file_path = path_template.format(timestep=time_step)\n", " try:\n", " # Read the first column (radii)\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " data = alldata['R']\n", "\n", " if np.isnan(data).any():\n", " print(f\"Warning: NaN values found in data at Time Step: {time_step}\")\n", " if not np.isfinite(data).all():\n", " print(f\"Warning: Infinite values found in data at Time Step: {time_step}\")\n", " \n", " # Count particles in bins\n", " counts, _ = np.histogram(data, bins=bin_edges)\n", " # Smooth the counts using a Gaussian filter\n", " smoothed_counts = gaussian_filter1d(counts, sigma=1)\n", " all_smoothed_counts.append(smoothed_counts)\n", " except Exception as e:\n", " print(f\"Error reading file {file_path}: {e}\")\n", " all_smoothed_counts.append(np.zeros(len(bin_centers))) # Append zeros if file is missing\n", "\n", "# Convert to numpy array for easier handling\n", "all_smoothed_counts = np.array(all_smoothed_counts)\n", "\n", "# Create animation\n", "fig, ax = plt.subplots()\n", "line, = ax.plot(bin_centers, all_smoothed_counts[0], color=\"blue\")\n", "\n", "\n", "ax.set_xlim(0, 10) # Lower limit is > 0\n", "ax.set_ylim(0, 500) # Lower limit is > 0\n", "\n", "ax.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\")\n", "ax.set_ylabel(r\"$N\\;\\;$[particles per bin]\")\n", "ax.set_title(r\"$N(r)$ at $t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % time_in_gyr[0])\n", "\n", "def update(frame):\n", " line.set_ydata(all_smoothed_counts[frame]) # Update the y-data for the line\n", " ax.set_title(r\"$N(r)$ at $t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % time_in_gyr[frame])\n", " return line,\n", "\n", "ani = FuncAnimation(fig, update, frames=len(time_steps), repeat=True, interval=200)\n", "\n", "# Uncomment to show initial static image\n", "# plt.show()\n", "\n", "# Uncomment this line to save the animation as a GIF\n", "# ani.save(\"results/number.gif\", writer=\"pillow\", fps=10)\n", "\n", "# Close the figure to prevent static display\n", "plt.close(fig)\n", "\n", "HTML(ani.to_jshtml())" ] }, { "cell_type": "code", "execution_count": 4, "id": "765bc4ba", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing files...\n", "Finished processing. Processed data for 251 time steps.\n", "Generating and saving plots...\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## THIS CELL PLOTS THE EVOLUTION OF THE PARTICLE NUMBER AND MEAN SQUARE VELOCITY IN THE LOWEST RADIUS BINS\n", "\n", "## Uncomment the \"plt.savefig\" lines to save the plots as PDF files\n", "\n", "# Import necessary libraries\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter1d\n", "import os\n", "\n", "# --- Configuration ---\n", "\n", "bin_edges = np.arange(0, 2, 0.02) # Bin edges for radii\n", "smoothing_sigma = 0.001 # Sigma for Gaussian smoothing of counts\n", "num_lowest_bins_to_sum = 10 # How many lowest bins for summed count and MSV plots\n", "\n", "# Check if base data directory exists\n", "if not os.path.exists(os.path.dirname(path_template)):\n", " print(f\"Warning: Base directory {os.path.dirname(path_template)} does not exist. Please check the path.\")\n", "\n", "# Calculate bin centers and prepare labels\n", "bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2\n", "if len(bin_centers) < num_lowest_bins_to_sum:\n", " raise ValueError(f\"Requested sum/MSV of {num_lowest_bins_to_sum} bins, but only {len(bin_centers)} bins are defined.\")\n", "\n", "lowest_bin_range_str = f\"[{bin_edges[0]}, {bin_edges[1]})\"\n", "sum_bins_range_str = f\"[{bin_edges[0]}, {bin_edges[num_lowest_bins_to_sum]})\"\n", "\n", "# --- Storage ---\n", "all_smoothed_counts = []\n", "lowest_bin_counts = [] # Smoothed count in bin 1\n", "sum_lowest_n_bins_counts = [] # Smoothed count sum in bins 1 to N\n", "msv_bin1_list = [] # Mean Square Velocity in bin 1\n", "msv_bins1_n_list = [] # Mean Square Velocity in bins 1 to N\n", "actual_time_steps = [] # Time steps with successfully processed data\n", "\n", "record_dtype = np.dtype([\n", " ('rank', np.int32),\n", " ('mass', np.float32),\n", " ('R', np.float32), # Radius\n", " ('Vrad', np.float32), # Radial Velocity\n", " ('PsiA', np.float32),\n", " ('E', np.float32),\n", " ('L', np.float32)\n", "])\n", "\n", "# --- Process each file ---\n", "print(\"Processing files...\")\n", "for time_step in time_steps:\n", " file_path = path_template.format(timestep=time_step)\n", " try:\n", " if not os.path.exists(file_path):\n", " print(f\"File not found: {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " if alldata.size == 0:\n", " print(f\"Warning: File is empty {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " # Extract Radius and Radial Velocity\n", " radii = alldata['R']\n", " vrad = alldata['Vrad']\n", "\n", " # Check for NaNs/Infs in essential data\n", " # Note: np.histogram handles NaNs in input, but mean calculation doesn't easily\n", " valid_data_mask = np.isfinite(radii) & np.isfinite(vrad)\n", " if not np.all(valid_data_mask):\n", " print(f\"Warning: Non-finite R or Vrad values found at Time Step: {time_step}. Filtering them out for calculations.\")\n", " radii = radii[valid_data_mask]\n", " vrad = vrad[valid_data_mask]\n", " if radii.size == 0:\n", " print(f\"Warning: No finite data remaining after filtering at Time Step: {time_step}. Skipping step.\")\n", " continue # Skip if no valid data left\n", "\n", " # 1. Histogram and Smoothed Counts\n", " counts, _ = np.histogram(radii, bins=bin_edges)\n", " smoothed_counts = gaussian_filter1d(counts, sigma=smoothing_sigma)\n", "\n", " # Store count data\n", " all_smoothed_counts.append(smoothed_counts)\n", " lowest_bin_counts.append(smoothed_counts[0])\n", " sum_n_bins = np.sum(smoothed_counts[0:num_lowest_bins_to_sum])\n", " sum_lowest_n_bins_counts.append(sum_n_bins)\n", "\n", " # 2. Mean Square Velocity Calculations\n", " # Digitize particles into bins. `digitize` returns index i if bin_edges[i-1] <= x < bin_edges[i]\n", " # So, index 1 corresponds to the first bin [bin_edges[0], bin_edges[1])\n", " bin_indices = np.digitize(radii, bin_edges, right=False)\n", "\n", " # MSV for the first bin (index == 1)\n", " mask_bin1 = (bin_indices == 1)\n", " vrad_bin1 = vrad[mask_bin1]\n", " if vrad_bin1.size > 0:\n", " msv_bin1 = np.mean(vrad_bin1**2)\n", " else:\n", " msv_bin1 = np.nan # Use NaN if bin is empty\n", "\n", " # MSV for the first N bins (index between 1 and N, inclusive)\n", " mask_bins1_n = (bin_indices >= 1) & (bin_indices <= num_lowest_bins_to_sum)\n", " vrad_bins1_n = vrad[mask_bins1_n]\n", " if vrad_bins1_n.size > 0:\n", " msv_bins1_n = 3.0 * np.mean(vrad_bins1_n**2)/1.023e-3**2 # Convert to (km/s)^2\n", " else:\n", " msv_bins1_n = np.nan # Use NaN if bins are empty\n", "\n", " msv_bin1_list.append(msv_bin1)\n", " msv_bins1_n_list.append(msv_bins1_n)\n", "\n", " # If all calculations successful, record the time step\n", " actual_time_steps.append(time_step)\n", "\n", " except Exception as e:\n", " print(f\"Error reading or processing file {file_path}: {e}\")\n", " # Remove potentially partially added data for this step if error occurred mid-processing\n", " if len(actual_time_steps) < len(lowest_bin_counts): lowest_bin_counts.pop()\n", " if len(actual_time_steps) < len(sum_lowest_n_bins_counts): sum_lowest_n_bins_counts.pop()\n", " if len(actual_time_steps) < len(msv_bin1_list): msv_bin1_list.pop()\n", " if len(actual_time_steps) < len(msv_bins1_n_list): msv_bins1_n_list.pop()\n", " if len(actual_time_steps) < len(all_smoothed_counts): all_smoothed_counts.pop()\n", "\n", "\n", "print(f\"Finished processing. Processed data for {len(actual_time_steps)} time steps.\")\n", "\n", "# --- Generate and Save Static Plots ---\n", "actual_time_steps1 = 19.605 /500 * np.array(actual_time_steps) # for 500 time steps\n", "\n", "if actual_time_steps: # Proceed only if some data was processed\n", " print(\"Generating and saving plots...\")\n", "\n", " lowest_bin_counts = np.array(lowest_bin_counts)\n", "\n", " # Plot 1: Lowest Bin Count Evolution\n", " fig1, ax1 = plt.subplots(figsize=(10, 6))\n", " ax1.plot(actual_time_steps1, 15*lowest_bin_counts, marker='.', linestyle='-', color='blue', label = r'$r<0.02\\;\\mathrm{kpc}\\;\\;$[$\\times 15$]')\n", " ax1.plot(actual_time_steps1, sum_lowest_n_bins_counts, marker='.', linestyle='-', color='green',label = r'$r<0.2\\;\\mathrm{kpc}$')\n", " ax1.set_xlabel(r\"$t\\;\\;$[$\\mathrm{Gyr}$]\", fontsize=16)\n", " ax1.set_ylabel(r\"$N$\", fontsize=16)\n", " ax1.legend(fontsize=14,loc='best')\n", " ax1.set_xlim(0, 18) # Set x-axis limit to 0-18 Gyr\n", " plt.tick_params(axis='both', which='major', labelsize=14) # Change font size for major ticks\n", " plt.tick_params(axis='both', which='minor', labelsize=10) # Change font size for minor ticks \n", " ax1.grid(True)\n", " plt.tight_layout()\n", " plt.savefig(\"fig2_particle_count_evolution.pdf\")\n", "\n", " # Plot 2: Mean Square Velocity in Lowest N Bins\n", " fig4, ax4 = plt.subplots(figsize=(10, 6))\n", " ax4.plot(actual_time_steps1, msv_bins1_n_list, marker='.', linestyle='-', color='green')\n", " ax4.set_xlabel(r\"$t\\;\\;$[$\\mathrm{Gyr}$]\", fontsize=16)\n", " ax4.set_ylabel(r'$\\langle v_r^2 \\rangle\\;\\;\\;$[$(\\mathrm{km}/\\mathrm{s})^2$] at $r<0.2\\;\\mathrm{kpc}$', fontsize=16)\n", " plt.tick_params(axis='both', which='major', labelsize=14) # Change font size for major ticks\n", " plt.tick_params(axis='both', which='minor', labelsize=10) # Change font size for minor ticks\n", " ax4.grid(True)\n", " ax4.set_xlim(0, 18) # Set x-axis limit to 0-18 Gyr\n", " plt.tight_layout()\n", " plt.savefig(\"fig3_radial_velocity_dispersion.pdf\")\n", "\n", "else:\n", " print(\"No data was successfully processed. Cannot generate plots.\")" ] }, { "cell_type": "code", "execution_count": 5, "id": "3849822b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing files...\n", "Finished processing. Processed data for 251 time steps.\n", "Generating density animation...\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "### THIS CELL MAKES AN ANIMATION OF THE EVOLUTION OF THE DENSITY DISTRIBUTION\n", "\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter1d\n", "from IPython.display import HTML\n", "import os\n", "\n", "# --- Configuration ---\n", "\n", "# == Parameters for Density Animation (Log Bins) ==\n", "density_num_bins = 10 # Number of bins for the density plot\n", "density_min_radius = 0.02\n", "density_max_radius = 2.0\n", "log_bin_edges = np.logspace(np.log10(density_min_radius),\n", " np.log10(density_max_radius),\n", " density_num_bins + 1)\n", "# Calculate geometric bin centers and linear bin widths for log bins\n", "log_bin_centers = np.sqrt(log_bin_edges[:-1] * log_bin_edges[1:])\n", "log_bin_widths = np.diff(log_bin_edges)\n", "\n", "# --- Storage ---\n", "# For density animation\n", "all_densities = []\n", "all_density_errors = []\n", "# Common\n", "actual_time_steps = []\n", "\n", "record_dtype = np.dtype([\n", " ('rank', np.int32),\n", " ('mass', np.float32),\n", " ('R', np.float32), # Radius\n", " ('Vrad', np.float32), # Radial Velocity\n", " ('PsiA', np.float32),\n", " ('E', np.float32),\n", " ('L', np.float32)\n", "])\n", "\n", "# --- Process each file ---\n", "print(\"Processing files...\")\n", "for time_step in time_steps:\n", " file_path = path_template.format(timestep=time_step)\n", " try:\n", " if not os.path.exists(file_path):\n", " print(f\"File not found: {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " if alldata.size == 0:\n", " print(f\"Warning: File is empty {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " radii = alldata['R']\n", "\n", " # Filter radii specifically for the density plot range\n", " radii_for_density = radii[(radii >= density_min_radius) & (radii <= density_max_radius)]\n", "\n", " counts_log, _ = np.histogram(radii_for_density, bins=log_bin_edges)\n", "\n", " # Calculate density: N / (4*pi*R^2 * ΔR)\n", " # Avoid division by zero if counts are zero\n", " # Use np.divide with where clause for safety, although R^2 and width shouldn't be zero here.\n", " denominator = 4.0 * np.pi * (log_bin_centers**2) * log_bin_widths\n", " density = np.divide(counts_log, denominator, out=np.zeros_like(denominator, dtype=float), where=denominator!=0)\n", " density_errors = np.divide(np.sqrt(counts_log), denominator, out=np.zeros_like(denominator, dtype=float), where=denominator!=0)\n", " all_densities.append(density)\n", " all_density_errors.append(density_errors)\n", " # --- Record successful timestep ---\n", " actual_time_steps.append(time_step)\n", "\n", " except Exception as e:\n", " print(f\"Error reading or processing file {file_path} at timestep {time_step}: {e}\")\n", " if len(actual_time_steps) < len(all_densities): all_densities.pop()\n", " if len(actual_time_steps) < len(all_density_errors): all_density_errors.pop()\n", "\n", "\n", "print(f\"Finished processing. Processed data for {len(actual_time_steps)} time steps.\")\n", "\n", "# Convert actual time steps to time in Gyr\n", "actual_time_in_gyr = [19.605 * t / 500 for t in actual_time_steps]\n", "\n", "# Convert density list to numpy array for easier handling\n", "all_densities_np = np.array(all_densities)\n", "all_density_errors_np = np.array(all_density_errors)\n", "\n", "\n", "\n", "# --- Create Density Animation ---\n", "if all_densities_np.size > 0:\n", " print(\"Generating density animation...\")\n", "\n", " fig_density, ax_density = plt.subplots(figsize=(8, 6))\n", "\n", " # Initial plot using the first frame's data\n", " ax_density.errorbar(\n", " log_bin_centers, all_densities_np[0], yerr=all_density_errors_np[0], \n", " fmt='o', markersize=3, linestyle='None', color=\"teal\", ecolor=\"gray\", capsize=3\n", " )\n", "\n", " # Set log scales\n", " ax_density.set_xscale('log')\n", " ax_density.set_yscale('log')\n", "\n", " # Set labels and title\n", " ax_density.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\")\n", " ax_density.set_ylabel(r\"$N / (4\\pi r^2 \\Delta r)\\;\\;$[$\\mathrm{kpc}^{-3}$]\")\n", " ax_density.set_title(r\"$t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % actual_time_in_gyr[0])\n", "\n", " # Set fixed limits based on config and calculated density range\n", " ax_density.set_xlim(density_min_radius, density_max_radius)\n", "\n", " # Determine y-limits dynamically (avoiding zeros for log scale)\n", " min_density = np.nanmin(all_densities_np[all_densities_np > 0]) if np.any(all_densities_np > 0) else 1e-3\n", " max_density = np.nanmax(all_densities_np) if np.any(np.isfinite(all_densities_np)) else 1.0\n", " if max_density <= min_density: # Handle cases with no variance or single point\n", " max_density = min_density * 10\n", " ax_density.set_ylim(min_density * 0.5, max_density * 2.0) # Add some padding\n", "\n", " ax_density.grid(True, which=\"both\", ls=\"--\", linewidth=0.5) # Add grid for log-log\n", "\n", " def update_density(frame):\n", " density_data = all_densities_np[frame]\n", " density_error_data = all_density_errors_np[frame]\n", " ax_density.clear() # Clear the axis for redrawing\n", " # Re-plot the error bars for the current frame\n", " # Update title and axis properties\n", " ax_density.set_xscale('log')\n", " ax_density.set_yscale('log')\n", " ax_density.set_title(r\"$t = %.2f\\;\\;$[$\\mathrm{Gyr}$]\" % actual_time_in_gyr[frame])\n", " ax_density.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\")\n", " ax_density.set_ylabel(r\"$N / (4\\pi r^2 \\Delta r)\\;\\;$[$\\mathrm{kpc}^{-3}$]\")\n", " ax_density.set_xlim(density_min_radius, density_max_radius)\n", " ax_density.set_ylim(min_density * 0.5, max_density * 2.0)\n", " ax_density.grid(True, which=\"both\", ls=\"--\", linewidth=0.5)\n", " errorbar = ax_density.errorbar(\n", " log_bin_centers, density_data, yerr=density_error_data, \n", " fmt='o', markersize=3, linestyle='None', color=\"teal\", ecolor=\"gray\", capsize=3\n", " )\n", " return errorbar.get_children() # Return the errorbar artists for blitting\n", "\n", "\n", " # Create the animation object\n", " density_ani = FuncAnimation(fig_density, update_density, frames=len(actual_time_steps),\n", " interval=150, blit=True, repeat=True) # blit=True for performance\n", " \n", " # Close the figure to prevent static display\n", " plt.close(fig_density)\n", "\n", "# Uncomment to show initial static image\n", "# plt.show()\n", "\n", "\n", "# Uncomment this line to save the animation as MP4\n", "# density_ani.save(\"results/loglogdensity.mp4\", writer='ffmpeg', fps=15, dpi=150) # Adjust fps/dpi as needed\n", "\n", "HTML(density_ani.to_jshtml())" ] }, { "cell_type": "code", "execution_count": 6, "id": "96566fa9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing files...\n", "Finished processing. Processed data for 251 time steps.\n", "Generating density animation...\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.animation import FuncAnimation\n", "from scipy.ndimage import gaussian_filter1d\n", "import os\n", "\n", "# --- Configuration ---\n", "\n", "density_num_bins = 10 # Number of bins for the density plot\n", "density_min_radius = 0.02\n", "density_max_radius = 2.0\n", "log_bin_edges = np.logspace(np.log10(density_min_radius),\n", " np.log10(density_max_radius),\n", " density_num_bins + 1)\n", "# Calculate geometric bin centers and linear bin widths for log bins\n", "log_bin_centers = np.sqrt(log_bin_edges[:-1] * log_bin_edges[1:])\n", "log_bin_widths = np.diff(log_bin_edges)\n", "\n", "\n", "# --- Storage ---\n", "# For original plots\n", "all_smoothed_counts = []\n", "lowest_bin_counts = []\n", "sum_lowest_n_bins_counts = []\n", "msv_bin1_list = []\n", "msv_bins1_n_list = []\n", "# For density animation\n", "all_densities = []\n", "all_density_errors = []\n", "# Common\n", "actual_time_steps = []\n", "\n", "record_dtype = np.dtype([\n", " ('rank', np.int32),\n", " ('mass', np.float32),\n", " ('R', np.float32), # Radius\n", " ('Vrad', np.float32), # Radial Velocity\n", " ('PsiA', np.float32),\n", " ('E', np.float32),\n", " ('L', np.float32)\n", "])\n", "\n", "# --- Process each file ---\n", "print(\"Processing files...\")\n", "for time_step in time_steps:\n", " file_path = path_template.format(timestep=time_step)\n", " try:\n", " if not os.path.exists(file_path):\n", " print(f\"File not found: {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " alldata = np.fromfile(file_path, dtype=record_dtype)\n", " if alldata.size == 0:\n", " print(f\"Warning: File is empty {file_path}, skipping time step {time_step}\")\n", " continue\n", "\n", " radii = alldata['R']\n", " vrad = alldata['Vrad']\n", "\n", " valid_data_mask = np.isfinite(radii) & np.isfinite(vrad)\n", " if not np.all(valid_data_mask):\n", " radii_filt = radii[valid_data_mask]\n", " vrad_filt = vrad[valid_data_mask]\n", " radii_orig_for_hist = radii[np.isfinite(radii)] # Keep radii for histogramming even if vrad is bad\n", " if radii_orig_for_hist.size == 0:\n", " print(f\"Warning: No finite radii remaining after filtering at Time Step: {time_step}. Skipping step.\")\n", " continue # Skip if no valid radii left\n", " else:\n", " radii_filt = radii\n", " vrad_filt = vrad\n", " radii_orig_for_hist = radii\n", "\n", " # --- Calculations for Density Animation (Log Bins) ---\n", " # Filter radii specifically for the density plot range\n", " radii_for_density = radii_orig_for_hist[(radii_orig_for_hist >= density_min_radius) & (radii_orig_for_hist <= density_max_radius)]\n", "\n", " counts_log, _ = np.histogram(radii_for_density, bins=log_bin_edges)\n", "\n", " # Calculate density: N / (R^2 * ΔR)\n", " # Avoid division by zero if counts are zero\n", " # Use np.divide with where clause for safety, although R^2 and width shouldn't be zero here.\n", " particlemass = 1.15e4 # Particle mass for conversion to physical units\n", " denominator = (log_bin_centers**2) * log_bin_widths * 4.0 * np.pi/particlemass\n", " density = np.divide(counts_log, denominator, out=np.zeros_like(denominator, dtype=float), where=denominator!=0)\n", " density_errors = np.divide(np.sqrt(counts_log), denominator, out=np.zeros_like(denominator, dtype=float), where=denominator!=0)\n", " all_densities.append(density)\n", " all_density_errors.append(density_errors)\n", " # --- Record successful timestep ---\n", " actual_time_steps.append(time_step)\n", "\n", " except Exception as e:\n", " print(f\"Error reading or processing file {file_path} at timestep {time_step}: {e}\")\n", " # Attempt to rollback lists if error occurred after some appends\n", " # This is slightly brittle; ideally, append only at the very end of try block\n", " if len(actual_time_steps) < len(lowest_bin_counts): lowest_bin_counts.pop()\n", " if len(actual_time_steps) < len(sum_lowest_n_bins_counts): sum_lowest_n_bins_counts.pop()\n", " if len(actual_time_steps) < len(msv_bin1_list): msv_bin1_list.pop()\n", " if len(actual_time_steps) < len(msv_bins1_n_list): msv_bins1_n_list.pop()\n", " if len(actual_time_steps) < len(all_smoothed_counts): all_smoothed_counts.pop()\n", " if len(actual_time_steps) < len(all_densities): all_densities.pop()\n", "\n", "\n", "print(f\"Finished processing. Processed data for {len(actual_time_steps)} time steps.\")\n", "\n", "# Convert density list to numpy array for easier handling\n", "all_densities_np = np.array(all_densities)\n", "all_density_errors_np = np.array(all_density_errors)\n", "\n", "\n", "\n", "# --- Create Density Animation ---\n", "if all_densities_np.size > 0:\n", " print(\"Generating density animation...\")\n", "\n", " fig_density, ax_density = plt.subplots(figsize=(8, 6))\n", "\n", " # Initial plot using the first frame's data\n", " ax_density.errorbar(\n", " log_bin_centers, all_densities_np[0], yerr=all_density_errors_np[0], \n", " fmt='o', markersize=3, linestyle='None', color=\"black\", ecolor=\"black\", capsize=3, label=r\"$t=0$ $\\mathrm{Gyr}$\"\n", ")\n", "\n", " ax_density.errorbar(\n", " log_bin_centers, all_densities_np[12], yerr=all_density_errors_np[12], \n", " fmt='o', markersize=3, linestyle='None', color=\"red\", ecolor=\"red\", capsize=3, label =r\"$t=1$ $\\mathrm{Gyr}$\"\n", ")\n", " \n", " ax_density.errorbar(\n", " log_bin_centers, all_densities_np[191], yerr=all_density_errors_np[191], \n", " fmt='o', markersize=3, linestyle='None', color=\"green\", ecolor=\"green\", capsize=3, label=r\"$t=15$ $\\mathrm{Gyr}$\"\n", ")\n", " \n", " ax_density.errorbar(\n", " log_bin_centers, all_densities_np[210], yerr=all_density_errors_np[210], \n", " fmt='o', markersize=3, linestyle='None', color=\"blue\", ecolor=\"blue\", capsize=3, label=r\"$t=16.5$ $\\mathrm{Gyr}$\"\n", ")\n", " # Set log scales\n", " ax_density.set_xscale('log')\n", " ax_density.set_yscale('log')\n", "\n", " plt.tick_params(axis='both', which='major', labelsize=14) # Change font size for major ticks\n", " plt.tick_params(axis='both', which='minor', labelsize=10) # Change font size for minor ticks\n", "\n", " # Set labels and title\n", " ax_density.set_xlabel(r\"$r\\;\\;$[$\\mathrm{kpc}$]\",fontsize=14)\n", " ax_density.set_ylabel(r'$\\rho\\;\\;$[$\\mathrm{M}_\\odot/\\mathrm{kpc}^3$]',fontsize=14)\n", "\n", " # Set fixed limits based on config and calculated density range\n", " ax_density.set_xlim(density_min_radius, density_max_radius)\n", "\n", " # Determine y-limits dynamically (avoiding zeros for log scale)\n", " min_density = np.nanmin(all_densities_np[all_densities_np > 0]) if np.any(all_densities_np > 0) else 1e-3\n", " max_density = np.nanmax(all_densities_np) if np.any(np.isfinite(all_densities_np)) else 1.0\n", " if max_density <= min_density: # Handle cases with no variance or single point\n", " max_density = min_density * 10\n", " ax_density.set_ylim(min_density * 0.5, max_density * 2.0) # Add some padding\n", "\n", " ax_density.grid(True, which=\"both\", ls=\"--\", linewidth=0.5) # Add grid for log-log\n", "\n", "ax_density.legend(loc=\"upper right\", fontsize=20)\n", "plt.savefig(\"fig1_density_evolution.pdf\", dpi=300, bbox_inches=\"tight\")\n", "plt.show()" ] } ], "metadata": { "apache_2_0_license_text": "Copyright 2025 Marc Kamionkowski and Kris Sigurdson.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.", "copyright": "Copyright 2025 Marc Kamionkowski and Kris Sigurdson. Licensed under Apache-2.0", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.3" }, "license": "Apache-2.0" }, "nbformat": 4, "nbformat_minor": 5 }