diff --git a/dummy_sensor.py b/dummy_sensor.py
new file mode 100644
index 0000000000..9e841dbbe8
--- /dev/null
+++ b/dummy_sensor.py
@@ -0,0 +1,42 @@
+import os
+import sys
+
+import drjit as dr
+import mitsuba as mi
+
+class custom_sensor(mi.Sensor):
+    def __init__(self, props):
+        mi.Sensor.__init__(self, props)
+
+        self.rays = dr.zeros(mi.Ray3f)
+        self.weight = mi.Float(0)
+        self.dummy_film = None
+    
+    def sample_ray_differential(self, 
+                                time,   # mi.Float
+                                sample1, #wavelength_sample,  # mi.Float
+                                sample2, #position_sample, 
+                                sample3, #aperture_sample, 
+                                mask: mi.Bool = True):
+
+        return self.rays, self.weight
+
+    def sample_ray(self, 
+                    time,   # mi.Float
+                    wavelength_sample,  # mi.Float
+                    position_sample, 
+                    aperture_sample, 
+                    mask: mi.Bool = True):
+
+        return self.rays, self.weight
+
+    def film(self):
+        return self.dummy_film
+
+    def to_string(self):
+        return ('Custom_sensor[\n'
+                '    ray=%s,\n'
+                '    weight=%s,\n'
+                ']' % (self.rays, self.weight))
+
+mi.register_sensor("custom_sensor", lambda props: custom_sensor(props)) 
diff --git a/src/python/python/loaders/rayloader.py b/src/python/python/loaders/rayloader.py
new file mode 100644
index 0000000000..9c0e488432
--- /dev/null
+++ b/src/python/python/loaders/rayloader.py
@@ -0,0 +1,264 @@
+from __future__ import annotations as __annotations__ # Delayed parsing of type annotations
+# import matplotlib.pyplot as plt
+import os
+import sys
+#import numpy as np
+root = os.path.dirname(os.path.abspath(__file__))
+print(root)
+sys.path.insert(0, f"{root}/build/python")
+
+import drjit as dr
+import mitsuba as mi
+
+mi.set_variant('cuda_ad_rgb')
+
+class Rayloader():
+    def __init__(self, scene, dummysensor, sensors, image_refs, batch_size, spp):
+        self.scene = scene
+        self.dummysensor = dummysensor
+        self.sensors = sensors
+        self.iteration = 0
+        self.batch_size = batch_size
+        self.permute_seed = 2
+        self.num_sensors = len(sensors)
+        self.image_refs = image_refs
+        if type(image_refs) != list :
+            self.image_refs = [image_refs]
+            
+        self.channel_size = self.image_refs[0].shape[2]
+        
+        # TODO film_size here for different sensors
+        self.film_size = self.sensors[0].film().size()
+        self.spp = spp
+        
+        # Build vectorized pointer type of sensors
+        self.sensors_unique_ptr = dr.zeros(mi.SensorPtr, self.num_sensors)
+        for i in range(self.num_sensors): # Use recorded loop if many sensors
+            dr.scatter(self.sensors_unique_ptr, mi.SensorPtr(self.sensors[i]), i)
+        
+        self.dummy_film = mi.load_dict({
+            'type': 'hdrfilm',
+            'width': self.batch_size,
+            'height': 1,
+            'filter': {'type': 'box'}
+            })
+        self.dummysensor.dummy_film = self.dummy_film
+        
+        # num_pixel_arr: # pixels per sensor
+        # accumulate_num_pixel: for sensor i, # pixels accumulated for aensors 0 to i
+        num_pixel_arr = []
+        self.accumulate_num_pixel = []
+        for i in range(self.num_sensors):
+            num_pixel_arr.append(self.sensors[i].film().size()[0] * self.sensors[i].film().size()[1])
+            self.accumulate_num_pixel.append(dr.sum(num_pixel_arr[0 : i+1]))
+        
+        # total # pixels of all sensors     
+        self.total_num_pixel = dr.sum(num_pixel_arr)
+        
+        #faltten the reference image into 1 N*1 array
+        self.image_ref_flat = dr.zeros(mi.Float, self.total_num_pixel * self.channel_size)
+        start_pixel_idx = 0
+        for i in range(self.num_sensors):
+            self.image_ref_flat[start_pixel_idx * self.channel_size : self.accumulate_num_pixel[i] * self.channel_size] = dr.ravel(self.image_refs[i])
+            start_pixel_idx = self.accumulate_num_pixel[i]
+        
+        # start_accumulate_num_pixel: on i-th position is the # pixels before the i-th sensor
+        self.start_accumulate_num_pixel = mi.UInt32([0] + self.accumulate_num_pixel)    
+        self.accumulate_num_pixel = mi.UInt32(self.accumulate_num_pixel)
+            
+
+    def next(self):
+        
+        # generate seed for permuation in each iteration
+        if (self.iteration * self.batch_size + self.batch_size > self.total_num_pixel):
+            self.iteration = 0
+            self.permute_seed += 3
+            
+        # permuted pixel index of size self.batch_size
+        start = self.iteration * self.batch_size
+        pixel_index = mi.permute_kensler(dr.arange(mi.UInt32, self.batch_size) + start, self.total_num_pixel, self.permute_seed)
+        
+        # TODO pixel indexes for different film sizes of each 
+        sensor_index = pixel_index // (self.film_size[0] * self.film_size[1])
+        
+        num_pixel_base = dr.gather(mi.UInt32, self.start_accumulate_num_pixel, sensor_index)
+        
+        # pixel index within each sensor
+        pixel_index_individual = pixel_index - sensor_index * (self.film_size[0] * self.film_size[1])
+        ray_index = dr.repeat(sensor_index, self.spp)
+
+        sensor_gather = dr.gather(mi.SensorPtr, self.sensors_unique_ptr, ray_index)
+        self.iteration += 1
+
+        sampler, spp = self.prepare(
+                sensor = self.dummysensor,
+                seed = 7,
+                spp = self.spp,
+                aovs=[]
+            )
+
+        ray, weight, pos, _ = self.sample_rays(
+            pixel_index_individual, self.scene, sensor_gather, sampler, self.dummy_film)
+
+        self.dummysensor.rays = ray
+        self.dummysensor.weight = weight
+         
+       
+        
+        # pixel_index_ref: positions of selected pixels in reference image
+        # pixel_index_color: channel positions of selected pixels in reference image
+        pixel_index_ref = num_pixel_base + pixel_index_individual 
+        rgb_index_mask = dr.tile(dr.arange(mi.UInt32, self.channel_size), self.batch_size)
+        pixel_index_color = dr.repeat(pixel_index_ref * self.channel_size, self.channel_size) + rgb_index_mask
+        
+        # reference tensor for the selected pixels
+        ref_tensor = dr.gather(mi.Float, self.image_ref_flat, pixel_index_color)
+        ref_tensor = mi.TensorXf(ref_tensor, shape=(1, self.batch_size, self.channel_size))
+        
+        return ref_tensor
+    
+    def prepare(self,
+                sensor: mi.Sensor,
+                seed: int = 0,
+                spp: int = 0,
+                aovs: list = []):
+
+        film = sensor.film()
+        sampler = sensor.sampler().clone()
+
+        if spp != 0:
+            sampler.set_sample_count(spp)
+
+        spp = sampler.sample_count()
+        sampler.set_samples_per_wavefront(spp)
+
+        film_size = film.crop_size()
+
+        if film.sample_border():
+            film_size += 2 * film.rfilter().border_size()
+
+        wavefront_size = dr.prod(film_size) * spp
+
+        if wavefront_size > 2**32:
+            raise Exception(
+                "The total number of Monte Carlo samples required by this "
+                "rendering task (%i) exceeds 2^32 = 4294967296. Please use "
+                "fewer samples per pixel or render using multiple passes."
+                % wavefront_size)
+
+        sampler.seed(seed, wavefront_size)
+        film.prepare(aovs)
+
+        return sampler, spp
+
+    def sample_rays(
+        self,
+        pixel_index,
+        scene: mi.Scene,
+        sensor: mi.Sensor,
+        sampler: mi.Sampler,
+        dummy_film,
+        reparam: Callable[[mi.Ray3f, mi.UInt32, mi.Bool],
+                          Tuple[mi.Vector3f, mi.Float]] = None
+    ) -> Tuple[mi.RayDifferential3f, mi.Spectrum, mi.Vector2f, mi.Float]:
+        """
+        Sample a 2D grid of primary rays for a given sensor
+
+        Returns a tuple containing
+
+        - the set of sampled rays
+        - a ray weight (usually 1 if the sensor's response function is sampled
+          perfectly)
+        - the continuous 2D image-space positions associated with each ray
+
+        When a reparameterization function is provided via the 'reparam'
+        argument, it will be applied to the returned image-space position (i.e.
+        the sample positions will be moving). The other two return values
+        remain detached.
+        """
+
+        dummy_film_size = dummy_film.crop_size() #[self.batch_size, 1]
+        rfilter = dummy_film.rfilter()
+        
+
+        spp = sampler.sample_count()
+
+        idx = dr.repeat(pixel_index, spp)
+
+        # positions of pixels in each sensor
+        # TODO: for sensors of different film sizes
+        pos = mi.Vector2i()
+        pos.y = idx // self.film_size[0]
+        pos.x = dr.fma(-self.film_size[0], pos.y, idx)
+
+        # Cast to floating point and add random offset
+        pos_f = mi.Vector2f(pos) + sampler.next_2d()
+
+        # Re-scale the position to [0, 1]^2
+        # TODO: for sensors of different film sizes
+        scale = dr.rcp(mi.ScalarVector2f(self.sensors[0].film().crop_size()))
+        offset = -mi.ScalarVector2f(self.sensors[0].film().crop_offset()) * scale
+        pos_adjusted = dr.fma(pos_f, scale, offset)
+
+        aperture_sample = mi.Vector2f(0.0)
+
+        wavelength_sample = 0
+        if mi.is_spectral:
+            wavelength_sample = sampler.next_1d()
+
+        with dr.resume_grad():
+            ray, weight = sensor.sample_ray_differential(
+                mi.Float(0),
+                wavelength_sample,
+                pos_adjusted,
+                aperture_sample,
+                mi.Bool(True)
+            )
+
+        reparam_det = 1.0
+
+        if reparam is not None:
+            if rfilter.is_box_filter():
+                raise Exception(
+                    "ADIntegrator detected the potential for image-space "
+                    "motion due to differentiable shape or camera pose "
+                    "parameters. This is, however, incompatible with the box "
+                    "reconstruction filter that is currently used. Please "
+                    "specify a smooth reconstruction filter in your scene "
+                    "description (e.g. 'gaussian', which is actually the "
+                    "default)")
+
+            # This is less serious, so let's just warn once
+            if not self.sensors[0].film().sample_border() and self.sample_border_warning:
+                self.sample_border_warning = True
+
+                mi.Log(mi.LogLevel.Warn,
+                    "ADIntegrator detected the potential for image-space "
+                    "motion due to differentiable shape or camera pose "
+                    "parameters. To correctly account for shapes entering "
+                    "or leaving the viewport, it is recommended that you set "
+                    "the film's 'sample_border' parameter to True.")
+
+            with dr.resume_grad():
+                # Reparameterize the camera ray
+                reparam_d, reparam_det = reparam(ray=dr.detach(ray),
+                                                 depth=mi.UInt32(0))
+
+                # TODO better understand why this is necessary
+                # Reparameterize the camera ray to handle camera translations
+                if dr.grad_enabled(ray.o):
+                    reparam_d, _ = reparam(ray=ray, depth=mi.UInt32(0))
+
+                # Create a fake interaction along the sampled ray and use it to
+                # recompute the position with derivative tracking
+                it = dr.zeros(mi.Interaction3f)
+                it.p = ray.o + reparam_d
+                ds, _ = sensor.sample_direction(it, aperture_sample)
+
+                # Return a reparameterized image position
+                pos_f = ds.uv + self.sensors[0].film().crop_offset()
+
+        # With box filter, ignore random offset to prevent numerical instabilities
+        splatting_pos = mi.Vector2f(pos) if rfilter.is_box_filter() else pos_f
+        
+        return ray, weight, splatting_pos, reparam_det
\ No newline at end of file
diff --git a/src/render/python/sensor_v.cpp b/src/render/python/sensor_v.cpp
index 1646f877a4..0f91c3547e 100644
--- a/src/render/python/sensor_v.cpp
+++ b/src/render/python/sensor_v.cpp
@@ -100,7 +100,6 @@ template <typename Ptr, typename Cls> void bind_sensor_generic(Cls &cls) {
     .def("sample_ray_differential",
             [](Ptr ptr, Float time, Float sample1, const Point2f &sample2,
                const Point2f &sample3, Mask active) {
-                std::cout << "Hellooo !! " << std::endl;
                 return ptr->sample_ray_differential(time, sample1, sample2, sample3, active);
             },
             "time"_a, "sample1"_a, "sample2"_a, "sample3"_a, "active"_a = true,
diff --git a/test.ipynb b/test.ipynb
new file mode 100644
index 0000000000..bc69794d8c
--- /dev/null
+++ b/test.ipynb
@@ -0,0 +1,46 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'mitssuba'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[1;32md:\\semester project\\test.ipynb Cell 1\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/semester%20project/test.ipynb#W0sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmitssuba\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mmi\u001b[39;00m\n",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'mitssuba'"
+     ]
+    }
+   ],
+   "source": [
+    "import mitsuba as mi"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mitsuba_test",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/volume_optimization.ipynb b/volume_optimization.ipynb
new file mode 100644
index 0000000000..d7ded48477
--- /dev/null
+++ b/volume_optimization.ipynb
@@ -0,0 +1,532 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f53b58d7-4a4c-41cd-b689-c42462d7c464",
+   "metadata": {},
+   "source": [
+    "# Volumetric inverse rendering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c00d2cc-3e22-464c-bf13-cf703e29cf23",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "In this tutorial, we use Mitsuba's differentiable volumetric path tracer to optimize a scattering volume to match a set of (synthetic) reference images. We will optimize a 3D volume density that's stored on a regular grid. The optimization will account for both direct and indirect illumination by using [path replay backpropagation][1] to compute derivatives of delta tracking and volumetric multiple scattering. The reconstructed volume parameters can then for example be re-rendered using novel illumination conditions.\n",
+    "\n",
+    "\n",
+    "<div class=\"admonition important alert alert-block alert-success\">\n",
+    "\n",
+    "🚀 **You will learn how to:**\n",
+    "    \n",
+    "<ul>\n",
+    "  <li>Construct a scene with volumes</li>\n",
+    "  <li>Optimize a volume grid to match a set of reference images</li>\n",
+    "  <li>Upscale the optimized parameters during the optimization</li>\n",
+    "</ul>\n",
+    "    \n",
+    "</div>\n",
+    "\n",
+    "[1]: https://rgl.epfl.ch/publications/Vicini2021PathReplay"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "644bbd28-7d4b-4494-8926-d8a1e892d69d",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "As always, we start with the usual imports and set a variant that supports automatic differentation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83ec80cc-d2a5-46da-83bd-cd66f8947a23",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import os, sys\n",
+    "root = os.path.abspath(\"\")\n",
+    "sys.path.insert(0, f\"{root}/build/python\")\n",
+    "sys.path.insert(0, f\"{root}/src/python/python/loaders\")\n",
+    "\n",
+    "import drjit as dr\n",
+    "import mitsuba as mi\n",
+    "\n",
+    "mi.set_variant('llvm_ad_rgb')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbd1cb4f-c4e5-4bf7-9b24-417c4ee080a9",
+   "metadata": {},
+   "source": [
+    "## Creating multiple sensors\n",
+    "\n",
+    "We cannot hope to obtain a robust volumetric reconstruction using only a single reference image. Multiple viewpoints are needed to sufficiently constrain the reconstructed volume density.  Using a multi-view optimization we can recover volume parameters that generalize to novel views (and illumination conditions).\n",
+    "\n",
+    "In this tutorial, we use 5 sensors placed on a half circle around the origin. For the simple optimization in this tutorial this is sufficient, but more complex scenes may require using significantly more views (e.g., using 50-100 sensors is not unreasonable)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10333b5e-eb4a-4b97-bb97-7895f2d8cd0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mitsuba import ScalarTransform4f as T\n",
+    "\n",
+    "sensor_count = 5\n",
+    "sensors_dict = {\n",
+    "    'type': 'batch',\n",
+    "    'film': {\n",
+    "            'type': 'hdrfilm',\n",
+    "            'width': 64 * sensor_count, 'height': 64,\n",
+    "            'filter': {'type': 'tent'}\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "for i in range(sensor_count):\n",
+    "    angle = 180.0 / sensor_count * i - 90.0\n",
+    "    sensor_rotation = T.rotate([0, 1, 0], angle)\n",
+    "    sensor_to_world = T.look_at(target=[0, 0, 0], origin=[0, 0, 4], up=[0, 1, 0])\n",
+    "    sensors_dict['sensor' + str(i)] = {\n",
+    "        'type': 'perspective',\n",
+    "        'fov': 45,\n",
+    "        'to_world': sensor_rotation @ sensor_to_world,\n",
+    "    }\n",
+    "sensors = mi.load_dict(sensors_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bddf2808-6b4f-49a8-b3c2-3d390c17e406",
+   "metadata": {},
+   "source": [
+    "## Rendering synthetic reference images\n",
+    "\n",
+    "We will now setup a simple scene with a constant environment illumination and a reference volume placed at the origin. The heterogenous volume is instantiated inside of a cube. We assign the `null` BSDF to the cube's surface, since we do not want the cube's surface to interact with light in any way (i.e., the surface should be invisible). To learn more about volume rendering in Mitsuba, please refer to the [plugin documentation][1].\n",
+    "\n",
+    "We then render this scene using the previously created sensors and store the resulting images in a list for later use.\n",
+    "\n",
+    "\n",
+    "[1]: https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_media.html#heterogeneous-medium-heterogeneous"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "021d2244-3224-4da5-a453-328920b8c550",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scene_dict = {\n",
+    "    'type': 'scene',\n",
+    "    'integrator': {'type': 'prbvolpath'},\n",
+    "    'object': {\n",
+    "        'type': 'cube',\n",
+    "        'bsdf': {'type': 'null'},\n",
+    "        'interior': {\n",
+    "            'type': 'heterogeneous',\n",
+    "            'sigma_t': {\n",
+    "                'type': 'gridvolume',\n",
+    "                'filename': './tutorials/scenes/volume.vol',\n",
+    "                'to_world': T.rotate([1, 0, 0], -90).scale(2).translate(-0.5)\n",
+    "            },\n",
+    "            'scale': 40\n",
+    "        }\n",
+    "    },\n",
+    "    'emitter': {'type': 'constant'}\n",
+    "}\n",
+    "\n",
+    "scene_ref = mi.load_dict(scene_dict)\n",
+    "\n",
+    "# Number of samples per pixel for reference images\n",
+    "ref_spp = 512"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffd5b53a-5c17-437a-83d2-6712bbfe1d86",
+   "metadata": {
+    "nbsphinx": "hidden",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# IGNORE THIS: When running under pytest, adjust parameters to reduce computation time\n",
+    "import os\n",
+    "if 'PYTEST_CURRENT_TEST' in os.environ:\n",
+    "    ref_spp = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16008559-86a3-4b9f-80e2-c28ccb5aac37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ref_images = mi.render(scene_ref, sensor=sensors, spp=ref_spp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "142d1dd5-6693-4030-a942-35ff70b7b826",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.imshow(mi.util.convert_to_bitmap(ref_images))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "825f10c4-265e-4f53-9515-7688b142c2db",
+   "metadata": {},
+   "source": [
+    "## Setting up the optimization scene\n",
+    "Our goal is now to optimize a 3D volume density (also called extinction) to match the previously generated reference images. For this we create a second scene, where we replace the reference volume by a simple uniform initialization. \n",
+    "\n",
+    "To initialize a volume grid from Python, we use the [<code>VolumeGrid</code>][2] object in conjunction with [<code>TensorXf</code>][3]. The `VolumeGrid` class is responsible for loading and writing volumes from disk, similar to the `Bitmap` class for images. Using the `grid` property of the [<code>gridvolume</code>][4] plugin, it is possible to pass it directly to the plugin constructor in Python.\n",
+    "\n",
+    "We initialize the extinction `sigma_t` to a low constant value, (e.g. `0.002`). This tends to help the optimization process, as it seems to be easier for the optimizer to increase the volume density rather than remove parts of a very dense volume. \n",
+    "\n",
+    "Note that we use a fairly small initial volume resolution here. This is done on purpose since we will upsample the volume grid during the actual optimization process. As explained later, this typically improves the convexity of the volume optimization problem.\n",
+    "\n",
+    "[1]: https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_media.html#heterogeneous-medium-heterogeneous\n",
+    "[2]: https://mitsuba.readthedocs.io/en/latest/src/api_reference.html#mitsuba.VolumeGrid\n",
+    "[3]: https://mitsuba.readthedocs.io/en/latest/src/api_reference.html#mitsuba.TensorXf\n",
+    "[4]: https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_media.html#grid-based-volume-data-source-gridvolume"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82313a97-a314-43a3-8a4b-f4e32305f1a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v_res = 16\n",
+    "\n",
+    "# Modify the scene dictionary\n",
+    "scene_dict['object'] = {\n",
+    "    'type': 'cube',\n",
+    "    'interior': {\n",
+    "        'type': 'heterogeneous',\n",
+    "        'sigma_t': {\n",
+    "            'type': 'gridvolume',\n",
+    "            'grid': mi.VolumeGrid(dr.full(mi.TensorXf, 0.002, (v_res, v_res, v_res, 1))),\n",
+    "            'to_world': T.translate(-1).scale(2.0)\n",
+    "        },\n",
+    "        'scale': 40.0,\n",
+    "    },\n",
+    "    'bsdf': {'type': 'null'}\n",
+    "}\n",
+    "\n",
+    "scene = mi.load_dict(scene_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5890a714-a81c-4f37-bc9f-7ec2e4335a6a",
+   "metadata": {},
+   "source": [
+    "We load the modified scene and render it for all view angles. Those are going to be our initial image in the optimization process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91050ab4-91ac-413b-89c0-959d024498e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init_images = mi.render(scene, sensor=sensors, spp=ref_spp)\n",
+    "mi.util.convert_to_bitmap(init_images)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a1cf830-9ad3-4bd7-98ca-3840e3179378",
+   "metadata": {},
+   "source": [
+    "## Optimization\n",
+    "\n",
+    "We instantiate an `Adam` optimizer and load the `sigma_t` grid data as parameter to be optimized."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41f4e964-c5f9-4d7d-81d3-e8669bf153c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params = mi.traverse(scene)\n",
+    "\n",
+    "key = 'object.interior_medium.sigma_t.data'\n",
+    "\n",
+    "opt = mi.ad.Adam(lr=0.02)\n",
+    "opt[key] = params[key]\n",
+    "params.update(opt);\n",
+    "\n",
+    "iteration_count = 40\n",
+    "spp = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "963d312f-e883-4e37-ad42-b93c360e51fd",
+   "metadata": {
+    "nbsphinx": "hidden",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# IGNORE THIS: When running under pytest, adjust parameters to reduce computation time\n",
+    "import os\n",
+    "if 'PYTEST_CURRENT_TEST' in os.environ:\n",
+    "    iteration_count = 2\n",
+    "    spp = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "210af9ef-b720-4d60-842a-88daa316db9f",
+   "metadata": {},
+   "source": [
+    "We then run the optimization loop for a few iterations, similar to the other tutorials."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4af17b50-c809-472e-a55d-4b1589a5e84a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for it in range(iteration_count):\n",
+    "    total_loss = 0.0\n",
+    "    # Perform the differentiable light transport simulation\n",
+    "    img = mi.render(scene, params, sensor=sensors, spp=spp, seed=it)\n",
+    "    \n",
+    "    # L2 loss function\n",
+    "    loss = dr.mean(dr.sqr(img - ref_images))\n",
+    "    \n",
+    "    # Backpropagate gradients\n",
+    "    dr.backward(loss)\n",
+    "\n",
+    "    # Take a gradient step\n",
+    "    opt.step()\n",
+    "    \n",
+    "    # Clamp the optimized density values. Since we used the `scale` parameter \n",
+    "    # when instantiating the volume, we are in fact optimizing extinction \n",
+    "    # in a range from [1e-6 * scale, scale].\n",
+    "    opt[key] = dr.clamp(opt[key], 1e-6, 1.0)\n",
+    "    \n",
+    "    # Propagate changes to the scene\n",
+    "    params.update(opt)\n",
+    "    \n",
+    "    total_loss += loss[0]\n",
+    "    print(f\"Iteration {it:02d}: error={total_loss:6f}\", end='\\r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f046cdc9-572e-43a1-b281-3ae65a29097e",
+   "metadata": {},
+   "source": [
+    "## Intermediate results\n",
+    "\n",
+    "We have only performed a few iterations so far and can take a look at the current results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74c3bf2f-21f7-4635-8fce-261a70cd5062",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intermediate_images = mi.render(scene, sensor=sensors, spp=ref_spp)\n",
+    "\n",
+    "fig, axs = plt.subplots(1, 1, figsize=(14, 4))\n",
+    "plt.imshow(mi.util.convert_to_bitmap(intermediate_images))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c597b6e9-ca45-441b-ab6d-9bea4f35d329",
+   "metadata": {},
+   "source": [
+    "## Volume upsampling\n",
+    "\n",
+    "The results above don't look great. One reason is the low resolution of the optimized volume grid. Let's try to increase the resolution of the current grid and continue the optimization for a few more iterations. In practice it is almost always beneficial to leverage such a \"multi-resolution\" approach. At low resolution, the optimization will recover the overall shape, exploring a much simpler solution landscape. Moving on to a volume with a higher resolution allows recovering additional detail, while using the coarser solution as a starting point.\n",
+    "\n",
+    "Luckily Dr.Jit provides [<code>dr.upsample()</code>][1], a functions for up-sampling tensor and texture data. We can easily create a higher resolution volume by passing the current optimzed tensor and specifying the desired shape (must be powers of two when upsampling `TensorXf`).\n",
+    "\n",
+    "[1]: https://drjit.readthedocs.io/en/latest/reference.html#drjit.upsample"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bbdfe9de-d1b2-4d06-89ed-ce2d93d1c383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "opt[key] = dr.upsample(opt[key], shape=(64, 64, 64))\n",
+    "params.update(opt);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "068b99e7-fb72-4b3f-b166-2d7930daf86d",
+   "metadata": {},
+   "source": [
+    "Rendering the new, upsampled volume we can already notice a slight difference in the apparent sharpness. This is due to the *trilinear* interpolation of density values that is used by the volumetric path tracer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "352c5176-ded0-4d13-8996-5d4dbe006c3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "upscale_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(upscale_images[i]))\n",
+    "    axs[i].axis('off')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a86592e8-a87c-497f-8c94-297cfbe06ad5",
+   "metadata": {},
+   "source": [
+    "## Continuing the optimization\n",
+    "\n",
+    "Let's now run our optimization loop for a few more iterations with the upscaled volume grid.\n",
+    "\n",
+    "<div class=\"admonition important alert alert-block alert-info\">\n",
+    "\n",
+    "🗒 **Note**\n",
+    "    \n",
+    "The optimizer automatically resets the internal state (e.g., momentum) associated to the optimized variable when it detects a size change.\n",
+    "\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c8b4e1b-a280-4178-8935-dd5c636aa846",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for it in range(iteration_count):\n",
+    "    total_loss = 0.0\n",
+    "    for sensor_idx in range(sensor_count):\n",
+    "        img = mi.render(scene, params, sensor=sensors[sensor_idx], spp=8*spp, seed=it)\n",
+    "        loss = dr.mean(dr.sqr(img - ref_images[sensor_idx]))\n",
+    "        dr.backward(loss)\n",
+    "        opt.step()\n",
+    "        opt[key] = dr.clamp(opt[key], 1e-6, 1.0)\n",
+    "        params.update(opt)\n",
+    "        total_loss += loss[0]\n",
+    "    print(f\"Iteration {it:02d}: error={total_loss:6f}\", end='\\r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "725e9980-f9c5-416a-a1f1-896e5942716d",
+   "metadata": {},
+   "source": [
+    "## Final results\n",
+    "\n",
+    "Finally we can render the final volume from the different view points and compare the images to the reference images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "57383d4d-780f-4824-a679-5021ca6d6a19",
+   "metadata": {
+    "nbsphinx-thumbnail": {},
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "final_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(2, sensor_count, figsize=(14, 6))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[0][i].imshow(mi.util.convert_to_bitmap(ref_images[i]))\n",
+    "    axs[0][i].axis('off')\n",
+    "    axs[1][i].imshow(mi.util.convert_to_bitmap(final_images[i]))\n",
+    "    axs[1][i].axis('off')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c34cf18c-75c6-4280-a69d-6467023e8cac",
+   "metadata": {},
+   "source": [
+    "Of course the results could be further improved by taking more iterations or adopting other advanced optimization schemes, such as multi-resolution rendering where the rendering resolution is increased throughout the optimization process. Additionally, it can sometimes be beneficial to add a sparsity (e.g., an $L_1$ loss on the density values) or smoothness prior (e.g., a total variation regularizer penalizing differences between neighboring voxels).\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4473987-40c1-4d8a-b133-fc8d7e319420",
+   "metadata": {},
+   "source": [
+    "## See also\n",
+    "\n",
+    "- [<code>prbvolpath</code> plugin](https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_integrators.html#path-replay-backpropagation-volumetric-integrator-prbvolpath)\n",
+    "- [<code>heterogeneous</code> plugin](https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_media.html#heterogeneous-medium-heterogeneous)\n",
+    "- [<code>gridvolume</code> plugin](https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_media.html#grid-based-volume-data-source-gridvolume)\n",
+    "- [<code>mitsuba.VolumeGrid</code>](https://mitsuba.readthedocs.io/en/latest/src/api_reference.html#mitsuba.VolumeGrid)\n",
+    "- [<code>mitsuba.TensorXf</code>](https://mitsuba.readthedocs.io/en/latest/src/api_reference.html#mitsuba.TensorXf)\n",
+    "- [<code>dr.upsample</code>](https://drjit.readthedocs.io/en/latest/reference.html#drjit.upsample)"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "afd680236861e4ad68138f9ddf1f8bff806918beb77b7f0c16179efa24869fce"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/volumetric_dumn_test.ipynb b/volumetric_dumn_test.ipynb
new file mode 100644
index 0000000000..19c85ec9dc
--- /dev/null
+++ b/volumetric_dumn_test.ipynb
@@ -0,0 +1,204 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "root = os.path.abspath(\"\")\n",
+    "sys.path.insert(0, f\"{root}/build/python\")\n",
+    "sys.path.insert(0, f\"{root}/src/python/python/loaders\")\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import drjit as dr\n",
+    "import mitsuba as mi\n",
+    "\n",
+    "mi.set_variant('llvm_ad_rgb')\n",
+    "\n",
+    "from mitsuba import ScalarTransform4f as T\n",
+    "from mitsuba import ScalarTransform4f as T\n",
+    "\n",
+    "from rayloader import Rayloader\n",
+    "import dummy_sensor\n",
+    "\n",
+    "sensor_count = 5\n",
+    "sensors = []\n",
+    "\n",
+    "for i in range(sensor_count):\n",
+    "    angle = 180.0 / sensor_count * i - 90.0\n",
+    "    sensor_rotation = T.rotate([0, 1, 0], angle)\n",
+    "    sensor_to_world = T.look_at(target=[0, 0, 0], origin=[0, 0, 4], up=[0, 1, 0])\n",
+    "    sensors.append(mi.load_dict({\n",
+    "        'type': 'perspective',\n",
+    "        'fov': 45,\n",
+    "        'to_world': sensor_rotation @ sensor_to_world,\n",
+    "        'film': {\n",
+    "            'type': 'hdrfilm',\n",
+    "            'width': 64, 'height': 64,\n",
+    "            'filter': {'type': 'tent'}\n",
+    "        }\n",
+    "    }))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scene_dict = {\n",
+    "    'type': 'scene',\n",
+    "    'integrator': {'type': 'prbvolpath'},\n",
+    "    'object': {\n",
+    "        'type': 'cube',\n",
+    "        'bsdf': {'type': 'null'},\n",
+    "        'interior': {\n",
+    "            'type': 'heterogeneous',\n",
+    "            'sigma_t': {\n",
+    "                'type': 'gridvolume',\n",
+    "                'filename': './tutorials/scenes/volume.vol',\n",
+    "                'to_world': T.rotate([1, 0, 0], -90).scale(2).translate(-0.5)\n",
+    "            },\n",
+    "            'scale': 40\n",
+    "        }\n",
+    "    },\n",
+    "    'emitter': {'type': 'constant'}\n",
+    "}\n",
+    "\n",
+    "scene_ref = mi.load_dict(scene_dict)\n",
+    "\n",
+    "# Number of samples per pixel for reference images\n",
+    "ref_spp = 512"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ref_images = [mi.render(scene_ref, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "#ref_images = mi.render(scene_ref, sensor=sensors, spp=ref_spp)\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(ref_images[i]))\n",
+    "    axs[i].axis('off')\n",
+    "print(ref_images[0].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v_res = 16\n",
+    "\n",
+    "# Modify the scene dictionary\n",
+    "scene_dict['object'] = {\n",
+    "    'type': 'cube',\n",
+    "    'interior': {\n",
+    "        'type': 'heterogeneous',\n",
+    "        'sigma_t': {\n",
+    "            'type': 'gridvolume',\n",
+    "            'grid': mi.VolumeGrid(dr.full(mi.TensorXf, 0.002, (v_res, v_res, v_res, 1))),\n",
+    "            'to_world': T.translate(-1).scale(2.0)\n",
+    "        },\n",
+    "        'scale': 40.0,\n",
+    "    },\n",
+    "    'bsdf': {'type': 'null'}\n",
+    "}\n",
+    "\n",
+    "scene = mi.load_dict(scene_dict)\n",
+    "\n",
+    "init_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(init_images[i]))\n",
+    "    axs[i].axis('off')\n",
+    "\n",
+    "params = mi.traverse(scene)\n",
+    "\n",
+    "key = 'object.interior_medium.sigma_t.data'\n",
+    "\n",
+    "opt = mi.ad.Adam(lr=0.02)\n",
+    "opt[key] = params[key]\n",
+    "params.update(opt);\n",
+    "\n",
+    "iteration_count = 40\n",
+    "spp = 8\n",
+    "\n",
+    "cus_sensor = mi.load_dict({'type': 'custom_sensor',\n",
+    "                           'id': 'cus',\n",
+    "                           }) #FIXME\n",
+    "\n",
+    "# scene is the start scene\n",
+    "ray_loader = Rayloader(scene, cus_sensor, sensors, ref_images, batch_size = 1024, spp = spp)\n",
+    "\n",
+    "for it in range(iteration_count):\n",
+    "    \n",
+    "    ref_tensor = ray_loader.next()\n",
+    "    \n",
+    "    img = mi.render(scene, params, sensor=cus_sensor, spp=spp, seed=it)\n",
+    "\n",
+    "    # L2 loss function\n",
+    "    loss = dr.mean(dr.sqr(img - ref_tensor))\n",
+    "\n",
+    "    # Backpropagate gradients\n",
+    "    dr.backward(loss)\n",
+    "\n",
+    "    # Take a gradient step\n",
+    "    opt.step()\n",
+    "\n",
+    "    # Clamp the optimized density values. Since we used the `scale` parameter\n",
+    "    # when instantiating the volume, we are in fact optimizing extinction\n",
+    "    # in a range from [1e-6 * scale, scale].\n",
+    "    opt[key] = dr.clamp(opt[key], 1e-6, 1.0)\n",
+    "\n",
+    "    # Propagate changes to the scene\n",
+    "    params.update(opt)\n",
+    "    print(f\"Iteration {it:02d}: error={loss[0]:6f}\", end='\\r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intermediate_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(intermediate_images[i]))\n",
+    "    axs[i].axis('off')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "test",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/volumetric_test.ipynb b/volumetric_test.ipynb
new file mode 100644
index 0000000000..4d98ccf859
--- /dev/null
+++ b/volumetric_test.ipynb
@@ -0,0 +1,297 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/simeng/mitsuba3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "root = os.path.abspath(\"\")\n",
+    "sys.path.insert(0, f\"{root}/build/python\")\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import drjit as dr\n",
+    "import mitsuba as mi\n",
+    "\n",
+    "mi.set_variant('llvm_ad_rgb')\n",
+    "\n",
+    "from mitsuba import ScalarTransform4f as T\n",
+    "from mitsuba import ScalarTransform4f as T\n",
+    "\n",
+    "from test_vec import Rayloader\n",
+    "import dummy_sensor\n",
+    "\n",
+    "sensor_count = 5\n",
+    "sensors = []\n",
+    "\n",
+    "for i in range(sensor_count):\n",
+    "    angle = 180.0 / sensor_count * i - 90.0\n",
+    "    sensor_rotation = T.rotate([0, 1, 0], angle)\n",
+    "    sensor_to_world = T.look_at(target=[0, 0, 0], origin=[0, 0, 4], up=[0, 1, 0])\n",
+    "    sensors.append(mi.load_dict({\n",
+    "        'type': 'perspective',\n",
+    "        'fov': 45,\n",
+    "        'to_world': sensor_rotation @ sensor_to_world,\n",
+    "        'film': {\n",
+    "            'type': 'hdrfilm',\n",
+    "            'width': 64, 'height': 64,\n",
+    "            'filter': {'type': 'tent'}\n",
+    "        }\n",
+    "    }))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scene_dict = {\n",
+    "    'type': 'scene',\n",
+    "    'integrator': {'type': 'prbvolpath'},\n",
+    "    'object': {\n",
+    "        'type': 'cube',\n",
+    "        'bsdf': {'type': 'null'},\n",
+    "        'interior': {\n",
+    "            'type': 'heterogeneous',\n",
+    "            'sigma_t': {\n",
+    "                'type': 'gridvolume',\n",
+    "                'filename': './tutorials/scenes/volume.vol',\n",
+    "                'to_world': T.rotate([1, 0, 0], -90).scale(2).translate(-0.5)\n",
+    "            },\n",
+    "            'scale': 40\n",
+    "        }\n",
+    "    },\n",
+    "    'emitter': {'type': 'constant'}\n",
+    "}\n",
+    "\n",
+    "scene_ref = mi.load_dict(scene_dict)\n",
+    "\n",
+    "# Number of samples per pixel for reference images\n",
+    "ref_spp = 512"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ref_images = [mi.render(scene_ref, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "#ref_images = mi.render(scene_ref, sensor=sensors, spp=ref_spp)\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(ref_images[i]))\n",
+    "    axs[i].axis('off')\n",
+    "print(ref_images[0].shape[2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[TensorXf(shape=(2, 5)), TensorXf(shape=(2, 5))]\n",
+      "[0, 1]\n",
+      "[0.0, 1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = mi.TensorXf([1, 1, 5, 2, 2, 6, 3, 3, 7, 4], shape=(2, 5))\n",
+    "b = mi.TensorXf([12, 11, 10, 12, 12, 16, 13, 13, 17, 14], shape=(2, 5))\n",
+    "c = [a, b]\n",
+    "d = [dr.ravel(c[i]) for i in range(2)]\n",
+    "print(dr.ravel(c))\n",
+    "# print(d)\n",
+    "# print(d[0])\n",
+    "# channels = len(c)\n",
+    "# length = dr.width(a[0])\n",
+    "index = dr.arange(mi.Int, 0, 4, 1)\n",
+    "print(index[0:2])\n",
+    "data = dr.zeros(mi.Float, 10)\n",
+    "data[0: 3] = index[0:3]\n",
+    "print(data)\n",
+    "# print(index)\n",
+    "#tempo = dr.gather(mi.Float, data, d[0], index)\n",
+    "# for i in range(channels):\n",
+    "#     dr.scatter(data, d[i], index + i)\n",
+    "#print(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 39: error=0.093535\r"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "v_res = 16\n",
+    "\n",
+    "# Modify the scene dictionary\n",
+    "scene_dict['object'] = {\n",
+    "    'type': 'cube',\n",
+    "    'interior': {\n",
+    "        'type': 'heterogeneous',\n",
+    "        'sigma_t': {\n",
+    "            'type': 'gridvolume',\n",
+    "            'grid': mi.VolumeGrid(dr.full(mi.TensorXf, 0.002, (v_res, v_res, v_res, 1))),\n",
+    "            'to_world': T.translate(-1).scale(2.0)\n",
+    "        },\n",
+    "        'scale': 40.0,\n",
+    "    },\n",
+    "    'bsdf': {'type': 'null'}\n",
+    "}\n",
+    "\n",
+    "scene = mi.load_dict(scene_dict)\n",
+    "\n",
+    "init_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(init_images[i]))\n",
+    "    axs[i].axis('off')\n",
+    "\n",
+    "params = mi.traverse(scene)\n",
+    "\n",
+    "key = 'object.interior_medium.sigma_t.data'\n",
+    "\n",
+    "opt = mi.ad.Adam(lr=0.02)\n",
+    "opt[key] = params[key]\n",
+    "params.update(opt);\n",
+    "\n",
+    "iteration_count = 40\n",
+    "spp = 8\n",
+    "\n",
+    "cus_sensor = mi.load_dict({'type': 'custom_sensor',\n",
+    "                           'id': 'cus',\n",
+    "                           }) #FIXME\n",
+    "\n",
+    "# scene is the start scene\n",
+    "ray_loader = Rayloader(scene, params, cus_sensor, sensors, ref_images, spp = spp)\n",
+    "\n",
+    "for it in range(iteration_count):\n",
+    "    total_loss = 0\n",
+    "    for sensor_idx in range(sensor_count):\n",
+    "        # Perform the differentiable light transport simulation\n",
+    "        img = mi.render(scene, params, sensor=sensors[sensor_idx], spp=spp, seed=it)\n",
+    "\n",
+    "        # L2 loss function\n",
+    "        loss = dr.mean(dr.sqr(img - ref_images[sensor_idx]))\n",
+    "\n",
+    "        # Backpropagate gradients\n",
+    "        dr.backward(loss)\n",
+    "\n",
+    "        # Take a gradient step\n",
+    "        opt.step()\n",
+    "\n",
+    "        # Clamp the optimized density values. Since we used the `scale` parameter\n",
+    "        # when instantiating the volume, we are in fact optimizing extinction\n",
+    "        # in a range from [1e-6 * scale, scale].\n",
+    "        opt[key] = dr.clamp(opt[key], 1e-6, 1.0)\n",
+    "\n",
+    "        # Propagate changes to the scene\n",
+    "        params.update(opt)\n",
+    "\n",
+    "        total_loss += loss[0]\n",
+    "    print(f\"Iteration {it:02d}: error={total_loss:6f}\", end='\\r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "intermediate_images = [mi.render(scene, sensor=sensors[i], spp=ref_spp) for i in range(sensor_count)]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, sensor_count, figsize=(14, 4))\n",
+    "for i in range(sensor_count):\n",
+    "    axs[i].imshow(mi.util.convert_to_bitmap(intermediate_images[i]))\n",
+    "    axs[i].axis('off')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "test",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}