From e855c6754b5c34b011d92e259f08ba007735e7c5 Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Tue, 5 Mar 2024 17:25:00 -0500 Subject: [PATCH 1/7] adding removal coefficients function --- EXPtools/utils/coefficients.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 EXPtools/utils/coefficients.py diff --git a/EXPtools/utils/coefficients.py b/EXPtools/utils/coefficients.py new file mode 100644 index 0000000..4606177 --- /dev/null +++ b/EXPtools/utils/coefficients.py @@ -0,0 +1,20 @@ +def remove_terms(original_coefficients, n, l, m): + """ + Remove coefficients + """ + + assert len(l) == len(m) == len(n) + copy_coeffcients = original_coefficients.deepcopy() + coefs_matrix = original_coefficients.getAllCoefs() + t_snaps = original_coefficients.Times() + + + for t in range(len(t_snaps)): + for i in range(len(l)): + lm_idx = int(l[i]*(l[i]+1) / 2) + m[i] + print(n[i],l[i],m[i],lm_idx) + try: coefs_matrix[n[i], lm_idx, t] = np.complex128(0) + except IndexError: continue + copy_coeffcients.setMatrix(mat=coefs_matrix[:,:, t], time=t_snaps[t]) + + return copy_coeffcients From 9a3e582daf3eef49130860ced5d748ac5ca6513e Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Thu, 7 Mar 2024 13:00:48 -0500 Subject: [PATCH 2/7] adding 3d visuals routines --- EXPtools/visuals/visuals_3d.py | 73 ++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 EXPtools/visuals/visuals_3d.py diff --git a/EXPtools/visuals/visuals_3d.py b/EXPtools/visuals/visuals_3d.py new file mode 100644 index 0000000..8edc244 --- /dev/null +++ b/EXPtools/visuals/visuals_3d.py @@ -0,0 +1,73 @@ + +import numpy as np +import k3d + + +def volume3D(field, level, size='nan'): + """ + + + """ + if size == 'nan': + size = np.array([600, 600, 600]) + + volume = k3d.volume(field.astype(np.float32), + alpha_coef=level, + color_range=[-0.4, 0.4], + color_map=(np.array(k3d.colormaps.paraview_color_maps.Cool_to_Warm_Extended).reshape(-1,4) + * np.array([1.0,1.0,1.0,1.0])).astype(np.float32) + ) + + volume.opacity_function = [0. , 0. , 0.21327923, 0.98025 , 0.32439035, + 0. , 0.5 , 0. , 0.67560965, 0. , + 0.74537706, 0.9915 , 1. , 0. ] + + + volume.transform.bounds = [-size[0]/2,size[0]/2, + -size[1]/2,size[1]/2, + -size[2]/2,size[2]/2] + + return volume + +def filed_evolution(fields_t, snap_0, ngrid=(50, 50, 50)): + rho0 = fields_t['snap_000']['pot0'][:].reshape(ngrid) + + for t in range(0, 300, 7): + rhoall = fields1['snap_{:03d}'.format(t)]['pot'][:].reshape((50, 50, 50)).T + img = (((rho0+rhoall) / (rho0)) - 1 ) # * 7 + + psi_t[str(float(t))] = img.astype(np.float32) + return psi_t + +def make_volume_render(densities, volumes, size, display=False, **kwargs): + # Contours + vols = [] + plot3d = k3d.plot(height=800) + + + for volume in volumes: + vol = volume3D(field, level=200.0, size=size) + vol.color_range = [-0.2, 0.2] + vols.append(vol) + plot3d += vol + + # Labels + if label in kwargs: + plt_tp_text = k3d.text2d(kwargs['label'], + position=[0.01, 0.05], + reference_point='lc', + is_html=True, + color=0x3f71d8) + plot3d += plt_tp_text + + # Orbit + if orbit in kwargs: + plt_streamlines = k3d.line(np.array([sat_orbit[:40,1], sat_orbit[:40,0], sat_orbit[:40,2]]).T, + color=222, + width=0.00007) + + if display == True: + plot3d.display() + + if + From 39206a920ade28451e9acd905eee83ae1de2f3dc Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Thu, 7 Mar 2024 13:31:16 -0500 Subject: [PATCH 3/7] updating 3D routines --- EXPtools/visuals/visuals3D.py | 103 +++++++++++++++++++++++++++++++++ EXPtools/visuals/visuals_3d.py | 73 ----------------------- 2 files changed, 103 insertions(+), 73 deletions(-) create mode 100644 EXPtools/visuals/visuals3D.py delete mode 100644 EXPtools/visuals/visuals_3d.py diff --git a/EXPtools/visuals/visuals3D.py b/EXPtools/visuals/visuals3D.py new file mode 100644 index 0000000..4c145dc --- /dev/null +++ b/EXPtools/visuals/visuals3D.py @@ -0,0 +1,103 @@ + +import numpy as np +import k3d + +def field3Dcontour(field, contour_range, contour_name, size, **kwargs): + """ + # TODO: Add time-dependent + + field + + volume_ranges + + volume_names + + kwargs: + color map + + """ + + + volume = k3d.volume(field.astype(np.float32), + alpha_coef=1.0, + color_range=contour_range, + color_map=(np.array(k3d.colormaps.paraview_color_maps.Cool_to_Warm_Extended).reshape(-1,4) + * np.array([1,1.0,1.0,1.0])).astype(np.float32), + name=contour_name) + + # Where this values come from? + volume.opacity_function = [0. , 0. , 0.21327923, 0.98025 , 0.32439035, + 0. , 0.5 , 0. , 0.67560965, 0. , + 0.74537706, 0.9915 , 1. , 0. ] + + + volume.transform.bounds = [-size[0]/2, size[0]/2, + -size[1]/2, size[1]/2, + -size[2]/2, size[2]/2] + + if 'alpha' in kwargs.keys(): + volume.alpha_coef = kwargs['alpha'] + + return volume + +def orbit3D(orbit, orbit_name, **kwargs): + """ + # TODO: Add time-dependent + + orbit: numpy.array + (3, N) shape + + orbit_name + + color + + kwargs: + color map + + """ + + orbit_trayectory = k3d.line(orbit.astype(np.float32), + width=1, + color_range=[0, 0.1], color=0x3e3a3a, name=orbit_name) + + + + if 'alpha' in kwargs.keys(): + orbit_trayectory.alpha_coef = kwargs['alpha'] + + return orbit_trayectory + + + +def field3Drender(volumes, contour_ranges, size, contour_names=['Inner', 'Outter'], + contour_alphas=[8,1], **kwargs): + """ + volumes: numpy.ndarray + shape: t, gridx, gridy, gridz + + orbit + + """ + render = k3d.plot(height=800) + + for vol in range(len(contour_ranges)): + v = field3Dcontour(volumes[0], + contour_range=contour_ranges[vol], + contour_name=contour_names[vol], + alpha=contour_alphas[vol], size=size) + render += v + v_t = {} + for t in range(volumes.shape[0]): + v_t[str(float(t))] = volumes[t].astype(np.float32) + v.volume = v_t + + # Implement 3d orbit + if 'orbits' in kwargs.keys(): + + for orb in range(len(kwargs['orbits_names'])): + o = orbit3D(kwargs['orbits'][orb], + orbit_name=kwargs['orbits_names'][orb], width=10) + render += o + + + return render diff --git a/EXPtools/visuals/visuals_3d.py b/EXPtools/visuals/visuals_3d.py deleted file mode 100644 index 8edc244..0000000 --- a/EXPtools/visuals/visuals_3d.py +++ /dev/null @@ -1,73 +0,0 @@ - -import numpy as np -import k3d - - -def volume3D(field, level, size='nan'): - """ - - - """ - if size == 'nan': - size = np.array([600, 600, 600]) - - volume = k3d.volume(field.astype(np.float32), - alpha_coef=level, - color_range=[-0.4, 0.4], - color_map=(np.array(k3d.colormaps.paraview_color_maps.Cool_to_Warm_Extended).reshape(-1,4) - * np.array([1.0,1.0,1.0,1.0])).astype(np.float32) - ) - - volume.opacity_function = [0. , 0. , 0.21327923, 0.98025 , 0.32439035, - 0. , 0.5 , 0. , 0.67560965, 0. , - 0.74537706, 0.9915 , 1. , 0. ] - - - volume.transform.bounds = [-size[0]/2,size[0]/2, - -size[1]/2,size[1]/2, - -size[2]/2,size[2]/2] - - return volume - -def filed_evolution(fields_t, snap_0, ngrid=(50, 50, 50)): - rho0 = fields_t['snap_000']['pot0'][:].reshape(ngrid) - - for t in range(0, 300, 7): - rhoall = fields1['snap_{:03d}'.format(t)]['pot'][:].reshape((50, 50, 50)).T - img = (((rho0+rhoall) / (rho0)) - 1 ) # * 7 - - psi_t[str(float(t))] = img.astype(np.float32) - return psi_t - -def make_volume_render(densities, volumes, size, display=False, **kwargs): - # Contours - vols = [] - plot3d = k3d.plot(height=800) - - - for volume in volumes: - vol = volume3D(field, level=200.0, size=size) - vol.color_range = [-0.2, 0.2] - vols.append(vol) - plot3d += vol - - # Labels - if label in kwargs: - plt_tp_text = k3d.text2d(kwargs['label'], - position=[0.01, 0.05], - reference_point='lc', - is_html=True, - color=0x3f71d8) - plot3d += plt_tp_text - - # Orbit - if orbit in kwargs: - plt_streamlines = k3d.line(np.array([sat_orbit[:40,1], sat_orbit[:40,0], sat_orbit[:40,2]]).T, - color=222, - width=0.00007) - - if display == True: - plot3d.display() - - if - From 592984b3da03fc2897969b3235486beafca9fd7c Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Fri, 8 Mar 2024 14:30:08 -0500 Subject: [PATCH 4/7] 3d fields symphony --- .../3d_fields_render_visualization.ipynb | 276 ++++++++++++++++++ 1 file changed, 276 insertions(+) create mode 100644 docs/tutorials/3d_fields_render_visualization.ipynb diff --git a/docs/tutorials/3d_fields_render_visualization.ipynb b/docs/tutorials/3d_fields_render_visualization.ipynb new file mode 100644 index 0000000..b66d8c8 --- /dev/null +++ b/docs/tutorials/3d_fields_render_visualization.ipynb @@ -0,0 +1,276 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "30590878", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n", + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "import numpy as np\n", + "import pyEXP\n", + "import EXPtools \n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fd377bf7", + "metadata": {}, + "outputs": [], + "source": [ + "field = np.load('/home/ngc/Downloads/field3d_0Gyr_test.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fc7d5c89", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(101, 101, 101)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.shape(field)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c8fce264", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-855137.44 968163.4\n" + ] + } + ], + "source": [ + "print(np.min(field), np.max(field))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a73321e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "968163.4" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(np.array([field]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "79b66056", + "metadata": {}, + "outputs": [], + "source": [ + "rend = EXPtools.visuals.field3Drender(np.array([field]), contour_ranges=[np.array([-0.1, 0.1]), np.array([-0.8, 0.8])],\n", + " size=[-100, 100, -100, 100, -100, 100])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "30e35046", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c566d6df0c648bd9b86c4c9952a9534", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Plot(antialias=3, axes=['x', 'y', 'z'], axes_helper=1.0, axes_helper_colors=[16711680, 65280, 255], background…" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rend" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "85eede92", + "metadata": {}, + "outputs": [], + "source": [ + "# Symphony fields" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f3db32eb", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2c5638db", + "metadata": {}, + "outputs": [], + "source": [ + "symph_halo_170_dens = np.zeros((30, 151, 151, 151))\n", + "for t in range(29):\n", + " with open('../../data/dens_Halo170/dens_Halo170_{:03d}.pickle'.format(215+t), 'rb') as f:\n", + " symph_halo_170_dens[t] = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "613a3b8f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_283080/1353063628.py:1: RuntimeWarning: divide by zero encountered in log10\n", + " np.max(np.log10(np.abs(symph_halo_170_dens)))\n" + ] + }, + { + "data": { + "text/plain": [ + "-4.735161224880169" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(np.log10(np.abs(symph_halo_170_dens)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6da29ffd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_283080/2116080773.py:1: RuntimeWarning: divide by zero encountered in log10\n", + " rend = EXPtools.visuals.field3Drender(np.log10(np.abs(symph_halo_170_dens)),\n" + ] + } + ], + "source": [ + "rend = EXPtools.visuals.field3Drender(np.log10(np.abs(symph_halo_170_dens)), \n", + " contour_ranges=[np.array([-8, -4]), \n", + " np.array([-7, -5.5])],\n", + " size=[-150, 150, -150, 150, -150, 150], \n", + " contour_alphas=[2, 4])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c6875f54", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b2243ca76a6a4f93b19d61e1f47a7b26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Plot(antialias=3, axes=['x', 'y', 'z'], axes_helper=1.0, axes_helper_colors=[16711680, 65280, 255], background…" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rend" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19fc3129", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyexp", + "language": "python", + "name": "pyexp" + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 21b04eed7d6968c8c58aed544fc0e0b66b20c8cf Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Mon, 11 Mar 2024 17:08:38 -0400 Subject: [PATCH 5/7] fixing calling empirical function --- EXPtools/basis_builder/basis_utils.py | 17 ++++----- EXPtools/basis_builder/makemodel.py | 53 +++++++++++++++++++++++---- 2 files changed, 52 insertions(+), 18 deletions(-) diff --git a/EXPtools/basis_builder/basis_utils.py b/EXPtools/basis_builder/basis_utils.py index 45be4f2..27acfff 100644 --- a/EXPtools/basis_builder/basis_utils.py +++ b/EXPtools/basis_builder/basis_utils.py @@ -1,6 +1,6 @@ import os, sys, pickle, pyEXP import numpy as np -from . import makemodel +from EXPtools.basis_builder import makemodel def make_config(basis_id, numr, rmin, rmax, lmax, nmax, scale, modelname='', cachename='.slgrid_sph_cache'): @@ -242,18 +242,15 @@ def makebasis(pos, mass, basis_model, config=None, basis_id='sphereSL', time=0, if os.path.isfile(modelname) == False: print("-> File model not found so we are computing one \n") - if empirical == True: + if basis_model == "empirical": print('-> Computing empirical model') rad, rho = empirical_density_profile(pos, mass, nbins=numr) - elif empirical == False: - makemodel.hernquist_halo() - - makemodel.Profiles(density_profile) - - R, D, M, P = makemodel.makemodel(rho, rvals=np.logspace(np.log10(rmin), - np.log10(rmax), numr), M=np.sum(mass), outfile=modelname, return_values=True) + R, D, M, P = makemodel('empirical', func=None, dvals=rho, rvals=np.logspace(np.log10(rmin), np.log10(rmax), numr), M=np.sum(mass), outfile=modelname, return_values=True) + elif empirical == "Hernquist": print('-> Computing analytical Hernquist model') - R, D, M, P = makemodel.makemodel(hernquist_halo, 1, [scale], rvals=, pfile=modelname) + #makemodel.hernquist_halo() + #R, D, M, P = makemodel.makemodel(hernquist_halo, 1, [scale], rvals=, pfile=modelname) + print('-> Model computed: rmin={}, rmax={}, numr={}'.format(R[0], R[-1], len(R))) else: R, D, M, P = np.loadtxt(modelname, skiprows=3, unpack=True) diff --git a/EXPtools/basis_builder/makemodel.py b/EXPtools/basis_builder/makemodel.py index c00f9eb..ef8a0a2 100644 --- a/EXPtools/basis_builder/makemodel.py +++ b/EXPtools/basis_builder/makemodel.py @@ -1,5 +1,47 @@ import numpy as np +def empirical_density_profile(pos, mass, nbins=500, rmin=0, rmax=600, log_space=False): + """ + Computes the number density radial profile assuming all particles have the same mass. + + Args: + pos (ndarray): array of particle positions in cartesian coordinates with shape (n,3). + mass (ndarray): array of particle masses with shape (n,). + nbins (int, optional): number of bins in the radial profile. Default is 500. + rmin (float, optional): minimum radius of the radial profile. Default is 0. + rmax (float, optional): maximum radius of the radial profile. Default is 600. + log_space (bool, optional): whether to use logarithmic binning. Default is False. + + Returns: + tuple: a tuple containing the arrays of radius and density with shapes (nbins,) and (nbins,), respectively. + + Raises: + ValueError: if pos and mass arrays have different lengths or if nbins is not a positive integer. + """ + if len(pos) != len(mass): + raise ValueError("pos and mass arrays must have the same length") + if not isinstance(nbins, int) or nbins <= 0: + raise ValueError("nbins must be a positive integer") + + # Compute radial distances + r_p = np.sqrt(np.sum(pos**2, axis=1)) + + # Compute bin edges and shell volumes + if log_space: + bins = np.logspace(np.log10(rmin), np.log10(rmax), nbins+1) + else: + bins = np.linspace(rmin, rmax, nbins+1) + V_shells = 4/3 * np.pi * (bins[1:]**3 - bins[:-1]**3) + + # Compute density profile + density, _ = np.histogram(r_p, bins=bins, weights=mass) + density /= V_shells + + # Compute bin centers and return profile + radius = 0.5 * (bins[1:] + bins[:-1]) + + return radius, density + def makemodel(basis_type, func, dvals, rvals, M, unit_physical=False, return_values=False, outfile='', plabel = '', verbose=True): @@ -43,9 +85,8 @@ def makemodel(basis_type, func, dvals, rvals, M, # query out the density values - if basis_type == 'empirical': - dvals = func(rvals) + #vals = empirical_density_profile(rvals) # make the mass and potential arrays mvals = np.zeros(dvals.size) @@ -60,13 +101,9 @@ def makemodel(basis_type, func, dvals, rvals, M, # evaluate mass enclosed and potential energy by recursion for indx in range(1, dvals.size): - mvals[indx] = mvals[indx-1] - + 2.0*np.pi*(rvals[indx-1]*rvals[indx-1]*dvals[indx-1] - + rvals[indx]*rvals[indx]*dvals[indx])*(rvals[indx] - rvals[indx-1]) + mvals[indx] = mvals[indx-1] + 2.0*np.pi*(rvals[indx-1]*rvals[indx-1]*dvals[indx-1] + rvals[indx]*rvals[indx]*dvals[indx])*(rvals[indx] - rvals[indx-1]) - pwvals[indx] = pwvals[indx-1] - + 2.0*np.pi*(rvals[indx-1]*dvals[indx-1] - + rvals[indx]*dvals[indx])*(rvals[indx] - rvals[indx-1]); + pwvals[indx] = pwvals[indx-1] + 2.0*np.pi*(rvals[indx-1]*dvals[indx-1] + rvals[indx]*dvals[indx])*(rvals[indx] - rvals[indx-1]); # evaluate potential (see theory document) pvals = -mvals/(rvals+1.e-10) - (pwvals[dvals.size-1] - pwvals) From 254f896bc2b5839f80ce611624dcbd086e2f97c8 Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Mon, 11 Mar 2024 17:09:10 -0400 Subject: [PATCH 6/7] adding empirical Hernquist example --- .../EXP_workflow_external_halo.ipynb | 224 ++++++++++++------ 1 file changed, 145 insertions(+), 79 deletions(-) diff --git a/docs/tutorials/EXP_workflow_external_halo.ipynb b/docs/tutorials/EXP_workflow_external_halo.ipynb index 39750ab..4e96268 100644 --- a/docs/tutorials/EXP_workflow_external_halo.ipynb +++ b/docs/tutorials/EXP_workflow_external_halo.ipynb @@ -1,8 +1,27 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "f603eebc", + "metadata": {}, + "source": [ + "# Example workflow with EXPtools and pyEXP\n", + "\n", + "In this tutorial we will build a basis from a particle distribution, then we will compute coefficients\n", + "and reconstruct density and acceleration fields\n", + "\n", + "- [x] Generate particle data with EXPtools.utils\n", + "- [ ] Compute empirical basis\n", + "- [ ] Compute analytical NFW basis\n", + "- [ ] Compute density and acceleration fields\n", + "- [ ] Visualize coefficients\n", + "- [ ] Commpute fields from selected coefficients \n", + "- [ ] Make 3d renders" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "ea8ff00c-9b3c-4e59-ba71-e5a1fe0f81ae", "metadata": {}, "outputs": [ @@ -19,70 +38,50 @@ "%pylab inline\n", "import numpy as np\n", "import pyEXP\n", - "import EXP_tools \n", - "import nba\n", + "\n", + "import EXPtools \n", + "#import nba\n", "import matplotlib.pyplot as plt\n", - "plt.style.use('~/matplotlib.mplstyle')" + "#plt.style.use('~/matplotlib.mplstyle')\n", + "import k3d" ] }, { "cell_type": "code", "execution_count": 2, - "id": "7696faa9-41bd-4515-88a5-313b0a37c7bd", + "id": "bea4f670", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* Loading snapshot: /mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110 \n", - "* Loading 'ParticleIDs' of particles types 'PartType1' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "Returning IDs for galaxy=0\n", - "100000000\n", - "* Loading 'Coordinates' of particles types 'PartType1' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "* Loading 'Velocities' of particles types 'PartType1' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "* Loading 'Masses' of particles types 'PartType1' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "* Loading halo 0 particle data\n", - "* Computing coordinates in halo 0 reference frame\n", - "* Loading 'Coordinates' of particles types 'PartType2' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "* Loading 'Velocities' of particles types 'PartType2' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n", - "* Loading 'Potential' of particles types 'PartType2' from snapshot: '/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110.hdf5'\n" - ] - } - ], + "outputs": [], "source": [ - "halo = nba.ios.load_halo('/mnt/home/nico/gadget_runs/isolated_MW/MWLMC5_100M_b0_vir_OM3_G4_110', N_halo_part=[100000000, 15000000],\n", - " com_frame=0,\n", - " galaxy=0, snapformat=3, q=['pos', 'vel', 'mass'], com_method='diskpot')" + "HHalo = EXPtools.utils.halo.ICHernquist(size=500000)\n", + "SphericalH = HHalo.triaxial(axis_ratios=[1, 1, 1], rot_angle=0.0)" ] }, { "cell_type": "code", "execution_count": 3, - "id": "b24e7092-237f-4361-aa6e-d36c4d9c6a47", + "id": "8caa15b4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.0005908100584678874" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "pos = halo['pos']\n", - "mass = halo['mass']\n" + "np.min(norm(SphericalH, axis=1))" ] }, { "cell_type": "code", "execution_count": 4, - "id": "861701ed-cf2f-4c9b-bdde-9b82325fe670", - "metadata": {}, - "outputs": [], - "source": [ - "sample = np.random.randint(0, len(mass), 100000)\n", - "pos_sample = pos[sample]\n", - "mass_sample = mass[sample]" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "315131c2-fe27-4924-828a-de20db20f6b9", + "id": "6fc69f73", "metadata": {}, "outputs": [ { @@ -91,15 +90,15 @@ "(-200.0, 200.0)" ] }, - "execution_count": 12, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -107,14 +106,15 @@ } ], "source": [ - "plt.scatter(pos_sample[:,0], pos_sample[:,1], s=1, alpha=0.3)\n", + "fig, ax = plt.subplots(1, 1,figsize=(5,5))\n", + "plt.scatter(SphericalH[:,0], SphericalH[:,1], s=1) \n", "plt.xlim(-200, 200)\n", "plt.ylim(-200, 200)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "id": "a6bbcb69-1944-459a-a635-ccc3b80df7cc", "metadata": {}, "outputs": [ @@ -122,45 +122,111 @@ "name": "stdout", "output_type": "stream", "text": [ + "-> File model not found so we are computing one \n", + "\n", + "-> Computing empirical model\n", + "! Scaling: R= 20.000000000000004 M= 0.9999999999999989\n", + "1.0000000000000002 19699437.56698048 19699437.56698049 19699437.566980485\n", + "-> Model computed: rmin=0.010000000000000002, rmax=20.000000000000007, numr=100\n", "No config file provided.\n", - "Computing empirical density\n", - "------------------------------------------------------------\n", - "Cache parameters for SLGridSph: .slgrid_sph_mwmlmc5_hern_empirical\n", - "------------------------------------------------------------\n", - "model : SLGrid.empirial_halo.isolate.mwlmc5_test\n", - "lmax : 5\n", - "nmax : 10\n", - "numr : 500\n", - "cmap : 1\n", - "rmin : 0.59999999999999998\n", - "rmax : 599.39999999999998\n", - "scale : 40.5\n", - "diverge : 0\n", - "dfac : 1\n", - "------------------------------------------------------------\n" + "Computing empirical density\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "---- SLGridSph::ReadH5Cache: read basis cache <.slgrid_sph_mwmlmc5_hern_empirical.h5>\n", - "HDF5-DIAG: Error detected in HDF5 (1.10.8) thread 0:\n", - " #000: /dev/shm/nix-build-hdf5-1.10.8.drv-0/nixbld4/spack-stage-hdf5-1.10.8-4llfcdl4yg928lkan2xaxn0m9g0h5sfk/spack-src/src/H5A.c line 271 in H5Acreate2(): unable to create attribute\n", - " major: Attribute\n", - " minor: Unable to initialize object\n", - " #001: /dev/shm/nix-build-hdf5-1.10.8.drv-0/nixbld4/spack-stage-hdf5-1.10.8-4llfcdl4yg928lkan2xaxn0m9g0h5sfk/spack-src/src/H5Aint.c line 156 in H5A__create(): attribute already exists\n", - " major: Attribute\n", - " minor: Object already exists\n", - "Unable to create the attribute \"geometry\": (Attribute) Object already exists\n" + "---- SLGridSph::ReadH5Cache: error reading <.slgrid_sph_hern_empirical>\n", + "---- SLGridSph::ReadH5Cache: HDF5 error is \n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Tolerance errors in Sturm-Liouville solver for l=0\n", + "\n", + "order eigenvalue condition \n", + "----- ---------- --------- \n", + "0 2.421703e-01 too many levels for eigenvalues \n", + "1 1.030765e+00 reliable \n", + "2 7.553035e+00 reliable \n", + "3 2.059626e+01 reliable \n", + "4 3.654330e+01 reliable \n", + "5 5.947169e+01 too many levels for eigenvectors \n", + "6 8.740598e+01 too many levels for eigenvalues \n", + "7 1.232547e+02 too many levels for eigenvalues \n", + "8 1.494680e+02 too many levels for eigenvalues \n", + "9 1.637231e+02 too many levels for eigenvalues \n", + "\n", + "Error in BasisFactory constructor: Execution Exception: \n", + "SLGridSph found 6 tolerance errors in computing SL solutions.\n", + "We suggest checking your model file for smoothness and ensure\n", + "a sufficient number grid points that the relative difference\n", + "between field quantities is <= 0.3.\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Execution Exception: \nSLGridSph found 6 tolerance errors in computing SL solutions.\nWe suggest checking your model file for smoothness and ensure\na sufficient number grid points that the relative difference\nbetween field quantities is <= 0.3.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m basis, coefs \u001b[38;5;241m=\u001b[39m \u001b[43mEXPtools\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbasis_builder\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmakebasis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mSphericalH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mones\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m500000\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m500000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbasis_model\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mempirical\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mbasis_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43msphereSL\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnumr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrmin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mlmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodelname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mSLGrid.empirical_hern_halo\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mcachename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m.slgrid_sph_hern_empirical\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43madd_coef\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcoef_file\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mhern_empirical_coef.h5\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Work/research/codes/EXP/pyexp/lib/python3.10/site-packages/EXPtools/basis_builder/basis_utils.py:268\u001b[0m, in \u001b[0;36mmakebasis\u001b[0;34m(pos, mass, basis_model, config, basis_id, time, numr, rmin, rmax, lmax, nmax, scale, norm_mass_coef, modelname, cachename, add_coef, coef_file)\u001b[0m\n\u001b[1;32m 264\u001b[0m config \u001b[38;5;241m=\u001b[39m make_config(basis_id, numr, R[\u001b[38;5;241m0\u001b[39m], R[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], lmax, nmax, scale, \n\u001b[1;32m 265\u001b[0m modelname, cachename)\n\u001b[1;32m 267\u001b[0m \u001b[38;5;66;03m# Construct the basis instances\u001b[39;00m\n\u001b[0;32m--> 268\u001b[0m basis \u001b[38;5;241m=\u001b[39m \u001b[43mpyEXP\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbasis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mBasis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfactory\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 270\u001b[0m \u001b[38;5;66;03m# Prints info from Cache\u001b[39;00m\n\u001b[1;32m 271\u001b[0m basis\u001b[38;5;241m.\u001b[39mcacheInfo(cachename)\n", + "\u001b[0;31mRuntimeError\u001b[0m: Execution Exception: \nSLGridSph found 6 tolerance errors in computing SL solutions.\nWe suggest checking your model file for smoothness and ensure\na sufficient number grid points that the relative difference\nbetween field quantities is <= 0.3." + ] + } + ], + "source": [ + "basis, coefs = EXPtools.basis_builder.makebasis(SphericalH, np.ones(500000)/500000, basis_model='empirical',\n", + " basis_id='sphereSL', time=0.0, numr=100, rmin=0.01, rmax=20,\n", + " lmax=5, nmax=10, scale=1, modelname='SLGrid.empirical_hern_halo', \n", + " cachename=\".slgrid_sph_hern_empirical\", \n", + " add_coef=False, coef_file='hern_empirical_coef.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b9bfd6d3", + "metadata": {}, + "outputs": [], + "source": [ + "read_model = np.loadtxt('SLGrid.empirical_hern_halo', skiprows=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2c017d24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "basis, coefs = EXP_tools.basis_utils.make_a_BFE(pos_sample, mass_sample, basis_id='sphereSL', time=2.2, numr=500, rmin=0.01, rmax=400, \n", - " lmax=5, nmax=10, scale=40.5, modelname='SLGrid.empirial_halo.isolate.mwlmc5_test', \n", - " cachename=\".slgrid_sph_mwmlmc5_hern_empirical\", add_coef=False, coef_file='mwlmc5_hern_empirical_coef.h5', \n", - " empirical=True)" + "plt.semilogx(read_model[:,0], read_model[:,1])" ] }, { @@ -241,7 +307,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.12" } }, "nbformat": 4, From fdba30b763601c071e70791bd54442401a3ce860 Mon Sep 17 00:00:00 2001 From: jngaravitoc Date: Fri, 22 Mar 2024 15:31:47 -0400 Subject: [PATCH 7/7] adding 3d renders utils --- EXPtools/visuals/__init__.py | 2 +- EXPtools/visuals/visualize.py | 14 ++++++++------ EXPtools/visuals/visuals3D.py | 21 +++++++++++++-------- 3 files changed, 22 insertions(+), 15 deletions(-) diff --git a/EXPtools/visuals/__init__.py b/EXPtools/visuals/__init__.py index f95cea8..09ccb70 100644 --- a/EXPtools/visuals/__init__.py +++ b/EXPtools/visuals/__init__.py @@ -5,4 +5,4 @@ from .visualize import return_fields_in_grid from .visualize import slice_fields from .visualize import slice_3d_fields - +from .visuals3D import field3Drender diff --git a/EXPtools/visuals/visualize.py b/EXPtools/visuals/visualize.py index a6c3a42..34f6d80 100644 --- a/EXPtools/visuals/visualize.py +++ b/EXPtools/visuals/visualize.py @@ -1,7 +1,6 @@ import os, sys, pickle, pyEXP import numpy as np -###Field computations for plotting### def make_basis_plot(basis, savefile=None, nsnap='mean', y=0.92, dpi=200): """ Plots the potential of the basis functions for different values of l and n. @@ -270,8 +269,7 @@ def slice_fields(basis, coefficients, time=0, return [fx.reshape(npoints, npoints), fy.reshape(npoints, npoints), fz.reshape(npoints, npoints)], xgrid -def slice_3d_fields(basis, coefficients, time=0, - projection='XY', proj_plane=0, npoints=300, +def slice_3d_fields(basis, coefficients, time=0, npoints=50, grid_limits=(-300, 300), prop='dens', monopole_only=False): """ Plots a slice projection of the fields of a simulation. @@ -280,8 +278,6 @@ def slice_3d_fields(basis, coefficients, time=0, basis (obj): object containing the basis functions for the simulation coefficients (obj): object containing the coefficients for the simulation time (float): the time at which to plot the fields - projection (str): the slice projection to plot. Can be 'XY', 'XZ', or 'YZ'. - proj_plane (float, optional): the value of the coordinate that is held constant in the slice projection npoints (int, optional): the number of grid points in each dimension grid_limits (tuple, optional): the limits of the grid in the x and y dimensions, in the form (x_min, x_max) prop (str, optional): the property to return. Can be 'dens' (density), 'pot' (potential), or 'force' (force). @@ -304,10 +300,13 @@ def slice_3d_fields(basis, coefficients, time=0, pot0 = np.zeros_like(xg) rho = np.zeros_like(xg) pot = np.zeros_like(xg) + fx = np.zeros_like(xg) + fy = np.zeros_like(xg) + fz = np.zeros_like(xg) basis.set_coefs(coefficients.getCoefStruct(time)) for k in range(0, N): - rho0[k], pot0[k], rho[k], pot[k], fx, fy, fz = basis.getFields(xg[k], yg[k], zg[k]) + rho0[k], pot0[k], rho[k], pot[k], fx[k], fy[k], fz[k] = basis.getFields(xg[k], yg[k], zg[k]) dens = rho.reshape(npoints, npoints, npoints) pot = pot.reshape(npoints, npoints, npoints) @@ -327,3 +326,6 @@ def slice_3d_fields(basis, coefficients, time=0, if prop == 'force': return [fx.reshape(npoints, npoints, npoints), fy.reshape(npoints, npoints, npoints), fz.reshape(npoints, npoints, npoints)], xgrid + + + diff --git a/EXPtools/visuals/visuals3D.py b/EXPtools/visuals/visuals3D.py index 4c145dc..9e16e1d 100644 --- a/EXPtools/visuals/visuals3D.py +++ b/EXPtools/visuals/visuals3D.py @@ -4,11 +4,13 @@ def field3Dcontour(field, contour_range, contour_name, size, **kwargs): """ - # TODO: Add time-dependent - field + field: numpy.ndarray + shape(t, N, N, N), where t is the time axis, N are the spatial axis. - volume_ranges + contour_ranges: list + values in percentage of the contour levels. e.g [0.5, 0.75] means + contours at the 50% and 75% level. volume_names @@ -17,10 +19,13 @@ def field3Dcontour(field, contour_range, contour_name, size, **kwargs): """ - + field_max = np.max(np.abs(field)) + #field_min = np.min(field) + + volume = k3d.volume(field.astype(np.float32), alpha_coef=1.0, - color_range=contour_range, + color_range=contour_range, #*field_max, color_map=(np.array(k3d.colormaps.paraview_color_maps.Cool_to_Warm_Extended).reshape(-1,4) * np.array([1,1.0,1.0,1.0])).astype(np.float32), name=contour_name) @@ -31,9 +36,9 @@ def field3Dcontour(field, contour_range, contour_name, size, **kwargs): 0.74537706, 0.9915 , 1. , 0. ] - volume.transform.bounds = [-size[0]/2, size[0]/2, - -size[1]/2, size[1]/2, - -size[2]/2, size[2]/2] + volume.transform.bounds = [-size[0], size[0], + -size[1], size[1], + -size[2], size[2]] if 'alpha' in kwargs.keys(): volume.alpha_coef = kwargs['alpha']