From 5b87bedab4d6e893e497104d71b2a49b97e2e3f0 Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Mon, 10 Nov 2025 02:59:56 +0000 Subject: [PATCH 1/9] Add raytracing for gas lines. --- examples/pinball-demo.ipynb | 317 ++++++++++++++++++++++++++++++++---- pinballrt/camera.py | 1 + pinballrt/gas.py | 101 ++++++++++++ pinballrt/grids.py | 204 ++++++++++++++++++++--- pinballrt/model.py | 30 +++- pinballrt/photons.py | 4 +- pinballrt/sources.py | 3 + 7 files changed, 595 insertions(+), 65 deletions(-) create mode 100644 pinballrt/gas.py diff --git a/examples/pinball-demo.ipynb b/examples/pinball-demo.ipynb index 5ca9351..eec4431 100644 --- a/examples/pinball-demo.ipynb +++ b/examples/pinball-demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "64a55749", "metadata": {}, "outputs": [], @@ -22,6 +22,7 @@ "from pinballrt.sources import Star\n", "from pinballrt.grids import UniformCartesianGrid\n", "from pinballrt.model import Model\n", + "from pinballrt.gas import Gas\n", "\n", "import matplotlib.pyplot as plt\n", "import astropy.units as u\n", @@ -31,17 +32,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "0d7c5715", - "metadata": {}, - "outputs": [], - "source": [ - "star = Star()\n", - "star.set_blackbody_spectrum()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "id": "a8890f61", "metadata": {}, "outputs": [ @@ -83,8 +73,26 @@ "model = Model(grid=UniformCartesianGrid, grid_kwargs={\"ncells\":9, \"dx\":2.0*u.au})\n", "\n", "density = np.ones(model.grid.shape)*1.0e-16 * u.g / u.cm**3\n", + "density[4,4,4] = 0.0 * u.g / u.cm**3 # Create a low-density cavity in the center\n", + "\n", + "vx, vy, vz = np.meshgrid(0.5*(model.grid.grid.w1.numpy()[1:] + model.grid.grid.w1.numpy()[0:-1]), \n", + " 0.5*(model.grid.grid.w2.numpy()[1:] + model.grid.grid.w2.numpy()[0:-1]), \n", + " 0.5*(model.grid.grid.w3.numpy()[1:] + model.grid.grid.w3.numpy()[0:-1]), indexing='ij')\n", + "velocity = np.concatenate((vx[np.newaxis], vy[np.newaxis], vz[np.newaxis]), axis=0) * (-1.0 * u.km / u.s)\n", "\n", - "model.add_density(density, \"yso.dst\")\n", + "model.set_physical_properties(density=density, dust=\"yso.dst\", amax=1.0*u.mm, p=3.5, gases=['co.dat'], \n", + " abundances=[1.0e-4], microturbulence=0.2 * u.km / u.s, velocity=velocity)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7bc813aa", + "metadata": {}, + "outputs": [], + "source": [ + "star = Star()\n", + "star.set_blackbody_spectrum()\n", "model.add_star(star)" ] }, @@ -98,17 +106,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 0\n", - "Module pinballrt.sources f5dedf3 load on device 'cpu' took 4.44 ms (cached)\n", - "Module pinballrt.grids 237c235 load on device 'cpu' took 10662.48 ms (compiled)\n", - "Module pinballrt.utils 08b2efb load on device 'cpu' took 1.45 ms (cached)\n" + "Iteration 0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module pinballrt.sources 1808836 load on device 'cpu' took 46.73 ms (cached)\n", + "Module pinballrt.grids 2b7aeed load on device 'cpu' took 2.09 ms (cached)\n", + "Module pinballrt.utils 08b2efb load on device 'cpu' took 2.30 ms (cached)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:04<00:00, 227489.85it/s]\n" + "100%|██████████| 1000000/1000000 [00:08<00:00, 114560.25it/s]\n", + "/workspaces/pinball-warp/pinballrt/grids.py:424: RuntimeWarning: invalid value encountered in divide\n", + " temperature = ((total_energy*u.L_sun).cgs.value / (4*const.sigma_sb.cgs.value*\\\n" ] }, { @@ -123,7 +139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:43<00:00, 23251.28it/s]\n" + "100%|██████████| 1000000/1000000 [00:15<00:00, 66245.92it/s]\n" ] }, { @@ -138,14 +154,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:43<00:00, 23147.92it/s]\n" + "100%|██████████| 1000000/1000000 [00:46<00:00, 21724.59it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2 1.1616004 230.01974\n", + "2 1.5727067 3.8231063\n", "Iteration 3\n" ] }, @@ -153,14 +169,44 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:52<00:00, 19069.58it/s]" + "100%|██████████| 1000000/1000000 [01:11<00:00, 14067.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 1.1690012 1.3453423\n", + "Iteration 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000000/1000000 [01:21<00:00, 12288.02it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "3 1.192686 1.026761\n" + "4 1.0569211 1.1060439\n", + "Iteration 5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000000/1000000 [01:25<00:00, 11675.67it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 1.0174265 1.0388181\n" ] }, { @@ -183,7 +229,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -200,43 +246,89 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "32322cc5", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Including gas 0 transition at 345.7959899 GHz\n", + "Including gas 0 transition at 461.0407682 GHz\n", + "Including gas 0 transition at 576.2679305 GHz\n", + "Including gas 0 transition at 691.4730763 GHz\n", + "Including gas 0 transition at 806.651806 GHz\n", + "Including gas 0 transition at 921.7997 GHz\n", + "Including gas 0 transition at 1036.912393 GHz\n", + "Including gas 0 transition at 1151.985452 GHz\n", + "Including gas 0 transition at 1267.014486 GHz\n", + "Including gas 0 transition at 1381.995105 GHz\n", + "Including gas 0 transition at 1496.922909 GHz\n", + "Including gas 0 transition at 1611.793518 GHz\n", + "Including gas 0 transition at 1726.6025057 GHz\n", + "Including gas 0 transition at 1841.345506 GHz\n", + "Including gas 0 transition at 1956.018139 GHz\n", + "Including gas 0 transition at 2070.615993 GHz\n", + "Including gas 0 transition at 2185.13468 GHz\n", + "Including gas 0 transition at 2299.569842 GHz\n", + "Including gas 0 transition at 2413.917113 GHz\n", + "Including gas 0 transition at 2528.17206 GHz\n", + "Including gas 0 transition at 2642.3303459 GHz\n", + "Including gas 0 transition at 2756.387584 GHz\n", + "Including gas 0 transition at 2870.339407 GHz\n", + "Including gas 0 transition at 2984.181455 GHz\n", + "Including gas 0 transition at 3097.909361 GHz\n", + "Including gas 0 transition at 3211.5187506 GHz\n", + "Including gas 0 transition at 3325.0052827 GHz\n", + "Including gas 0 transition at 3438.364611 GHz\n", + "Including gas 0 transition at 3551.592361 GHz\n", + "Including gas 0 transition at 3664.68418 GHz\n", + "Including gas 0 transition at 3777.635728 GHz\n", + "Including gas 0 transition at 3890.442717 GHz\n", + "Including gas 0 transition at 4003.1007876 GHz\n", + "Including gas 0 transition at 4115.605585 GHz\n", + "Including gas 0 transition at 4227.9527744 GHz\n", + "Including gas 0 transition at 4340.138112 GHz\n", + "Including gas 0 transition at 4452.1571221 GHz\n", + "Including gas 0 transition at 4564.0056399 GHz\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100000/100000 [00:06<00:00, 14506.65it/s]\n" + "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "100%|██████████| 100000/100000 [00:07<00:00, 13226.93it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 7.548181772232056\n" + "Time: 8.141393184661865\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 548627.16it/s]\n" + "100%|██████████| 100000/100000 [00:00<00:00, 533965.46it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 0.7414956092834473\n", + "Time: 0.7967901229858398\n", "65536\n", - "Module pinballrt.camera c7d3b15 load on device 'cpu' took 0.62 ms (cached)\n" + "Module pinballrt.camera c7d3b15 load on device 'cpu' took 0.64 ms (cached)\n" ] } ], "source": [ - "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, lam=np.array([1., 1000.])*u.micron, incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, device='cpu')" + "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.array([1., 1000.])*u.micron, incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, device='cpu')" ] }, { @@ -247,7 +339,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -263,11 +355,166 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "028ad375", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Including gas 0 transition at 345.7959899 GHz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 439033.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7963299751281738\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 520297.32it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.8237893581390381\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 503124.09it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.779876708984375\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 396922.14it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.8667309284210205\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 486441.06it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7757582664489746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 518145.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7729036808013916\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 518420.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7576239109039307\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 522214.81it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.9291698932647705\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 516309.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7775521278381348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100000/100000 [00:00<00:00, 513233.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 0.7407441139221191\n", + "65536\n" + ] + } + ], + "source": [ + "g = Gas()\n", + "g.set_properties_from_lambda('co.dat')\n", + "\n", + "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.linspace(-5., 5., 10)*u.km/u.s, rest_frequency=g.nu[2], \n", + " incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, device='cpu')" + ] } ], "metadata": { diff --git a/pinballrt/camera.py b/pinballrt/camera.py index ba84339..570d68d 100644 --- a/pinballrt/camera.py +++ b/pinballrt/camera.py @@ -52,6 +52,7 @@ def emit_rays(self, x, y, nu, nx, ny, pixel_size): ray_list = PhotonList() ray_list.position = wp.array(position, dtype=wp.vec3) ray_list.direction = wp.array(direction, dtype=wp.vec3) + ray_list.direction_frame = wp.array(direction, dtype=wp.vec3) ray_list.indices = wp.zeros(xflat.shape+(3,), dtype=int) ray_list.intensity = wp.array2d(intensity, dtype=float) ray_list.tau_intensity = wp.array2d(tau_intensity, dtype=float) diff --git a/pinballrt/gas.py b/pinballrt/gas.py new file mode 100644 index 0000000..fdc8563 --- /dev/null +++ b/pinballrt/gas.py @@ -0,0 +1,101 @@ +import astropy.constants as const +import astropy.units as u +import urllib +import requests +import numpy +import os + +class Gas: + + def set_properties_from_lambda(self, filename): + if not os.path.exists(filename): + if os.path.exists(os.environ["HOME"]+"/.pinballrt/data/gas/"+filename): + filename = os.environ["HOME"]+"/.pinballrt/data/gas/"+filename + else: + web_data_location = 'https://home.strw.leidenuniv.nl/~moldata/datafiles/'+filename + response = requests.get(web_data_location) + if response.status_code == 200: + if not os.path.exists(os.environ["HOME"]+"/.pinballrt/data/gas"): + os.makedirs(os.environ["HOME"]+"/.pinballrt/data/gas") + urllib.request.urlretrieve(web_data_location, + os.environ["HOME"]+"/.pinballrt/data/gas/"+filename) + filename = os.environ["HOME"]+"/.pinballrt/data/gas/"+filename + else: + print(web_data_location+' does not exist') + return + + f = open(filename) + + for i in range(3): + f.readline() + + self.mass = float(f.readline()) + + f.readline() + nlev = int(f.readline()) + f.readline() + + self.J = numpy.empty(nlev, dtype=" cell_size[ix,iy,iz] + def select_lines(self, lam): + # Convert wavelengths to frequencies and find range + nu = (const.c / lam).to(u.GHz) + max_nu = nu.max() + min_nu = nu.min() + + line_nu = [] + alpha_line = [] + inv_gamma = [] + + # Check which lines fall in range for each gas + for igas, gas in enumerate(self.gases): + # Calculate maximum line width + max_v = self.grid.velocity.numpy().max() * const.c + a_thermal = 3*np.sqrt(2 * const.k_B * self.grid.temperature.numpy().max()*u.K / \ + (gas.mass * const.m_p)) # 3-sigma width + a_microturb = self.grid.microturbulence.numpy().max() * u.km / u.s + + max_v += a_thermal + a_microturb + + # Check each transition + for iline in range(gas.nu.size): + max_frequency = gas.nu[iline] * (1 + max_v / const.c) + min_frequency = gas.nu[iline] * (1 - max_v / const.c) + + if ((min_nu < min_frequency and min_frequency < max_nu) or + (min_nu < max_frequency and max_frequency < max_nu) or + (min_frequency < min_nu and max_nu < max_frequency)): + + print(f"Including gas {igas} transition at {gas.nu[iline]}") + + alpha_line_tmp, inv_gamma_tmp = self.calculate_level_populations(igas, iline) + + line_nu.append(gas.nu[iline].to(u.GHz).value) + alpha_line.append(alpha_line_tmp) + inv_gamma.append(inv_gamma_tmp) + + with wp.ScopedDevice(self.device): + self.grid.alpha_line = wp.array4d(np.array(alpha_line), dtype=float) + self.grid.inv_gamma = wp.array4d(np.array(inv_gamma), dtype=float) + self.grid.nlines = len(line_nu) + self.grid.line_nu = wp.array1d(np.array(line_nu), dtype=float) + + def calculate_level_populations(self, igas, iline): + gas = self.gases[igas] + + # get level indices (convert to 0-based) + level_up = gas.J_u[iline] - 1 + level_low = gas.J_l[iline] - 1 + + level_populations_upper = np.zeros(self.shape) + level_populations_lower = np.zeros(self.shape) + alpha_line = np.zeros(self.shape) + self.inv_gamma_thermal_np = np.zeros(self.shape) + + # partition function: either callable or array-like + Q = gas.partition_function(self.grid.temperature.numpy()) + + # level populations (LTE Boltzmann with partition function) + level_populations_upper = gas.g[level_up] * np.exp(-const.h * const.c * gas.E[level_up] / (const.k_B * self.grid.temperature.numpy()*u.K)) / Q + level_populations_lower = gas.g[level_low] * np.exp(-const.h * const.c * gas.E[level_low] / (const.k_B * self.grid.temperature.numpy()*u.K)) / Q + + # thermal / microturbulent broadening + a_thermal = np.sqrt(2.0 * const.k_B * self.grid.temperature.numpy()*u.K / (gas.mass * const.m_p)) + a_microturb = self.grid.microturbulence.numpy() * u.km / u.s + inv_gamma = (1.0 / (gas.nu[iline] / const.c * np.sqrt(a_thermal**2 + a_microturb**2))).decompose().to(1./u.GHz) + + number_density = ((self.grid.density.numpy() * 1./self.distance_unit / self.dust.kmean) * self.gas_abundances[igas] / (gas.mass * const.m_p)).decompose() + + # Alpha for this line in this cell + # alpha = c^2/(8*pi*nu^2) * A * n * (n_l * g_u/g_l - n_u) * inv_gamma / sqrt(pi) + alpha_line = (const.c**2 / (8.0 * np.pi * gas.nu[iline]**2) * gas.A_ul[iline] * number_density * (level_populations_lower * (gas.g[level_up] / gas.g[level_low]) - level_populations_upper) * (inv_gamma / np.sqrt(np.pi))).decompose().to(1./self.distance_unit) + + return alpha_line, inv_gamma + @wp.kernel def add_intensity(ray_list: PhotonList, s: wp.array(dtype=float), @@ -823,7 +944,20 @@ def add_intensity(ray_list: PhotonList, intensity_sca = (1.0 - wp.exp(-tau_cell)) * albedo_total * scattering[inu,ix,iy,iz] - intensity_cell = intensity_abs + intensity_line = float(0.) + vector_velocity = wp.vec3(grid.velocity[0,ix,iy,iz], grid.velocity[1,ix,iy,iz], grid.velocity[2,ix,iy,iz]) + for itrans in range(grid.nlines): + # Need to add doppler shift here based on cell velocity along ray direction + profile = wp.exp(-(ray_list.frequency[inu] * (1.0 + wp.dot(ray_list.direction[ir],vector_velocity)) - grid.line_nu[itrans])**2. * (grid.inv_gamma[itrans,ix,iy,iz]**2.)) + + alpha_this_line = grid.alpha_line[itrans,ix,iy,iz] * profile + + tau_cell = tau_cell + s[ir] * alpha_this_line + alpha_ext = alpha_ext + alpha_this_line + + intensity_line = intensity_line + alpha_this_line * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) + + intensity_cell = intensity_abs + intensity_sca + intensity_line ray_list.intensity[ir,inu] = (ray_list.intensity[ir,inu] + intensity_cell * wp.exp(-ray_list.tau_intensity[ir,inu])) * (1. - wp.float32(ray_list.pixel_too_large[ir])) ray_list.tau_intensity[ir,inu] = ray_list.tau_intensity[ir,inu] + tau_cell @@ -1232,6 +1366,8 @@ def photon_loc(photon_list: PhotonList, i3 += 1 photon_list.indices[ip][2] = i3 + photon_list.direction_frame[ip] = photon_list.direction[ip] + class UniformSphericalGrid(Grid): def __init__(self, ncells=9, dr=1.0*u.au, mirror=True, device="cpu"): """ @@ -1698,6 +1834,14 @@ def photon_loc(photon_list: PhotonList, photon_list.position[ip][1] = photon_list.radius[ip] * photon_list.sin_theta[ip] * photon_list.sin_phi[ip] photon_list.position[ip][2] = photon_list.radius[ip] * photon_list.cos_theta[ip] + # Also, since we have all of the components calculated, update the direction frame + + xhat = wp.vec3(photon_list.sin_theta[ip] * photon_list.cos_phi[ip], photon_list.cos_theta[ip] * photon_list.cos_phi[ip], -photon_list.sin_phi[ip]) + yhat = wp.vec3(photon_list.sin_theta[ip] * photon_list.sin_phi[ip], photon_list.cos_theta[ip] * photon_list.sin_phi[ip], photon_list.cos_phi[ip]) + zhat = wp.vec3(photon_list.cos_theta[ip], -photon_list.sin_theta[ip], 0.) + + photon_list.direction_frame[ip] = photon_list.direction[ip][0] * xhat + photon_list.direction[ip][1] * yhat + photon_list.direction[ip][2] * zhat + class LogUniformSphericalGrid(UniformSphericalGrid): def __init__(self, ncells=9, rmin=0.1*u.au, rmax=4.5*u.au, mirror=True, device="cpu"): """ @@ -1968,4 +2112,12 @@ def photon_loc(photon_list: PhotonList, photon_list.position[ip][0] = photon_list.radius[ip] * photon_list.sin_theta[ip] * photon_list.cos_phi[ip] photon_list.position[ip][1] = photon_list.radius[ip] * photon_list.sin_theta[ip] * photon_list.sin_phi[ip] - photon_list.position[ip][2] = photon_list.radius[ip] * photon_list.cos_theta[ip] \ No newline at end of file + photon_list.position[ip][2] = photon_list.radius[ip] * photon_list.cos_theta[ip] + + # Also, since we have all of the components calculated, update the direction frame + + xhat = wp.vec3(photon_list.sin_theta[ip] * photon_list.cos_phi[ip], photon_list.cos_theta[ip] * photon_list.cos_phi[ip], -photon_list.sin_phi[ip]) + yhat = wp.vec3(photon_list.sin_theta[ip] * photon_list.sin_phi[ip], photon_list.cos_theta[ip] * photon_list.sin_phi[ip], photon_list.cos_phi[ip]) + zhat = wp.vec3(photon_list.cos_theta[ip], -photon_list.sin_theta[ip], 0.) + + photon_list.direction_frame[ip] = photon_list.direction[ip][0] * xhat + photon_list.direction[ip][1] * yhat + photon_list.direction[ip][2] * zhat \ No newline at end of file diff --git a/pinballrt/model.py b/pinballrt/model.py index 5795344..1a8942c 100644 --- a/pinballrt/model.py +++ b/pinballrt/model.py @@ -2,6 +2,7 @@ import astropy.units as u from .grids import Grid from .dust import load, Dust +from .gas import Gas from .camera import Camera from schwimmbad import SerialPool import xarray as xr @@ -50,7 +51,8 @@ def __init__(self, grid: Grid, grid_kwargs={}, ncores = 1, pool = SerialPool()): self.ncores = ncores self.pool = pool - def add_density(self, density: u.Quantity, dust): + def set_physical_properties(self, density=None, dust=None, amax=None, p=None, gases=None, abundances=None, + velocity=None, microturbulence=None): """ Add density to the grid. @@ -63,7 +65,9 @@ def add_density(self, density: u.Quantity, dust): """ for device in self.grid_list: for grid in self.grid_list[device]: - grid.add_density(density, load(dust) if isinstance(dust, str) else dust) + grid.set_physical_properties(density=density, dust=load(dust) if isinstance(dust, str) else dust, + amax=amax, p=p, gases=gases, abundances=abundances, + velocity=velocity, microturbulence=microturbulence) def add_star(self, star): """ @@ -191,7 +195,7 @@ def scattering_mc(self, nphotons, wavelengths, device="cpu", return_timing=False if return_timing: return timing - def make_image(self, npix=100, pixel_size=None, lam=np.array([1.])*u.micron, incl=0, pa=0, distance=1*u.pc, device="cpu"): + def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=None, incl=0, pa=0, distance=1*u.pc, device="cpu"): """ Create an image from the dust distribution. @@ -222,6 +226,26 @@ def make_image(self, npix=100, pixel_size=None, lam=np.array([1.])*u.micron, inc if pixel_size is None: pixel_size = ((1.25*self.grid.grid_size()*self.grid.distance_unit / distance).decompose()*u.radian).to(u.arcsec) / npix + # Check whether spectral is wavelength or frequency + + if channels.unit.is_equivalent(u.micron): + lam = channels.to(u.micron) + nu = (const.c / channels).to(u.GHz) + elif channels.unit.is_equivalent(u.GHz): + nu = channels.to(u.GHz) + lam = (const.c / nu).to(u.micron) + elif channels.unit.is_equivalent(u.km / u.s): + if rest_frequency is None: + raise ValueError("rest_frequency must be provided when channels are in velocity units.") + nu = (rest_frequency * (1 - channels / const.c)).to(u.GHz) + lam = (const.c / nu).to(u.micron) + else: + raise ValueError("Either lam or nu must be provided.") + + # Check which lines from the gas should be included + + self.grid.select_lines(lam) + # First, run a scattering simulation to get the scattering phase function self.scattering_mc(100000, lam, device=device) diff --git a/pinballrt/photons.py b/pinballrt/photons.py index 34f97ca..37afd55 100644 --- a/pinballrt/photons.py +++ b/pinballrt/photons.py @@ -40,4 +40,6 @@ class PhotonList: cos_theta: wp.array(dtype=float) phi: wp.array(dtype=float) sin_phi: wp.array(dtype=float) - cos_phi: wp.array(dtype=float) \ No newline at end of file + cos_phi: wp.array(dtype=float) + + direction_frame: wp.array(dtype=wp.vec3) \ No newline at end of file diff --git a/pinballrt/sources.py b/pinballrt/sources.py index 99527db..b7904c6 100644 --- a/pinballrt/sources.py +++ b/pinballrt/sources.py @@ -51,6 +51,7 @@ def emit(self, nphotons, distance_unit, wavelength="random", simulation="thermal phi = 2*np.pi*np.random.rand(nphotons) direction = cost[:,np.newaxis]*r_hat + (sint*np.cos(phi))[:,np.newaxis]*phi_hat + (sint*np.sin(phi))[:,np.newaxis]*theta_hat + direction_frame = cost[:,np.newaxis]*r_hat + (sint*np.cos(phi))[:,np.newaxis]*phi_hat + (sint*np.sin(phi))[:,np.newaxis]*theta_hat if wavelength == "random": t1 = time.time() @@ -69,6 +70,7 @@ def emit(self, nphotons, distance_unit, wavelength="random", simulation="thermal photon_list = PhotonList() photon_list.position = wp.array(position, dtype=wp.vec3) photon_list.direction = wp.array(direction, dtype=wp.vec3) + photon_list.direction_frame = wp.array(direction_frame, dtype=wp.vec3) photon_list.frequency = wp.array(frequency, dtype=float) photon_list.energy = wp.array(photon_energy, dtype=float) @@ -91,6 +93,7 @@ def emit_rays(self, nu, distance_unit, ez, nrays, distance, device="cpu"): ray_list = PhotonList() ray_list.position = wp.array(position, dtype=wp.vec3) ray_list.direction = wp.array(direction, dtype=wp.vec3) + ray_list.direction_frame = wp.array(direction, dtype=wp.vec3) ray_list.indices = wp.zeros(position.shape, dtype=int) ray_list.intensity = wp.array2d(intensity, dtype=float) ray_list.tau_intensity = wp.array2d(tau_intensity, dtype=float) From 3b125da2abd0e3ab1a97be09fec86f48fbc7059c Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Wed, 12 Nov 2025 03:12:02 +0000 Subject: [PATCH 2/9] Fix divide by zero that comes with scattering; add options to control including dust/gas/stars in image; update the example to include gas. --- examples/pinball-demo.ipynb | 257 ++++++------------------------------ pinballrt/grids.py | 40 +++--- pinballrt/model.py | 17 ++- 3 files changed, 74 insertions(+), 240 deletions(-) diff --git a/examples/pinball-demo.ipynb b/examples/pinball-demo.ipynb index eec4431..113f3f8 100644 --- a/examples/pinball-demo.ipynb +++ b/examples/pinball-demo.ipynb @@ -35,6 +35,19 @@ "id": "a8890f61", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warp CUDA error: Could not open libcuda.so.\n", + "Warp CUDA error: Function cuDriverGetVersion_f: a suitable driver entry point was not found\n", + "Warp CUDA error 36 (in function cuda_driver_version, /builds/omniverse/warp/warp/native/warp.cu:1719)\n", + "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -55,13 +68,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "Warp CUDA error: Could not open libcuda.so.\n", - "Warp CUDA error: Function cuDriverGetVersion_f: a suitable driver entry point was not found\n", - "Warp CUDA error 36 (in function cuda_driver_version, /builds/omniverse/warp/warp/native/warp.cu:1719)\n", - "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", - " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", - "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", - " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", @@ -113,17 +119,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Module pinballrt.sources 1808836 load on device 'cpu' took 46.73 ms (cached)\n", - "Module pinballrt.grids 2b7aeed load on device 'cpu' took 2.09 ms (cached)\n", - "Module pinballrt.utils 08b2efb load on device 'cpu' took 2.30 ms (cached)\n" + "Module pinballrt.sources 1808836 load on device 'cpu' took 258.03 ms (cached)\n", + "Module pinballrt.grids 5076f22 load on device 'cpu' took 11392.98 ms (compiled)\n", + "Module pinballrt.utils 08b2efb load on device 'cpu' took 10.72 ms (cached)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:08<00:00, 114560.25it/s]\n", - "/workspaces/pinball-warp/pinballrt/grids.py:424: RuntimeWarning: invalid value encountered in divide\n", + "100%|██████████| 1000000/1000000 [00:07<00:00, 137837.22it/s]\n", + "/workspaces/pinball-warp/pinballrt/grids.py:427: RuntimeWarning: invalid value encountered in divide\n", " temperature = ((total_energy*u.L_sun).cgs.value / (4*const.sigma_sb.cgs.value*\\\n" ] }, @@ -139,7 +145,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:15<00:00, 66245.92it/s]\n" + "100%|██████████| 1000000/1000000 [00:16<00:00, 60151.61it/s]\n" ] }, { @@ -154,14 +160,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:46<00:00, 21724.59it/s]\n" + "100%|██████████| 1000000/1000000 [00:49<00:00, 20163.15it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2 1.5727067 3.8231063\n", + "2 1.5663369 3.7621562\n", "Iteration 3\n" ] }, @@ -169,14 +175,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:11<00:00, 14067.89it/s]\n" + "100%|██████████| 1000000/1000000 [01:13<00:00, 13516.07it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "3 1.1690012 1.3453423\n", + "3 1.1663412 1.3429492\n", "Iteration 4\n" ] }, @@ -184,14 +190,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:21<00:00, 12288.02it/s]\n" + "100%|██████████| 1000000/1000000 [01:19<00:00, 12555.82it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "4 1.0569211 1.1060439\n", + "4 1.0577291 1.1026841\n", "Iteration 5\n" ] }, @@ -199,14 +205,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:25<00:00, 11675.67it/s]" + "100%|██████████| 1000000/1000000 [01:29<00:00, 11215.50it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "5 1.0174265 1.0388181\n" + "5 1.0214643 1.0355028\n" ] }, { @@ -229,7 +235,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -250,96 +256,51 @@ "id": "32322cc5", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Including gas 0 transition at 345.7959899 GHz\n", - "Including gas 0 transition at 461.0407682 GHz\n", - "Including gas 0 transition at 576.2679305 GHz\n", - "Including gas 0 transition at 691.4730763 GHz\n", - "Including gas 0 transition at 806.651806 GHz\n", - "Including gas 0 transition at 921.7997 GHz\n", - "Including gas 0 transition at 1036.912393 GHz\n", - "Including gas 0 transition at 1151.985452 GHz\n", - "Including gas 0 transition at 1267.014486 GHz\n", - "Including gas 0 transition at 1381.995105 GHz\n", - "Including gas 0 transition at 1496.922909 GHz\n", - "Including gas 0 transition at 1611.793518 GHz\n", - "Including gas 0 transition at 1726.6025057 GHz\n", - "Including gas 0 transition at 1841.345506 GHz\n", - "Including gas 0 transition at 1956.018139 GHz\n", - "Including gas 0 transition at 2070.615993 GHz\n", - "Including gas 0 transition at 2185.13468 GHz\n", - "Including gas 0 transition at 2299.569842 GHz\n", - "Including gas 0 transition at 2413.917113 GHz\n", - "Including gas 0 transition at 2528.17206 GHz\n", - "Including gas 0 transition at 2642.3303459 GHz\n", - "Including gas 0 transition at 2756.387584 GHz\n", - "Including gas 0 transition at 2870.339407 GHz\n", - "Including gas 0 transition at 2984.181455 GHz\n", - "Including gas 0 transition at 3097.909361 GHz\n", - "Including gas 0 transition at 3211.5187506 GHz\n", - "Including gas 0 transition at 3325.0052827 GHz\n", - "Including gas 0 transition at 3438.364611 GHz\n", - "Including gas 0 transition at 3551.592361 GHz\n", - "Including gas 0 transition at 3664.68418 GHz\n", - "Including gas 0 transition at 3777.635728 GHz\n", - "Including gas 0 transition at 3890.442717 GHz\n", - "Including gas 0 transition at 4003.1007876 GHz\n", - "Including gas 0 transition at 4115.605585 GHz\n", - "Including gas 0 transition at 4227.9527744 GHz\n", - "Including gas 0 transition at 4340.138112 GHz\n", - "Including gas 0 transition at 4452.1571221 GHz\n", - "Including gas 0 transition at 4564.0056399 GHz\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", - "100%|██████████| 100000/100000 [00:07<00:00, 13226.93it/s]\n" + "100%|██████████| 100000/100000 [00:07<00:00, 13364.65it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 8.141393184661865\n" + "Time: 8.626117467880249\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 533965.46it/s]\n" + "100%|██████████| 100000/100000 [00:00<00:00, 562914.49it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 0.7967901229858398\n", - "65536\n", - "Module pinballrt.camera c7d3b15 load on device 'cpu' took 0.64 ms (cached)\n" + "Time: 0.8552961349487305\n", + "65536\n" ] } ], "source": [ - "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.array([1., 1000.])*u.micron, incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, device='cpu')" + "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.array([1., 1000.])*u.micron, incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, include_gas=False, device='cpu')" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "837dbdd1", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "028ad375", "metadata": {}, "outputs": [ @@ -363,147 +324,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Including gas 0 transition at 345.7959899 GHz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 439033.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7963299751281738\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 520297.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.8237893581390381\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 503124.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.779876708984375\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 396922.14it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.8667309284210205\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 486441.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7757582664489746\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 518145.39it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7729036808013916\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 518420.77it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7576239109039307\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 522214.81it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.9291698932647705\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 516309.72it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7775521278381348\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 513233.59it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time: 0.7407441139221191\n", + "Including gas 0 transition at 345.7959899 GHz\n", "65536\n" ] } @@ -513,7 +334,7 @@ "g.set_properties_from_lambda('co.dat')\n", "\n", "image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.linspace(-5., 5., 10)*u.km/u.s, rest_frequency=g.nu[2], \n", - " incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, device='cpu')" + " incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, include_dust=False, device='cpu')" ] } ], diff --git a/pinballrt/grids.py b/pinballrt/grids.py index 6a01af8..f6788a0 100644 --- a/pinballrt/grids.py +++ b/pinballrt/grids.py @@ -46,6 +46,9 @@ class GridStruct: alpha_line: wp.array4d(dtype=float) inv_gamma: wp.array4d(dtype=float) + include_dust: bool + include_gas: bool + class Grid: def __init__(self, _w1, _w2, _w3, device='cpu'): self.device = device @@ -928,34 +931,37 @@ def add_intensity(ray_list: PhotonList, tau_cell = 0. intensity_abs = 0. + intensity_sca = 0. alpha_ext = 0. alpha_sca = 0. - tau_cell = tau_cell + s[ir]*ray_list.kext[iray,inu]*grid.density[ix,iy,iz] - alpha_ext = alpha_ext + ray_list.kext[iray,inu]*grid.density[ix,iy,iz] - alpha_sca = alpha_sca + ray_list.kext[iray,inu]*ray_list.ray_albedo[iray,inu]*grid.density[ix,iy,iz] - intensity_abs = intensity_abs + ray_list.kext[iray,inu] * (1. - ray_list.ray_albedo[iray,inu]) * \ - grid.density[ix,iy,iz] * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) + if grid.include_dust: + tau_cell = tau_cell + s[ir]*ray_list.kext[iray,inu]*grid.density[ix,iy,iz] + alpha_ext = alpha_ext + ray_list.kext[iray,inu]*grid.density[ix,iy,iz] + alpha_sca = alpha_sca + ray_list.kext[iray,inu]*ray_list.ray_albedo[iray,inu]*grid.density[ix,iy,iz] + intensity_abs = intensity_abs + ray_list.kext[iray,inu] * (1. - ray_list.ray_albedo[iray,inu]) * \ + grid.density[ix,iy,iz] * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) - albedo_total = alpha_sca / alpha_ext + albedo_total = alpha_sca / alpha_ext - if alpha_ext > 0.: - intensity_abs = intensity_abs * (1.0 - wp.exp(-tau_cell)) / alpha_ext + if alpha_ext > 0.: + intensity_abs = intensity_abs * (1.0 - wp.exp(-tau_cell)) / alpha_ext - intensity_sca = (1.0 - wp.exp(-tau_cell)) * albedo_total * scattering[inu,ix,iy,iz] + intensity_sca = (1.0 - wp.exp(-tau_cell)) * albedo_total * scattering[inu,ix,iy,iz] intensity_line = float(0.) - vector_velocity = wp.vec3(grid.velocity[0,ix,iy,iz], grid.velocity[1,ix,iy,iz], grid.velocity[2,ix,iy,iz]) - for itrans in range(grid.nlines): - # Need to add doppler shift here based on cell velocity along ray direction - profile = wp.exp(-(ray_list.frequency[inu] * (1.0 + wp.dot(ray_list.direction[ir],vector_velocity)) - grid.line_nu[itrans])**2. * (grid.inv_gamma[itrans,ix,iy,iz]**2.)) + if grid.include_gas: + vector_velocity = wp.vec3(grid.velocity[0,ix,iy,iz], grid.velocity[1,ix,iy,iz], grid.velocity[2,ix,iy,iz]) + for itrans in range(grid.nlines): + # Need to add doppler shift here based on cell velocity along ray direction + profile = wp.exp(-(ray_list.frequency[inu] * (1.0 + wp.dot(ray_list.direction[ir],vector_velocity)) - grid.line_nu[itrans])**2. * (grid.inv_gamma[itrans,ix,iy,iz]**2.)) - alpha_this_line = grid.alpha_line[itrans,ix,iy,iz] * profile + alpha_this_line = grid.alpha_line[itrans,ix,iy,iz] * profile - tau_cell = tau_cell + s[ir] * alpha_this_line - alpha_ext = alpha_ext + alpha_this_line + tau_cell = tau_cell + s[ir] * alpha_this_line + alpha_ext = alpha_ext + alpha_this_line - intensity_line = intensity_line + alpha_this_line * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) + intensity_line = intensity_line + alpha_this_line * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) intensity_cell = intensity_abs + intensity_sca + intensity_line diff --git a/pinballrt/model.py b/pinballrt/model.py index 1a8942c..c94a9a5 100644 --- a/pinballrt/model.py +++ b/pinballrt/model.py @@ -195,7 +195,8 @@ def scattering_mc(self, nphotons, wavelengths, device="cpu", return_timing=False if return_timing: return timing - def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=None, incl=0, pa=0, distance=1*u.pc, device="cpu"): + def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=None, incl=0, pa=0, distance=1*u.pc, include_dust=True, + include_gas=True, include_sources=True, device="cpu"): """ Create an image from the dust distribution. @@ -226,6 +227,9 @@ def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=No if pixel_size is None: pixel_size = ((1.25*self.grid.grid_size()*self.grid.distance_unit / distance).decompose()*u.radian).to(u.arcsec) / npix + self.grid.grid.include_dust = include_dust + self.grid.grid.include_gas = include_gas + # Check whether spectral is wavelength or frequency if channels.unit.is_equivalent(u.micron): @@ -244,11 +248,13 @@ def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=No # Check which lines from the gas should be included - self.grid.select_lines(lam) + if include_gas: + self.grid.select_lines(lam) # First, run a scattering simulation to get the scattering phase function - self.scattering_mc(100000, lam, device=device) + if include_dust: + self.scattering_mc(100000, lam, device=device) # Now set up the image proper. @@ -275,8 +281,9 @@ def make_image(self, npix=100, pixel_size=None, channels=None, rest_frequency=No intensity = np.array(list(self.pool.map(lambda x: x[0].raytrace(x[1], x[2], nx, ny, image.pixel_size, image.nu).numpy(), zip(self.camera_list[device], np.array_split(new_x, self.ncores), np.array_split(new_y, self.ncores))))).sum(axis=0) - intensity += np.array(list(self.pool.map(lambda camera: camera.raytrace_sources(image.x, image.y, nx, ny, image.nu, distance, - nrays=int(1000/self.ncores)).numpy(), self.camera_list[device]))).mean(axis=0) + if include_sources: + intensity += np.array(list(self.pool.map(lambda camera: camera.raytrace_sources(image.x, image.y, nx, ny, image.nu, distance, + nrays=int(1000/self.ncores)).numpy(), self.camera_list[device]))).mean(axis=0) image = image.assign(intensity=(("x","y","lam"), intensity)) From 8d413fd3fd84da54fd9060083206760cfe8e6edb Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Thu, 4 Dec 2025 16:57:21 +0000 Subject: [PATCH 3/9] Update tests to reflect updates to support spectral line imaging. --- pinballrt/tests/test_E2E.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/pinballrt/tests/test_E2E.py b/pinballrt/tests/test_E2E.py index 71ee42b..ad5e7a9 100644 --- a/pinballrt/tests/test_E2E.py +++ b/pinballrt/tests/test_E2E.py @@ -5,10 +5,8 @@ from pinballrt.utils import calculate_Qvalue import astropy.units as u -import matplotlib.pyplot as plt import numpy as np import xarray as xr -import torch import os import pytest @@ -39,12 +37,19 @@ def test_E2E(grid_class, grid_kwargs, percentile, return_vals=False): density = np.ones(model.grid.shape)*1.0e-16 * u.g / u.cm**3 - model.add_density(density, d) + vx, vy, vz = np.meshgrid(0.5*(model.grid.grid.w1.numpy()[1:] + model.grid.grid.w1.numpy()[0:-1]), + 0.5*(model.grid.grid.w2.numpy()[1:] + model.grid.grid.w2.numpy()[0:-1]), + 0.5*(model.grid.grid.w3.numpy()[1:] + model.grid.grid.w3.numpy()[0:-1]), indexing='ij') + velocity = np.concatenate((vx[np.newaxis], vy[np.newaxis], vz[np.newaxis]), axis=0) * (-1.0 * u.km / u.s) + + model.set_physical_properties(density=density, dust="yso.dst", amax=1.0*u.mm, p=3.5, gases=['co.dat'], + abundances=[1.0e-4], microturbulence=0.2 * u.km / u.s, velocity=velocity) model.add_star(star) model.thermal_mc(nphotons=1000000, use_ml_step=False, Qthresh=1.02, Delthresh=1.02) - image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, lam=np.array([1., 1000.])*u.micron, incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, nphotons=1000000) + image = model.make_image(npix=256, pixel_size=0.2*u.arcsec, channels=np.array([1., 1000.])*u.micron, + incl=45.*u.degree, pa=45.*u.degree, distance=1.*u.pc, nphotons=1000000, include_gas=False) # Do the checks. From 2f304145dafd89655d9e92bf6b28a6fb51f10220 Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Tue, 9 Dec 2025 02:58:13 +0000 Subject: [PATCH 4/9] Put the random selection of a cell for photon emission into a warp kernel to speed it up significantly. --- pinballrt/grids.py | 45 +++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 41 insertions(+), 4 deletions(-) diff --git a/pinballrt/grids.py b/pinballrt/grids.py index 5986aa0..30d8142 100644 --- a/pinballrt/grids.py +++ b/pinballrt/grids.py @@ -129,6 +129,28 @@ def set_physical_properties(self, density=None, dust=None, amax=None, p=None, ga def add_star(self, star): self.star = star + @wp.kernel + def sample_from_cum_lum(grid: GridStruct, + cum_sum: wp.array3d(dtype=float), + cell_coords: wp.array2d(dtype=int), + seed: int, + ): # pragma: no cover + i = wp.tid() + + rng = wp.rand_init(seed, i) + ksi = wp.randf(rng) + + min_cum_sum = float(wp.inf) + + for ix in range(grid.n1): + for iy in range(grid.n2): + for iz in range(grid.n3): + if ksi >= cum_sum[ix,iy,iz] and cum_sum[ix,iy,iz] < min_cum_sum: + min_cum_sum = cum_sum[ix,iy,iz] + cell_coords[i][0] = ix + cell_coords[i][1] = iy + cell_coords[i][2] = iz + def base_emit(self, nphotons, wavelength="random", scattering=False, timing={}): with wp.ScopedDevice(self.device): if scattering: @@ -143,32 +165,47 @@ def base_emit(self, nphotons, wavelength="random", scattering=False, timing={}): cell_coords = [] if scattering: - ksi = np.random.rand(nphotons_per_source) + t1 = time.time() multiplier = 1. / (nphotons_per_source * 100) if self.luminosity.sum() == 0: self.luminosity += EPSILON cum_lum = np.cumsum(np.maximum(self.luminosity, self.luminosity.max()*multiplier).flatten()).reshape(self.shape) / np.maximum(self.luminosity, self.luminosity.max()*multiplier).sum() + t2 = time.time() + timing["cum_lum time"] = t2 - t1 - for i in range(nphotons_per_source): - cell_coords += [np.where(cum_lum[cum_lum > ksi[i]].min() == cum_lum)] - cell_coords = wp.array2d(np.array(cell_coords)[:,:,0], dtype=int) + t1 = time.time() + cell_coords = wp.array2d(np.zeros((nphotons_per_source, 3), dtype=int), dtype=int) + wp.launch(kernel=self.sample_from_cum_lum, + dim=(nphotons_per_source,), + inputs=[self.grid, wp.array3d(cum_lum, dtype=float), cell_coords, np.random.randint(0, 100000)]) + t2 = time.time() + timing["cell coords time"] = t2 - t1 + t1 = time.time() new_position = wp.array(np.zeros((nphotons_per_source,3)), dtype=wp.vec3) wp.launch(kernel=self.random_location_in_cell, dim=(nphotons_per_source,), inputs=[new_position, cell_coords, self.grid, np.random.randint(0, 100000)]) + t2 = time.time() + timing["random loc time"] = t2 - t1 photon_list.position = wp.array(np.concatenate((photon_list.position.numpy(), new_position.numpy()), axis=0), dtype=wp.vec3) + t1 = time.time() new_direction = wp.array(np.zeros((nphotons_per_source, 3)), dtype=wp.vec3) wp.launch(kernel=self.random_direction, dim=(nphotons_per_source,), inputs=[new_direction, torch.arange(nphotons_per_source, dtype=torch.int32, device=wp.device_to_torch(wp.get_device())), np.random.randint(0, 100000)]) photon_list.direction = wp.array(np.concatenate((photon_list.direction.numpy(), new_direction.numpy()), axis=0), dtype=wp.vec3) photon_list.direction_frame = wp.array(np.concatenate((photon_list.direction_frame.numpy(), new_direction.numpy()), axis=0), dtype=wp.vec3) + t2 = time.time() + timing["random dir time"] = t2 - t1 + t1 = time.time() photon_list.frequency = wp.array(np.concatenate([photon_list.frequency.numpy(), np.repeat((const.c / wavelength).to(u.GHz).value, nphotons_per_source)]), dtype=float) photon_list.energy = wp.array(np.concatenate([photon_list.energy.numpy(), np.repeat(self.total_lum/nphotons_per_source, nphotons_per_source).astype(np.float32)]), dtype=float) + t2 = time.time() + timing["set freq/energy time"] = t2 - t1 return photon_list From c2689c58d335a4faa2744f638757f27478aef9ab Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Tue, 9 Dec 2025 11:21:44 +0000 Subject: [PATCH 5/9] Fix the order of the greater than --- pinballrt/grids.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pinballrt/grids.py b/pinballrt/grids.py index 30d8142..75f63c0 100644 --- a/pinballrt/grids.py +++ b/pinballrt/grids.py @@ -145,7 +145,7 @@ def sample_from_cum_lum(grid: GridStruct, for ix in range(grid.n1): for iy in range(grid.n2): for iz in range(grid.n3): - if ksi >= cum_sum[ix,iy,iz] and cum_sum[ix,iy,iz] < min_cum_sum: + if ksi < cum_sum[ix,iy,iz] and cum_sum[ix,iy,iz] < min_cum_sum: min_cum_sum = cum_sum[ix,iy,iz] cell_coords[i][0] = ix cell_coords[i][1] = iy From 6a3b56a8eebee34c8896f2d8fc564c653cdc4df4 Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Thu, 11 Dec 2025 02:31:40 +0000 Subject: [PATCH 6/9] Separate gas and dust densities, and make density refer to gas; add dustogasratio parameter to enable easily calculating the dust density; ensure that all photons emitted from grid cells fall well within the cell (so they don't end up on the wall) --- pinballrt/grids.py | 54 +++++++++++++++++++------------------ pinballrt/tests/test_E2E.py | 2 +- 2 files changed, 29 insertions(+), 27 deletions(-) diff --git a/pinballrt/grids.py b/pinballrt/grids.py index 75f63c0..cb21c79 100644 --- a/pinballrt/grids.py +++ b/pinballrt/grids.py @@ -32,7 +32,8 @@ class GridStruct: mirror_symmetry: bool - density: wp.array3d(dtype=float) + dust_density: wp.array3d(dtype=float) + gas_density: wp.array3d(dtype=float) temperature: wp.array3d(dtype=float) energy: wp.array3d(dtype=float) amax: wp.array3d(dtype=float) @@ -63,15 +64,16 @@ def __init__(self, _w1, _w2, _w3, device='cpu'): self.shape = (self.grid.n1, self.grid.n2, self.grid.n3) - def set_physical_properties(self, density=None, dust=None, amax=None, p=None, gases=None, abundances=None, + def set_physical_properties(self, density=None, dusttogasratio=0.01, dust=None, amax=None, p=None, gases=None, abundances=None, velocity=None, microturbulence=None): with wp.ScopedDevice(self.device): if density is not None: - self.grid.density = wp.array3d((density * dust.kmean).to(1. / self.distance_unit).value, dtype=float) + self.grid.dust_density = wp.array3d((density * dusttogasratio * dust.kmean).to(1. / self.distance_unit).value, dtype=float) + self.grid.gas_density = wp.array3d(density, dtype=float) self.grid.energy = wp.zeros(density.shape, dtype=float) self.grid.temperature = wp.array3d(np.ones(density.shape) * 0.1, dtype=float) - self.mass = (density * self.volume.cpu().numpy() * self.distance_unit**3).decompose() + self.dust_mass = (density * dusttogasratio * self.volume.cpu().numpy() * self.distance_unit**3).decompose() if amax is not None: if isinstance(amax, (int, float)): @@ -232,7 +234,7 @@ def tau_distance_scattering(grid: GridStruct, ix, iy, iz = photon_list.indices[ip][0], photon_list.indices[ip][1], photon_list.indices[ip][2] - photon_list.alpha[ip] = grid.density[ix,iy,iz] * photon_list.ksca[ip] + photon_list.alpha[ip] = grid.dust_density[ix,iy,iz] * photon_list.ksca[ip] distances[ip] = photon_list.tau[ip] / photon_list.alpha[ip] @wp.kernel @@ -339,7 +341,7 @@ def photon_cell_properties(photon_list: PhotonList, ix, iy, iz = photon_list.indices[ip][0], photon_list.indices[ip][1], photon_list.indices[ip][2] photon_list.temperature[ip] = grid.temperature[ix, iy, iz] - photon_list.density[ip] = grid.density[ix, iy, iz] + photon_list.density[ip] = grid.dust_density[ix, iy, iz] photon_list.amax[ip] = grid.amax[ix, iy, iz] photon_list.p[ip] = grid.p[ix, iy, iz] @@ -463,9 +465,9 @@ def update_grid(self, timing={}): temperature = ((total_energy*u.L_sun).cgs.value / (4*const.sigma_sb.cgs.value*\ planck_mean_opacity*\ - self.mass.cgs.value))**0.25 + self.dust_mass.cgs.value))**0.25 - temperature[np.logical_or(temperature < 0.1, self.mass.value == 0)] = 0.1 + temperature[np.logical_or(temperature < 0.1, self.dust_mass.value == 0)] = 0.1 if (np.abs(old_temperature - temperature) / old_temperature).max() < 1.0e-2: converged = True @@ -481,7 +483,7 @@ def initialize_luminosity_array(self, wavelength): for i in range(self.shape[0]): for j in range(self.shape[1]): for k in range(self.shape[2]): - self.luminosity[i,j,k] = (4*np.pi*u.steradian*self.grid.density.numpy()[i,j,k]*self.volume.cpu().numpy()[i,j,k]*self.dust.interpolate_kabs(nu)*self.distance_unit**2*models.BlackBody(temperature=self.grid.temperature.numpy()[i,j,k]*u.K)(nu)).to(u.au**2 * u.Jy).value + self.luminosity[i,j,k] = (4*np.pi*u.steradian*self.grid.dust_density.numpy()[i,j,k]*self.volume.cpu().numpy()[i,j,k]*self.dust.interpolate_kabs(nu)*self.distance_unit**2*models.BlackBody(temperature=self.grid.temperature.numpy()[i,j,k]*u.K)(nu)).to(u.au**2 * u.Jy).value self.total_lum = self.luminosity.sum() @@ -946,7 +948,7 @@ def calculate_level_populations(self, igas, iline): a_microturb = self.grid.microturbulence.numpy() * u.km / u.s inv_gamma = (1.0 / (gas.nu[iline] / const.c * np.sqrt(a_thermal**2 + a_microturb**2))).decompose().to(1./u.GHz) - number_density = ((self.grid.density.numpy() * 1./self.distance_unit / self.dust.kmean) * self.gas_abundances[igas] / (gas.mass * const.m_p)).decompose() + number_density = (self.grid.gas_density.numpy() * self.gas_abundances[igas] / (gas.mass * const.m_p)).decompose() # Alpha for this line in this cell # alpha = c^2/(8*pi*nu^2) * A * n * (n_l * g_u/g_l - n_u) * inv_gamma / sqrt(pi) @@ -973,11 +975,11 @@ def add_intensity(ray_list: PhotonList, alpha_sca = 0. if grid.include_dust: - tau_cell = tau_cell + s[ir]*ray_list.kext[iray,inu]*grid.density[ix,iy,iz] - alpha_ext = alpha_ext + ray_list.kext[iray,inu]*grid.density[ix,iy,iz] - alpha_sca = alpha_sca + ray_list.kext[iray,inu]*ray_list.ray_albedo[iray,inu]*grid.density[ix,iy,iz] + tau_cell = tau_cell + s[ir]*ray_list.kext[iray,inu]*grid.dust_density[ix,iy,iz] + alpha_ext = alpha_ext + ray_list.kext[iray,inu]*grid.dust_density[ix,iy,iz] + alpha_sca = alpha_sca + ray_list.kext[iray,inu]*ray_list.ray_albedo[iray,inu]*grid.dust_density[ix,iy,iz] intensity_abs = intensity_abs + ray_list.kext[iray,inu] * (1. - ray_list.ray_albedo[iray,inu]) * \ - grid.density[ix,iy,iz] * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) + grid.dust_density[ix,iy,iz] * planck_function(ray_list.frequency[inu], grid.temperature[ix,iy,iz]) albedo_total = alpha_sca / alpha_ext @@ -1015,7 +1017,7 @@ def reduce_source_intensity(ray_list: PhotonList, ix, iy, iz = ray_list.indices[ir][0], ray_list.indices[ir][1], ray_list.indices[ir][2] - ray_list.intensity[ir, inu] = ray_list.intensity[ir, inu] * wp.exp(-s[ir] * ray_list.kext[ir, inu] * grid.density[ix, iy, iz]) + ray_list.intensity[ir, inu] = ray_list.intensity[ir, inu] * wp.exp(-s[ir] * ray_list.kext[ir, inu] * grid.dust_density[ix, iy, iz]) def propagate_rays(self, ray_list: PhotonList, frequency, pixel_size): with wp.ScopedDevice(self.device): @@ -1192,9 +1194,9 @@ def random_location_in_cell(position: wp.array(dtype=wp.vec3), rng = wp.rand_init(seed, ip) - position[ip][0] = grid.w1[ix] + (grid.w1[ix+1] - grid.w1[ix])*wp.randf(rng) - position[ip][1] = grid.w2[iy] + (grid.w2[iy+1] - grid.w2[iy])*wp.randf(rng) - position[ip][2] = grid.w3[iz] + (grid.w3[iz+1] - grid.w3[iz])*wp.randf(rng) + position[ip][0] = grid.w1[ix] + (grid.w1[ix+1] - grid.w1[ix])*max(min(wp.randf(rng), 0.999), 0.001) + position[ip][1] = grid.w2[iy] + (grid.w2[iy+1] - grid.w2[iy])*max(min(wp.randf(rng), 0.999), 0.001) + position[ip][2] = grid.w3[iz] + (grid.w3[iz+1] - grid.w3[iz])*max(min(wp.randf(rng), 0.999), 0.001) @wp.kernel def next_wall_distance(photon_list: PhotonList, @@ -1264,7 +1266,7 @@ def minimum_wall_distance(photon_list: PhotonList, if sz2 < s: s = sz2 - if s * photon_list.kabs[ip] * grid.density[ix, iy, iz] < 10.**log10_tau_min: + if s * photon_list.kabs[ip] * grid.dust_density[ix, iy, iz] < 10.**log10_tau_min: s = 0. max_tau_distance = 10.**log10_tau_max / photon_list.alpha[ip] @@ -1518,9 +1520,9 @@ def random_location_in_cell(position: wp.array(dtype=wp.vec3), rng = wp.rand_init(seed, ip) - r = grid.w1[ix] + wp.randf(rng) * (grid.w1[ix+1] - grid.w1[ix]) - theta = grid.w2[iy] + wp.randf(rng) * (grid.w2[iy+1] - grid.w2[iy]) - phi = grid.w3[iz] + wp.randf(rng) * (grid.w3[iz+1] - grid.w3[iz]) + r = grid.w1[ix] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.w1[ix+1] - grid.w1[ix]) + theta = grid.w2[iy] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.w2[iy+1] - grid.w2[iy]) + phi = grid.w3[iz] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.w3[iz+1] - grid.w3[iz]) position[ip][0] = r * wp.sin(theta) * wp.cos(phi) position[ip][1] = r * wp.sin(theta) * wp.sin(phi) @@ -1666,7 +1668,7 @@ def minimum_wall_distance(photon_list: PhotonList, if sp < s: s = sp - if s * photon_list.kabs[ip] * grid.density[iw1, iw2, iw3] < log10_tau_min: + if s * photon_list.kabs[ip] * grid.dust_density[iw1, iw2, iw3] < log10_tau_min: s = 0. max_tau_distance = log10_tau_max / photon_list.alpha[ip] @@ -1999,9 +2001,9 @@ def random_location_in_cell(position: wp.array(dtype=wp.vec3), if ix == 0: r = 10.**(wp.randf(rng) * grid.logw1[ix]) else: - r = 10.**(grid.logw1[ix-1] + wp.randf(rng) * (grid.logw1[ix] - grid.logw1[ix-1])) - theta = grid.w2[iy] + wp.randf(rng) * (grid.w2[iy+1] - grid.w2[iy]) - phi = grid.w3[iz] + wp.randf(rng) * (grid.w3[iz+1] - grid.w3[iz]) + r = 10.**(grid.logw1[ix-1] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.logw1[ix] - grid.logw1[ix-1])) + theta = grid.w2[iy] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.w2[iy+1] - grid.w2[iy]) + phi = grid.w3[iz] + max(min(wp.randf(rng), 0.999), 0.001) * (grid.w3[iz+1] - grid.w3[iz]) position[ip][0] = r * wp.sin(theta) * wp.cos(phi) position[ip][1] = r * wp.sin(theta) * wp.sin(phi) diff --git a/pinballrt/tests/test_E2E.py b/pinballrt/tests/test_E2E.py index ad5e7a9..cf4452f 100644 --- a/pinballrt/tests/test_E2E.py +++ b/pinballrt/tests/test_E2E.py @@ -35,7 +35,7 @@ def test_E2E(grid_class, grid_kwargs, percentile, return_vals=False): # Set up the grid. model = Model(grid=grid_class, grid_kwargs=grid_kwargs) - density = np.ones(model.grid.shape)*1.0e-16 * u.g / u.cm**3 + density = np.ones(model.grid.shape)*1.0e-14 * u.g / u.cm**3 vx, vy, vz = np.meshgrid(0.5*(model.grid.grid.w1.numpy()[1:] + model.grid.grid.w1.numpy()[0:-1]), 0.5*(model.grid.grid.w2.numpy()[1:] + model.grid.grid.w2.numpy()[0:-1]), From 7c16ba00b63ae18d79f6eb53ad6dd671676cf48f Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Thu, 11 Dec 2025 10:51:41 +0000 Subject: [PATCH 7/9] Slightly relax image tolerance for tests. --- pinballrt/tests/test_E2E.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pinballrt/tests/test_E2E.py b/pinballrt/tests/test_E2E.py index cf4452f..d730b54 100644 --- a/pinballrt/tests/test_E2E.py +++ b/pinballrt/tests/test_E2E.py @@ -65,7 +65,7 @@ def test_E2E(grid_class, grid_kwargs, percentile, return_vals=False): base_image = xr.open_dataset(os.path.join(os.path.dirname(__file__), f"data/{grid_class.__name__}_E2E_image.nc")) Q = calculate_Qvalue(image.intensity, base_image.intensity, percentile=100.0, clip=0.1) - assert Q < 1.02, f"Image difference exceeds tolerance: {Q}" + assert Q < 1.03, f"Image difference exceeds tolerance: {Q}" else: return model.grid.grid.temperature.numpy(), model.grid.scattering.numpy(), image From 1b53b68d70829d4520670aee441c62ec7f7157ce Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Thu, 11 Dec 2025 13:30:33 +0000 Subject: [PATCH 8/9] Update demo now that gas and dust are separate (and the density specified corresponds to the gas) --- examples/pinball-demo.ipynb | 70 ++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 35 deletions(-) diff --git a/examples/pinball-demo.ipynb b/examples/pinball-demo.ipynb index b484b7f..8377152 100644 --- a/examples/pinball-demo.ipynb +++ b/examples/pinball-demo.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "6ced7049", "metadata": {}, "outputs": [], @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "a8890f61", "metadata": {}, "outputs": [ @@ -41,7 +41,11 @@ "text": [ "Warp CUDA error: Could not open libcuda.so.\n", "Warp CUDA error: Function cuDriverGetVersion_f: a suitable driver entry point was not found\n", - "Warp CUDA error 36 (in function cuda_driver_version, /builds/omniverse/warp/warp/native/warp.cu:1719)\n" + "Warp CUDA error 36 (in function cuda_driver_version, /builds/omniverse/warp/warp/native/warp.cu:1719)\n", + "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", + "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", + " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n" ] }, { @@ -64,10 +68,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", - " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", - "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", - " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in expm1\n", " result = super().__array_ufunc__(function, method, *arrays, **kwargs)\n", "/opt/conda/envs/warp/lib/python3.13/site-packages/astropy/units/quantity.py:658: RuntimeWarning: overflow encountered in multiply\n", @@ -78,7 +78,7 @@ "source": [ "model = Model(grid=UniformCartesianGrid, grid_kwargs={\"ncells\":9, \"dx\":2.0*u.au})\n", "\n", - "density = np.ones(model.grid.shape)*1.0e-16 * u.g / u.cm**3\n", + "density = np.ones(model.grid.shape)*1.0e-14 * u.g / u.cm**3\n", "density[4,4,4] = 0.0 * u.g / u.cm**3 # Create a low-density cavity in the center\n", "\n", "vx, vy, vz = np.meshgrid(0.5*(model.grid.grid.w1.numpy()[1:] + model.grid.grid.w1.numpy()[0:-1]), \n", @@ -92,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "7bc813aa", "metadata": {}, "outputs": [], @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "47dca2cd", "metadata": {}, "outputs": [ @@ -113,17 +113,17 @@ "output_type": "stream", "text": [ "Iteration 0\n", - "Module pinballrt.sources 1808836 load on device 'cpu' took 404.25 ms (cached)\n", - "Module pinballrt.grids 1f99f97 load on device 'cpu' took 11264.78 ms (compiled)\n", - "Module pinballrt.utils 08b2efb load on device 'cpu' took 142.21 ms (cached)\n" + "Module pinballrt.sources 1808836 load on device 'cpu' took 1.43 ms (cached)\n", + "Module pinballrt.grids 53af283 load on device 'cpu' took 0.46 ms (cached)\n", + "Module pinballrt.utils 08b2efb load on device 'cpu' took 0.29 ms (cached)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:06<00:00, 144701.82it/s]\n", - "/workspaces/pinball-warp/pinballrt/grids.py:427: RuntimeWarning: invalid value encountered in divide\n", + "100%|██████████| 1000000/1000000 [00:06<00:00, 148369.58it/s]\n", + "/workspaces/pinball-warp/pinballrt/grids.py:466: RuntimeWarning: invalid value encountered in divide\n", " temperature = ((total_energy*u.L_sun).cgs.value / (4*const.sigma_sb.cgs.value*\\\n" ] }, @@ -139,7 +139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:15<00:00, 63025.44it/s]\n" + "100%|██████████| 1000000/1000000 [00:15<00:00, 63438.46it/s]\n" ] }, { @@ -154,14 +154,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [00:48<00:00, 20573.71it/s]\n" + "100%|██████████| 1000000/1000000 [00:48<00:00, 20424.26it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2 1.5740279 3.8487184\n", + "2 1.5704488 3.8647785\n", "Iteration 3\n" ] }, @@ -169,14 +169,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:16<00:00, 13062.00it/s]\n" + "100%|██████████| 1000000/1000000 [01:11<00:00, 14001.56it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "3 1.1681706 1.3474299\n", + "3 1.1686034 1.343868\n", "Iteration 4\n" ] }, @@ -184,14 +184,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:23<00:00, 11933.57it/s]\n" + "100%|██████████| 1000000/1000000 [01:21<00:00, 12278.75it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "4 1.0579958 1.1041354\n", + "4 1.0577108 1.1048422\n", "Iteration 5\n" ] }, @@ -199,14 +199,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000000/1000000 [01:29<00:00, 11182.08it/s]" + "100%|██████████| 1000000/1000000 [01:23<00:00, 11998.20it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "5 1.0199475 1.0373042\n" + "5 1.0173565 1.0396658\n" ] }, { @@ -223,13 +223,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "fa5b80fa", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -246,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "32322cc5", "metadata": {}, "outputs": [ @@ -254,30 +254,30 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100000/100000 [00:07<00:00, 13591.78it/s]\n" + "100%|██████████| 100000/100000 [00:07<00:00, 13426.10it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 7.9322240352630615\n" + "Time: 7.5848705768585205\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100000/100000 [00:00<00:00, 563251.64it/s]\n" + "100%|██████████| 100000/100000 [00:00<00:00, 440484.69it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Time: 0.7754969596862793\n", + "Time: 0.3511643409729004\n", "65536\n", - "Module pinballrt.camera 1417a13 load on device 'cpu' took 4.52 ms (cached)\n" + "Module pinballrt.camera 1417a13 load on device 'cpu' took 0.25 ms (cached)\n" ] } ], @@ -287,13 +287,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "837dbdd1", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -309,7 +309,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "028ad375", "metadata": {}, "outputs": [ From 95bd3339b449c8438e830a84f51235979d6d7955 Mon Sep 17 00:00:00 2001 From: Patrick Sheehan Date: Thu, 11 Dec 2025 13:31:01 +0000 Subject: [PATCH 9/9] Make sure the gas density units work out properly --- pinballrt/grids.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pinballrt/grids.py b/pinballrt/grids.py index cb21c79..3feabcb 100644 --- a/pinballrt/grids.py +++ b/pinballrt/grids.py @@ -69,7 +69,7 @@ def set_physical_properties(self, density=None, dusttogasratio=0.01, dust=None, with wp.ScopedDevice(self.device): if density is not None: self.grid.dust_density = wp.array3d((density * dusttogasratio * dust.kmean).to(1. / self.distance_unit).value, dtype=float) - self.grid.gas_density = wp.array3d(density, dtype=float) + self.grid.gas_density = wp.array3d(density.to(u.g / u.cm**3), dtype=float) self.grid.energy = wp.zeros(density.shape, dtype=float) self.grid.temperature = wp.array3d(np.ones(density.shape) * 0.1, dtype=float) @@ -948,7 +948,7 @@ def calculate_level_populations(self, igas, iline): a_microturb = self.grid.microturbulence.numpy() * u.km / u.s inv_gamma = (1.0 / (gas.nu[iline] / const.c * np.sqrt(a_thermal**2 + a_microturb**2))).decompose().to(1./u.GHz) - number_density = (self.grid.gas_density.numpy() * self.gas_abundances[igas] / (gas.mass * const.m_p)).decompose() + number_density = (self.grid.gas_density.numpy()*u.g / u.cm**3 * self.gas_abundances[igas] / (gas.mass * const.m_p)).decompose() # Alpha for this line in this cell # alpha = c^2/(8*pi*nu^2) * A * n * (n_l * g_u/g_l - n_u) * inv_gamma / sqrt(pi)