Migrated from GitHub

.gitattributes

@@ -58,3 +58,27 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/eit-data/matlab-code/data/mesh.mat filter=lfs diff=lfs merge=lfs -text
+data/figures/diff_majorant/diff_majorant_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/fd-sdf/fd-sdf_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/fd-sphere/fd-sphere_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/fd_2D/fd_2D_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/fd_3D/fd_3D_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/green/green_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/normal-der/normal-der_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-circle/opt-discrete-circle.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-circle/opt-discrete-circle_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-sdf/opt-discrete-sdf.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-sdf/opt-discrete-sdf_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-sphere-real/opt-discrete-sphere-real.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt-discrete-sphere-real/opt-discrete-sphere-real_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt_coeff_3D/opt_coeff_3D.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/opt_coeff_3D/opt_coeff_3D_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/path_length/path_length_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/radius_decrease/radius_decrease_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/sdf-field/sdf-field_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/figures/sdf-field-zoomed/sdf-field-zoomed_uc.pdf filter=lfs diff=lfs merge=lfs -text
+data/notebooks-2D/solvers/wos/variable/accel/cond.pdf filter=lfs diff=lfs merge=lfs -text
+data/notebooks-2D/solvers/wos/variable/accel/sampling.pdf filter=lfs diff=lfs merge=lfs -text
+data/notebooks-3D/visualization/fd_3D.pdf filter=lfs diff=lfs merge=lfs -text
+data/notebooks-3D/visualization/opt_coeff_3D.pdf filter=lfs diff=lfs merge=lfs -text

data/PDE2D/BoundaryShape/__init__.py

@@ -0,0 +1,8 @@
+from .boundary_shape import *
+from .circle import CircleShape
+from .boundarywithdirichlets import BoundaryWithDirichlets
+from .circlewithelectrodes import CircleWithElectrodes
+from .bezierquadratic import QuadraticBezierShape
+from .sdf_grid import SDFGrid
+from .sdf_utils import *
+from .shape_utils import load_bunny, load_boundary_data

data/PDE2D/BoundaryShape/bezierquadratic.py

@@ -0,0 +1,613 @@
+import mitsuba as mi 
+from mitsuba import Point2f, Bool, Float
+from PDE2D.BoundaryShape.interaction import BoundaryInfo
+from .boundary_shape import *
+from ..utils.helpers import *
+from ..utils.sketch import *
+from .interaction import *
+from ..Coefficient import *
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path as mpath
+
+class QuadraticBezierShape(Shape):
+    ''' Defines the quadratic bezier curve. The neumann boundary part needs to be convex
+        otherwise you will get incorrect results. '''
+    def __init__(self, vertex_positions : np.array, vertex_normals : np.array = None,
+                 dirichlet_map: np.array = None,
+                 vertex_dirichlet_vals : list[Float] = None, vertex_neumann_vals : np.array = None, 
+                 dirichlet: list[Coefficient] = None,
+                 neumann: list[Coefficient] = None,
+                 epsilon=1e-4, name = "boundary", normal_derivative_dist = 0.01,
+                 inside = True, newton_steps = 5, n_segment = 50):
+        super().__init__(np.all(dirichlet_map), single_closed_shape=True, epsilon=epsilon,
+                         inside = inside, derivative_dist=normal_derivative_dist)
+        self.epsilon_neumann = 1e-5
+        self.name = name
+        
+        self.v_p = Point2f(vertex_positions)
+        self.npoints = dr.width(self.v_p)
+
+        if vertex_normals is None:
+            indices = dr.arange(UInt32, self.npoints)
+            p1 = dr.gather(Point2f, self.v_p, (indices-1) % self.npoints)
+            p =  dr.gather(Point2f, self.v_p, (indices) % self.npoints)
+            p2 = dr.gather(Point2f, self.v_p, (indices+1) % self.npoints)
+            vec1 = p2-p
+            vec2 = p1-p
+            self.v_n = -dr.normalize(vec1 + vec2) 
+        else:
+            assert len(vertex_positions) == len(vertex_normals) 
+            self.v_n = Point2f(vertex_normals)
+        
+        dr.make_opaque(self.v_p)
+        dr.make_opaque(self.v_n)
+
+        #self.bbox = [[np.min(vertex_positions[0]), np.min(vertex_positions[1])],
+        #             [np.max(vertex_positions[0]), np.max(vertex_positions[1])]]
+        self.bbox = [[-1, -1],[1,1]]
+        self.bbox_center = Point2f(float(self.bbox[0][0] + self.bbox[1][0]) / 2, float(self.bbox[0][1] + self.bbox[1][1]) / 2)
+        dr.make_opaque(self.bbox_center)
+
+        if dirichlet_map is None:
+            self.dirichlet_map = dr.ones(Bool, self.npoints)
+        else:
+            self.dirichlet_map = Bool(dirichlet_map)
+        dr.make_opaque(self.dirichlet_map)
+
+        self.is_full_dirichlet = dr.all(self.dirichlet_map)
+        self.is_full_neumann = dr.all(~self.dirichlet_map)
+        self.newton_steps = newton_steps
+        self.n_segment = n_segment
+        self.NEE = NEE.BruteForce
+        self.inside = True
+
+        # Number of segments
+        self.n_dirichlet = np.sum(dirichlet_map == True)
+        self.n_neumann = np.sum(dirichlet_map == False)
+
+        if not self.is_full_dirichlet:
+            if (neumann is None) and (vertex_neumann_vals is None):
+                raise Exception("Please specify either a function or vertex neumann values.")
+            elif(neumann is None):
+                self.num_conf_n = len(vertex_neumann_vals)
+                self.v_neumann = dr.zeros(ArrayXf, shape = (self.num_conf_n, self.npoints))
+                for i in range(self.num_conf_n):
+                    assert len(vertex_neumann_vals[i]) == self.npoints
+                    self.v_neumann[i] = Float(vertex_neumann_vals[i])
+                self.neumann = None
+                dr.make_opaque(self.v_neumann)
+            elif vertex_neumann_vals is None:
+                self.num_conf_n = len(neumann)
+                self.neumann = neumann
+                self.v_neumann = None
+            else:
+                raise Exception("Please only specify either a function, or vertex neumann vals, not both.")
+
+        
+        if not self.is_full_neumann:
+            if (dirichlet is None) and (vertex_dirichlet_vals is None):
+                raise Exception("Please specify either a function or vertex dirichlet values.")
+            elif(dirichlet is None):
+                self.num_conf_d = len(vertex_dirichlet_vals)
+                self.v_dirichlet = dr.zeros(ArrayXf, shape = (self.num_conf_d, self.npoints))
+                for i in range(self.num_conf_n):
+                    assert len(vertex_dirichlet_vals[i]) == self.npoints
+                    self.v_dirichlet[i] = Float(vertex_dirichlet_vals[i])
+                self.dirichlet = None
+                dr.make_opaque(self.v_dirichlet)
+            elif vertex_dirichlet_vals is None:
+                self.num_conf_d = len(dirichlet)
+                self.dirichlet = dirichlet
+                self.v_dirichlet = None
+            else:
+                raise Exception("Please only specify either a function, or vertex dirichlet vals, not both.")
+
+        if (not self.is_full_dirichlet) and (not self.is_full_neumann):   
+            assert (self.num_conf_n == self.num_conf_d) or (self.num_conf_n == 1) or (self.num_conf_d == 1)
+
+        if self.is_full_dirichlet:
+            self.num_conf = self.num_conf_d
+        elif self.is_full_neumann:
+            self.num_conf = self.num_conf_n
+        else:
+            self.num_conf = max(self.num_conf_d, self.num_conf_n)
+        self.max_distance = 10
+        self.hasNEE = False
+        self.measureCurrent = False
+
+        # Find the control points of the curve using the normals.
+        self.c_p = dr.zeros(Point2f, self.npoints)
+        for i in range(self.npoints):
+            p1 = dr.gather(Point2f, self.v_p, i)
+            p2 = dr.gather(Point2f, self.v_p, (i+1) % self.npoints)
+            n1 = dr.gather(Point2f, self.v_n, i)
+            n2 = dr.gather(Point2f, self.v_n, (i+1) % self.npoints)
+            t = (n2[1] * (p2[1]-p1[1]) + n2[0] * (p2[0] - p1[0])) / (n2[1]*n1[0] - n1[1]*n2[0])
+            c_p = Point2f(-n1[1] * t + p1[0], n1[0] * t + p1[1])
+            dr.scatter(self.c_p, c_p, i)
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        pass
+    
+    def update(self, optimizer):
+        pass
+    
+    def zero_grad(self):
+        pass
+    
+    
+    def inside_closed_surface(self, points : Point2f, L : Float, conf_numbers : list[UInt32] = None):
+        return self.inside_closed_surface_mask(points), L
+
+    @dr.syntax
+    def inside_closed_surface_mask(self, points : Point2f):
+        dist_min, bpoint, boundary_normal, k_min, t_min = self.get_closest_dist(points)
+        bdir = dr.normalize(bpoint - points)
+        threshold = dr.maximum(self.epsilon, 100 * dr.epsilon(Float))
+        return (dist_min > threshold) & (dr.dot(boundary_normal, bdir) < 0)
+
+    
+
+    def get_interpolation_points(self, n) -> tuple[Point2f, Point2f, Point2f]:
+        p1 = dr.gather(Point2f, self.v_p, n)
+        p2 = dr.gather(Point2f, self.v_p, (n+1) % self.npoints)
+        c = dr.gather(Point2f, self.c_p, n)
+        return p1, p2, c
+    
+    def get_normals(self, n)-> Point2f:
+        return dr.gather(Point2f, self.v_n, n)
+    
+    def interpolate(self, p1 : Point2f, p2 : Point2f, c : Point2f, t : Float) -> Point2f:
+        p1c =  dr.lerp(p1, c, t)
+        p2c =  dr.lerp(c, p2, t)
+        return dr.lerp(p1c, p2c, t)
+    
+    def interpolate_derivative(self, p1: Point2f, p2 : Point2f, c : Point2f, t: Float) -> Point2f:
+        "Compute derivative with respect to t."
+        return -2 * (1 - t) * p1 + 2 * c - 4*c*t + 2 * p2 * t 
+    
+    def interpolate_derivative2(self, p1 : Point2f, p2 : Point2f, c:Point2f, t:Float) -> Point2f:
+        return 2 * p1 + 2 * p2 - 4 * c
+
+    def get_distance2(self, p : Point2f, p1 : Point2f, p2 : Point2f, c : Point2f, t : Float) -> tuple[Float, Float]:
+        "Compute the distance squared to a given t and derivative and 2nd derivative of it."
+        p_t = self.interpolate(p1, p2, c, t)
+        p_t_der = self.interpolate_derivative(p1, p2, c, t)
+        p_t_der2 = self.interpolate_derivative2(p1, p2, c, t)
+        p_diff = p - p_t 
+        dist2 = dr.squared_norm(p_diff)
+        dist2_der = -2 * p_diff * p_t_der
+        dist2_der = dist2_der[0] + dist2_der[1]
+        dist2_der2 = -2 * p_diff * p_t_der2 + 2 * dr.square(p_t_der)
+        dist2_der2 = dist2_der2[0] + dist2_der2[1]
+        return dist2, dist2_der, dist2_der2
+    
+    def min_segment(self, p : Point2f, p1 : Point2f, p2 : Point2f, c : Point2f, i_segment : UInt32, n_segment : UInt32) -> Float:
+        t1 = Float(i_segment) / n_segment
+        t2 = Float(i_segment + 1) / n_segment
+
+        pl1 = self.interpolate(p1, p2, c, t1)
+        pl2 = self.interpolate(p1, p2, c, t2)
+        vec_edge = pl2 - pl1
+        t = dr.clamp(dr.dot((p - pl1), vec_edge) / dr.squared_norm(vec_edge), 0, 1)
+        min_point = dr.lerp(pl1, pl2, t)
+        return dr.norm(min_point - p), t / n_segment + t1
+    
+    @dr.syntax
+    def get_closest_dist_polyline_k(self, p : Point2f, k : UInt32):
+        p1, p2, c = self.get_interpolation_points(k)
+        # First find the intersection point if it was linearly interpolated.
+        i = UInt32(0)
+        dist_min = Float(dr.inf)
+        t = Float(1)
+        i_selected = UInt32(0)
+        while i < self.n_segment:
+            min, t_ = self.min_segment(p, p1, p2, c, i, self.n_segment)
+            if min < dist_min:
+                dist_min = min
+                t = t_
+                i_selected = UInt32(i)
+            i += 1
+        return dist_min, t, i_selected
+    
+    @dr.syntax
+    def get_closest_dist_polyline(self, p : Point2f):
+        i = UInt32(0)
+        dist_min = Float(dr.inf)
+        n_min = UInt32(0)
+        t_min = Float(dr.inf)
+
+        while i < self.npoints:
+            dist, t, _ = self.get_closest_dist_polyline_k(p, i)
+            if dist < dist_min:
+                n_min = i
+                dist_min = dist
+                t_min = t
+            i+=1
+        return dist_min, n_min, t_min
+    
+    @dr.syntax
+    def get_closest_dist_k(self, p : Point2f, k : UInt32):
+        dist_min, t_min, i_min = self.get_closest_dist_polyline_k(p, k)
+        p1, p2, c = self.get_interpolation_points(k)
+
+        
+        a1, a2 = Float(i_min) / self.n_segment, Float(i_min + 1) / self.n_segment
+        # Start to apply Newton's algorithm to set the derivative to zero.
+        i = UInt32(0)
+        dist2 = Float(dr.inf)
+        while i < self.newton_steps:
+            dist2, val, deriv = self.get_distance2(p, p1, p2, c, t_min)
+            dist_min = dr.sqrt(dist2)
+            t_min = t_min - val / deriv
+
+            # Newton-Bisection: potentially reject the Newton step
+            bad_step = ~((t_min >= a1) & (t_min <= a2))
+            t_min = dr.select(bad_step, (a1 + a2) / 2, t_min)
+
+            # Update bracketing interval
+            is_neg = self.get_distance2(p, p1, p2, c, t_min)[1]  < 0
+            a1 = dr.select(is_neg, t_min, a1)
+            a2 = dr.select(is_neg, a2, t_min)
+
+            t_min = dr.clamp(t_min, 0, 1)
+            i += 1
+        bpoint = self.interpolate(p1, p2, c, t_min)
+
+        boundary_normal = self.interpolate_derivative(p1, p2, c, t_min)
+        boundary_normal = dr.normalize(Point2f(-boundary_normal[1], boundary_normal[0]))
+
+        aprox_n1 = self.get_normals(k)
+        aprox_n2 = self.get_normals((k + 1) % self.npoints)
+        aprox_n = dr.lerp(aprox_n1, aprox_n2, t_min)
+        if dr.dot(aprox_n, boundary_normal) < 0:
+            boundary_normal = -boundary_normal
+
+        if dr.hint(self.inside, mode = "scalar"):
+            boundary_normal = -boundary_normal
+
+        return dist_min, bpoint, boundary_normal, t_min
+
+    
+    @dr.syntax
+    def get_closest_dist(self, p : Point2f):
+        # First get the closest point if it was linearly interpolated and find t.
+        dist_min, k_min, t_min = self.get_closest_dist_polyline(p)
+        p1, p2, c = self.get_interpolation_points(k_min)
+        
+        # Start to apply Newton's algorithm to set the derivative to zero.
+        i = UInt32(0)
+        dist2 = Float(dr.inf)
+        while i < self.newton_steps:
+            dist2, val, deriv = self.get_distance2(p, p1, p2, c, t_min)
+            dist_min = dr.sqrt(dist2)
+            t_min = t_min - val / deriv
+            t_min = dr.clamp(t_min, 0, 1)
+            # if t is smaller than 0 or greater than one, it means we changed the segment.
+            if t_min<0:
+                k_min = (k_min-1) % self.npoints
+                t_min = Float(1)
+                p1, p2, c = self.get_interpolation_points(k_min)
+            elif t_min>1:
+                k_min = (k_min+1) % self.npoints
+                t_min = Float(0)
+                p1, p2, c = self.get_interpolation_points(k_min)
+            i += 1
+        bpoint = self.interpolate(p1, p2, c, t_min)
+        boundary_normal = self.interpolate_derivative(p1, p2, c, t_min)
+        boundary_normal = dr.normalize(Point2f(-boundary_normal[1], boundary_normal[0]))
+
+        aprox_n1 = self.get_normals(k_min)
+        aprox_n2 = self.get_normals((k_min + 1) % self.npoints)
+        aprox_n = dr.lerp(aprox_n1, aprox_n2, t_min)
+        if dr.dot(aprox_n, boundary_normal) < 0:
+            boundary_normal = -boundary_normal
+
+        if dr.hint(self.inside, mode = "scalar"):
+            boundary_normal = -boundary_normal
+        return dist_min, bpoint, boundary_normal, k_min, t_min
+    
+    @dr.syntax
+    def boundary_interaction(self, points: Point2f, radius_fnc: callable = None, 
+                             max_radius=Float(dr.inf) , star_generation=True, 
+                             conf_numbers : list[UInt32] = [UInt32(0)]) -> BoundaryInfo:
+        if dr.hint(self.is_full_dirichlet, mode = "scalar"):
+            closest_dist, closest_bpoint, closest_bnormal, k_all, t_min_all = self.get_closest_dist(points)
+            k_dirichlet, t_min_dirichlet = Float(k_all), Float(t_min_all)
+            closest_bpoint_dirichlet = closest_bpoint
+            closest_dirichlet = closest_dist
+            is_dirichlet = Bool(True)
+            is_neumann = Bool(False)
+        elif dr.hint(self.is_full_neumann, mode = "scalar"):
+            closest_dist, closest_bpoint, closest_bnormal, k_all, t_min_all = self.get_closest_dist(points)
+            closest_dirichlet = Point2f(dr.inf)
+            closest_bpoint_dirichlet = Point2f(dr.nan)
+            is_dirichlet = Bool(False)
+            is_neumann = Bool(True)
+        else:
+            is_dirichlet = Bool(True)
+            i = UInt32(0)
+            k_dirichlet = UInt32(0)
+            k_all = UInt32(0)
+            closest_dist = Float(dr.inf)
+            closest_dirichlet = Float(dr.inf)
+            closest_bpoint = Point2f(dr.nan)
+            closest_bpoint_dirichlet = Point2f(dr.nan)
+            closest_bnormal = Point2f(dr.nan)
+            t_min_dirichlet = Float(dr.inf)
+            t_min_all = Float(dr.inf)
+            while i < self.npoints:
+                d, bpoint, bnormal, t = self.get_closest_dist_k(points, i)
+                if d<closest_dist:
+                    closest_dist = d
+                    closest_bpoint = bpoint
+                    closest_bnormal = bnormal
+                    k_all = i
+                    t_min_all = t
+                    is_dirichlet = dr.gather(Bool, self.dirichlet_map, i)
+                if (d < closest_dirichlet) &  dr.gather(Bool, self.dirichlet_map, i):
+                    closest_dirichlet = d
+                    closest_bpoint_dirichlet = bpoint
+                    t_min_dirichlet = t
+                    k_dirichlet = i
+
+                #if closest_dist < closest_dirichlet:
+                #    is_dirichlet = Bool(False)
+                i += 1
+                
+            merge_dirichlet = (closest_dirichlet < (100*dr.epsilon(Float))) 
+            is_dirichlet |=  merge_dirichlet 
+            is_neumann = ~is_dirichlet 
+            
+        num_conf = len(conf_numbers)
+        nearest_dirichlet_val = dr.zeros(ArrayXf, shape = (num_conf, dr.width(points)))
+        if dr.hint(not self.is_full_neumann, mode = "scalar"):
+            if dr.hint(self.v_dirichlet is None, mode = "scalar"):    
+                    if dr.hint(self.num_conf_d == 1, mode = 'scalar'):
+                        dirichlet = self.dirichlet[0].get_value(closest_bpoint_dirichlet)
+                        for i in range(num_conf):
+                            nearest_dirichlet_val[i] = dirichlet
+                    else:
+                        for i in range(self.num_conf_d): 
+                            for j, conf in enumerate(conf_numbers):
+                                if i == conf:
+                                    nearest_dirichlet_val[j] = self.dirichlet[i].get_value(closest_bpoint_dirichlet)
+            else:
+                nearest_dirichlet_all = self.get_dirichlet_vertices(k_dirichlet, t_min_dirichlet)
+                if dr.hint(self.num_conf_d == 1, mode = 'scalar'):
+                    nearest_dirichlet_val = nearest_dirichlet_all
+                else:
+                    for i in range(self.num_conf_d): 
+                            for j, conf in enumerate(conf_numbers):
+                                if i == conf:
+                                    nearest_dirichlet_val[j] = nearest_dirichlet_all[i]
+        
+        
+        boundary_dir = dr.normalize(closest_bpoint - points) 
+        radius = closest_dirichlet if radius_fnc is None else radius_fnc(closest_dirichlet)
+        radius = dr.minimum(radius, max_radius)
+        
+        is_epsilon_shell = ((closest_dist < self.epsilon)) 
+        on_boundary = (closest_dist < self.epsilon_neumann)
+        is_far = (self.inf_distance < closest_dist) & (dr.dot(boundary_dir, closest_bnormal) > 0)
+        
+        # Curvature computation
+        # We computed some stuff here, but whatever.
+        p1, p2, c = self.get_interpolation_points(k_all)
+        pd = self.interpolate_derivative(p1, p2, c, t_min_all)
+        pd2 = self.interpolate_derivative2(p1, p2, c, t_min_all)
+        pd_sqr = dr.sum(dr.square(pd))
+        curvature =  -(pd[0] * pd2[1] - pd[1] * pd2[0]) / dr.sqrt(dr.square(pd_sqr) * pd_sqr)
+        bi = BoundaryInfo(points, on_boundary, radius, closest_dist, is_far, closest_bpoint, curvature, closest_dirichlet, nearest_dirichlet_val, 
+                            closest_bpoint_dirichlet, boundary_dir, closest_bnormal, is_dirichlet, is_neumann, is_epsilon_shell, 
+                            UInt32(0), UInt32(0), is_star = ~is_dirichlet)
+        return bi
+    
+    def star_generation(self, bi):
+        bi.is_star = bi.is_n & (bi.r > bi.d)
+        return bi
+    
+    @dr.syntax
+    def ray_intersect(self, bi : BoundaryInfo, direction : Point2f, conf_numbers : list[UInt32] = None):
+
+        origin = Point2f(bi.origin)
+        if bi.on_boundary:
+            origin = Point2f(bi.bpoint)  + bi.bn * self.epsilon_neumann/50
+
+        #o_b = 1/bi.curvature * bi.bn
+        #cos_angle = dr.dot(o_b, direction)
+        #aprox_mask = (bi.curvature > 0) & bi.on_boundary & cos_angle < 1e-2
+        #if aprox_mask:
+        #    t_min = 2 * cos_angle / bi.curvature
+
+        epsilon = 0
+        i = UInt32(0)
+        # First find which ray segment we should search for by assuming it is linearly interpolated.
+        n = UInt32(0)
+        t_min = Float(dr.inf)
+        t_min_ = Float(dr.nan)
+        while i < self.npoints:
+            p1, p2, co = self.get_interpolation_points(i)
+            a_ = p1 + p2 - 2 * co
+            b_ = 2 * (co - p1)
+            c_ = p1 - origin
+            a = direction[0] * a_[1] - direction[1] * a_[0]
+            b = direction[0] * b_[1] - direction[1] * b_[0]
+            c = direction[0] * c_[1] - direction[1] * c_[0]
+            t1_ = (-b  - dr.sqrt(dr.square(b) - 4 * a * c)) / (2 * a)
+            t2_ = (-b  + dr.sqrt(dr.square(b) - 4 * a * c)) / (2 * a)
+            
+            t1 = Float(0)
+            t2 = Float(0)
+            if dr.abs(direction[0]) < 0.7:
+                t1 = (a_[1] * dr.square(t1_) + b_[1] * t1_ + c_[1]) / direction[1]
+                t2 = (a_[1] * dr.square(t2_) + b_[1] * t2_ + c_[1]) / direction[1]
+            else:
+                t1 = (a_[0] * dr.square(t1_) + b_[0] * t1_ + c_[0]) / direction[0]
+                t2 = (a_[0] * dr.square(t2_) + b_[0] * t2_ + c_[0]) / direction[0]
+            if dr.isfinite(t1) & dr.isfinite(t1_) & (t1 < t_min) & (t1> epsilon) & (t1_ >= 0) & (t1_ <= 1):
+                t_min = t1
+                t_min_ = t1_
+                n = UInt32(i)
+            if dr.isfinite(t2) & dr.isfinite(t2_) & (t2 < t_min) & (t2> epsilon) & (t2_ >= 0) & (t2_ <= 1):
+                t_min = t2
+                t_min_ = t2_
+                n = UInt32(i)
+            i+=1
+        #if self.inside & (t_min == dr.inf) & bi.on_boundary:
+        #    t_min = Float(0)
+
+        intersected = origin + direction * t_min
+        p1, p2, co = self.get_interpolation_points(n)
+        normal = self.interpolate_derivative(p1, p2, co, t_min_)
+        normal = Point2f(-normal[1], normal[0])
+        if dr.dot(direction, normal) > 0:
+            normal = -normal
+
+        # Get the boundary condition at the hit point.
+        is_dirichlet = dr.gather(Bool, self.dirichlet_map, n)
+
+        neumann_vals = None
+        if dr.hint(conf_numbers is not None, mode = 'scalar'):
+            num_conf = len(conf_numbers)
+            neumann_vals = dr.zeros(ArrayXf, shape = (num_conf, dr.width(bi.origin)))
+            if not self.is_full_dirichlet:
+                if dr.hint(self.v_neumann is None, mode = "scalar"):    
+                    if dr.hint(self.num_conf_n == 1, mode = 'scalar'):
+                        neumann = self.neumann[0].get_value(intersected)
+                        for i in range(num_conf):
+                            if ~is_dirichlet:
+                                neumann_vals[i] = neumann
+                    else:
+                        for i in range(self.num_conf_n): 
+                            for j, conf in enumerate(conf_numbers):
+                                if (i == conf) & ~is_dirichlet:
+                                    neumann_vals[j] = self.neumann[i].get_value(intersected)
+                else:
+                    neumann_all = self.get_neumann_vertices(n, t_min_)
+                    if dr.hint(self.num_conf_n == 1, mode = 'scalar'):
+                        for i in range(num_conf):
+                            if ~is_dirichlet:
+                                neumann_vals = Float(neumann_all)
+                    else:
+                        for i in range(self.num_conf_n): 
+                            for j, conf in enumerate(conf_numbers):
+                                if i == conf & ~is_dirichlet:
+                                    neumann_vals[j] = Float(neumann_all[i])
+
+        ri = RayInfo(origin, direction, t_min, intersected, normal, is_dirichlet, neumann_vals)
+        return ri
+    
+    def get_diriclet_value(self, points) -> Float:
+        self.get_closest_dist(points,)
+        
+    def sketch(self, ax, bbox, resolution, colors = ["red", "green"], sketch_center = False, sketch_in_boundaries = False, lw = None):
+        for i in range(self.npoints):
+            color = colors[0] if self.dirichlet_map[i]==True else colors[1]
+            p1, p2, c = self.get_interpolation_points(i)
+            p1_s = point2sketch(p1, bbox, resolution).numpy().squeeze()
+            p2_s = point2sketch(p2, bbox, resolution).numpy().squeeze()
+            c_s = point2sketch(c, bbox, resolution).numpy().squeeze()
+            pp = PathPatch(mpath([p1_s, c_s, p2_s], [mpath.MOVETO, mpath.CURVE3, mpath.CURVE3]), facecolor='none', edgecolor = color, linewidth = lw, capstyle = "round")
+            ax.add_patch(pp)
+
+    def sketch_points(self, ax, bbox, resolution, colors = ['green', 'orange'], control_points : bool = False):
+        for i in range(self.npoints):
+            p1, p2, c = self.get_interpolation_points(i)
+            p1_s = point2sketch(p1, bbox, resolution).numpy().squeeze()
+            p2_s = point2sketch(p2, bbox, resolution).numpy().squeeze()
+            c_s = point2sketch(c, bbox, resolution).numpy().squeeze()
+            ax.scatter(p1_s[0], p1_s[1], color = colors[0])
+            if control_points:
+                ax.scatter(c_s[0], c_s[1], color = colors[1])
+
+    def sketch_curvature(self, bi : BoundaryInfo, ax, bbox, resolution):
+        radius = 1/bi.curvature
+        center = bi.bpoint + bi.bn * radius
+        bpoint_s = point2sketch(bi.bpoint, bbox, resolution).numpy()
+        center_s = point2sketch(center, bbox, resolution).numpy()
+        radius_s = dist2sketch(radius, bbox, resolution)[0].numpy()
+        ax.scatter(bpoint_s[0], bpoint_s[1], color = 'red')
+        ax.scatter(center_s[0], center_s[1])
+        for c, r in zip(center_s.T, radius_s):
+            sphere = patches.Ellipse(c, r * 2, r * 2, linewidth= 1,
+                                fill = False, color = "purple")
+            ax.add_patch(sphere)        
+
+
+    def sketch_normals(self, ax, bbox, resolution, color = "blue", length_vector = 0.2):
+        for i in range(self.npoints):
+            p1, _, c = self.get_interpolation_points(i)
+            p1_s = point2sketch(p1, bbox, resolution).numpy().squeeze()
+            c_s = point2sketch(c, bbox, resolution).numpy().squeeze()
+            l_s, _, _ = dist2sketch(length_vector, bbox, resolution)
+            v_n = self.get_normals(i)
+            n_s = dir2sketch(v_n, bbox, resolution).numpy().squeeze()
+            arrow = patches.FancyArrow(p1_s[0], p1_s[1], n_s[0] * l_s, n_s[1] * l_s, 
+                                        width = 2 / 512 * resolution[0], length_includes_head=True, color = color)
+            ax.add_patch(arrow)
+
+
+    def sketch_polyline(self, ax, bbox, resolution, color = "blue"):
+        for i in range(self.npoints):
+            p1, p2, c = self.get_interpolation_points(i)
+            t = dr.arange(Float, self.n_segment + 1) / self.n_segment
+            p = self.interpolate(p1, p2, c, t)
+            p_s = point2sketch(p, bbox, resolution).numpy().squeeze()
+            pp = PathPatch(mpath(p_s.T), facecolor='none', edgecolor = color)
+            ax.add_patch(pp)
+
+
+    def get_dirichlet_vertices(self, k : UInt32, t :UInt32):
+        d1 = dr.gather(Float, self.v_dirichlet, k)
+        d2 = dr.gather(Float, self.v_dirichlet, (k + 1) % self.npoints)
+        return dr.lerp(d1, d2, t)
+    
+    def get_neumann_vertices(self, k : UInt32, t :UInt32):
+        n1 = dr.gather(Float, self.v_neumann, k)
+        n2 = dr.gather(Float, self.v_neumann, (k + 1) % self.npoints)
+        return dr.lerp(n1, n2, t)
+    
+    @dr.syntax
+    def create_neumann_points(self, resolution : int, spp : int):
+        n = resolution * spp
+        points = dr.zeros(Point2f, self.n_neumann * n)
+        sampler = PCG32(initstate=dr.arange(UInt32, n))
+        indices = dr.arange(UInt32, n)
+        j = UInt32(0)
+        for i in range(self.npoints):
+            is_d = dr.gather(Bool, self.dirichlet_map, i)
+            if ~is_d:
+                p1, p2, c = self.get_interpolation_points(i)
+                t = dr.arange(Float, n) / n + sampler.next_float32() / n
+                p_iter = self.interpolate(p1, p2, c, t)
+                dr.scatter(points, p_iter, indices + j)
+                j += n
+        return points
+    
+    def create_boundary_points(self, resolution : int, spp : int):
+        n = resolution * spp
+        points = dr.zeros(Point2f, self.n_segment * n)
+        sampler = PCG32(initstate=dr.arange(UInt32, n))
+        indices = dr.arange(UInt32, n)
+        j = UInt32(0)
+        for i in range(self.npoints):
+            p1, p2, c = self.get_interpolation_points(i)
+            t = dr.arange(Float, n) / n + sampler.next_float32() / n
+            p_iter = self.interpolate(p1, p2, c, t)
+            dr.scatter(points, p_iter, indices + j)
+            j += n
+        return points
+
+
+
+    
+        
+
+            
+
+
+
+
+
+

data/PDE2D/BoundaryShape/boundary_shape.py

@@ -0,0 +1,108 @@
+import drjit as dr
+from matplotlib import pyplot as plt
+from matplotlib import patches as patches
+from ..Coefficient import *
+from ..utils.helpers import *
+from .interaction import *
+from mitsuba import Float, Point2f, Bool
+from enum import IntEnum
+
+class NEE(IntEnum):
+    Normal = 0,
+    Special = 1,
+    BruteForce = 2
+
+class Shape(object):
+    def __init__(self, is_full_dirichlet = False, is_full_neumann = False, single_closed_shape = True, 
+                 epsilon=1e-5, inside = True, derivative_dist = 1e-2, inf_distance = 10):
+        self.is_full_dirichlet = is_full_dirichlet
+        self.is_full_neumann = is_full_neumann
+        self.single_closed = single_closed_shape
+        self.epsilon = epsilon
+        self.min_star_radius = self.epsilon * 2 # Check the paper for better min distance!
+        self.name = "boundary"
+        self.inside = inside  
+        self.normal_derivative_dist = derivative_dist
+        self.measured_current = False # If the Boundary condition given as currents or normal derivatives.
+        self.has_continuous_neumann = True
+        self.has_delta = False
+        self.NEE = NEE.Normal
+        self.inf_distance = inf_distance
+    
+    
+    def star_generation(self, bi: BoundaryInfo) -> BoundaryInfo:
+        return bi
+    
+    def inside_closed_surface(self, points, L, conf_numbers):
+        return Bool(False), dr.zeros(ArrayXf, shape = (len(conf_numbers), dr.width(points)))
+    
+    def inside_closed_surface_mask(self, L):
+        return Bool(False)
+    
+    def ray_intersect(self, bi : BoundaryInfo, direction : Point2f, conf_numbers : list[UInt32] = None) -> RayInfo:
+        pass
+    
+    def boundary_interaction(points : Point2f, 
+                             radius_fnc : callable = None, max_radius = None, 
+                             star_generation = True, conf_numbers : list[UInt32] = [UInt32[0]]) -> BoundaryInfo:
+        pass
+    
+    def get_opt_params_shape(self, param_dict: dict, opt_params: list):
+        pass
+    
+    def update_shape(self, optimizer):
+        pass
+    
+    def zero_grad_shape(self):
+        pass
+    
+    def sketch(self,ax, bbox, resolution, colors = ['red'], fill = False):
+        pass
+
+    def sketch_image(self,ax, bbox, resolution, channel= 0, colors = ["red"], image = None, color_factor = 0.6):
+        pass
+    
+    def create_boundary_points(self, distance : float, resolution : int, spp : int):
+        pass
+
+    def create_neumann_points(self, resolution : int, spp : int):
+        pass
+
+    def create_boundary_result(self, result, resolution):
+        pass
+
+    def create_boundary_coefficient(self, tensor_mi, name = "boundary-val"):
+        pass
+
+    def set_normal_derivative(self, tensor_mi, name = "normal-derivative"):
+        pass
+    
+    def normal_derivative_from_result(self, result : Float, film_points : Point2f, resolution : int):
+        pass
+    
+    def create_normal_der_coefficient(self, tensor_mi):
+        pass
+    
+    def jakobian_to_boundary(self, bi : BoundaryInfo, distance : Float):
+        pass
+    
+    def get_max_intersection_dist(self, bi : BoundaryInfo):
+        pass
+    
+    def get_distance_correction(self, points):
+        pass
+    def get_point_neumann(self, bi : BoundaryInfo, conf_number : UInt32) -> tuple[list[Float], list[Float], list[Float], list[Point2f]]:
+        return [], [], [], []
+    
+    def sampleNEE(self, bi : BoundaryInfo, sample : Float, conf_number : UInt32) -> tuple[Float, Float, Float, Point2f]:
+        return Float(0), Float(0), Float(0), Point2f(0)
+    
+    def create_volume_points(self, resolution = [256, 256], spp = 1):
+        points = create_image_points(self.bbox, resolution, spp, centered = True)
+        active = self.inside_closed_surface_mask(points)
+        indices = dr.compress(active)
+        points = dr.gather(type(points), points, indices)
+        return points
+    
+    def accum_tput(self, tput : Float, bi : BoundaryInfo):
+        pass

data/PDE2D/BoundaryShape/boundarywithdirichlets.py

@@ -0,0 +1,290 @@
+from PDE2D.BoundaryShape.interaction import BoundaryInfo
+from PDE2D.BoundaryShape import CircleShape
+from .boundary_shape import *
+from ..utils.helpers import *
+from ..utils.sketch import *
+from .interaction import *
+from scipy.spatial import Voronoi
+
+from ..utils.imageUtils import create_circle_from_result, create_circle_points
+from ..Coefficient import *
+class BoundaryWithDirichlets(Shape):
+    def __init__(self, out_boundary : Shape,
+                 dirichlet_boundaries : list[Shape] = [], dirichlet_values : list[list] = None,
+                 epsilon = 1e-5, name : str = "DirichletShapes"):
+        #assert len(dirichlet_values) == len(dirichlet_boundaries)
+        
+        self.single_shape_closed = True
+        self.name = name
+        self.out_boundary = out_boundary
+        self.in_boundaries = dirichlet_boundaries
+        self.out_boundary.inside = True
+        self.is_full_dirichlet = self.out_boundary.is_full_dirichlet
+        self.max_distance = self.out_boundary.max_distance
+        self.single_closed = True
+        self.neumann = self.out_boundary.neumann # Only neumann is the out boundary
+        # If the shape has some NEE structure.
+        self.NEE = self.out_boundary.NEE
+        self.has_continuous_neumann = self.out_boundary.has_continuous_neumann
+        self.has_delta = self.out_boundary.has_delta
+        # If the boundary condition given as currents or normal derivatives.
+        self.measured_current = self.out_boundary.measured_current 
+        self.epsilon = epsilon
+        self.out_boundary.epsilon = epsilon
+        self.bbox = self.out_boundary.bbox
+        self.bbox_length = max(self.bbox[1][1] - self.bbox[0][1], self.bbox[1][0] - self.bbox[0][0])
+        self.update_in_boundaries(dirichlet_boundaries, dirichlet_values)
+
+    def update_in_boundaries(self, in_boundaries : list[Shape], dirichlet_values : list[list] = None):
+        self.num_shapes = len(in_boundaries)
+        if dirichlet_values is None:
+            dirichlet_values = [[0] for i in range(self.num_shapes)]
+        
+        #if self.num_shapes > 0:
+        #    self.num_conf_d = len(dirichlets[0])
+        #else:
+        #    self.num_conf_d = 1
+
+        self.in_boundaries = in_boundaries
+        self.is_full_neumann = (self.num_shapes == 0) & self.out_boundary.is_full_neumann
+        for  i, d_shape in enumerate(self.in_boundaries):
+            assert d_shape.is_full_dirichlet
+            #assert len(dirichlet_values[i]) == self.num_conf_d
+            d_shape.inside = False
+            d_shape.epsilon = self.epsilon
+
+        self.update_in_boundary_dirichlets(dirichlet_values)
+
+    
+    def get_origins(self):
+        origins = []
+        for d_shape in self.in_boundaries:
+            origins.append(d_shape.origin.numpy().squeeze())
+        return np.array(origins)
+
+    def update_in_boundaries_circle(self, origins : list, radius : float = 0.01, dirichlet_values : list[list] = None):
+        in_boundaries = []
+        for origin in origins:
+            in_boundaries.append(CircleShape(origin = origin, radius = radius))
+        self.update_in_boundaries(in_boundaries, dirichlet_values)
+    
+    @dr.syntax
+    def update_in_boundary_dirichlets(self, dirichlet_values : list[list]):
+        self.dirichlets = []
+        for i in range(self.num_shapes):
+            self.dirichlets.append(ArrayXf(dirichlet_values[i]))
+        dr.make_opaque(self.dirichlets)
+
+    @dr.syntax
+    def ray_intersect(self, bi : BoundaryInfo, direction : Point2f, conf_numbers : list [UInt32] = None):  # change this for outside!
+        ri = self.out_boundary.ray_intersect(bi, direction, conf_numbers)
+        for boundary in self.in_boundaries:
+            ri_in = boundary.ray_intersect(bi, direction, conf_numbers)
+            if (ri_in.t < ri.t) & (ri_in.t >= 0):
+                ri.t = Float(ri_in.t)
+                ri.intersected = Point2f(ri_in.intersected)
+                ri.normal = Point2f(ri_in.normal)
+                ri.is_dirichlet = Bool(ri_in.is_dirichlet)
+                if dr.hint(conf_numbers is not None):
+                    num_conf = len(conf_numbers)
+                    if dr.hint(num_conf == 1):
+                        ri.neumann[0] = Float(0)
+                    else:
+                        for j in range(num_conf):
+                            ri.neumann[j] = Float(0)
+        return ri
+    
+    @dr.syntax
+    def boundary_interaction(self, points, 
+                             radius_fnc : callable = None, star_generation = True, 
+                             max_radius = Float(dr.inf), conf_numbers : list[UInt32] = [UInt32(0)]):
+        num_conf = len(conf_numbers)
+        assert len(self.dirichlets) == self.num_shapes
+        if self.num_shapes>0:
+            assert (num_conf == dr.width(self.dirichlets[0])) or (dr.width(self.dirichlets[0]) == 1)
+        bi = self.out_boundary.boundary_interaction(points, radius_fnc, star_generation = False, conf_numbers = conf_numbers)
+        for (i,boundary) in enumerate(self.in_boundaries):
+            bi_in = boundary.boundary_interaction(points, radius_fnc, star_generation = False, conf_numbers = conf_numbers)
+            bi_in.shape = UInt32(i+1)
+            bi_in.d_shape = UInt32(i+1)
+            bi_in.dval = ArrayXf(self.dirichlets[i])
+            bi = merge_boundary_info(bi, bi_in)
+        
+        bi.r = dr.minimum(max_radius, bi.r)
+        
+        if dr.hint(not self.is_full_dirichlet, mode = 'scalar'):
+            if dr.hint(star_generation, mode = 'scalar'):
+                bi = self.star_generation(bi)
+        return bi
+            
+    def star_generation(self, bi):
+        return self.out_boundary.star_generation(bi)
+
+    
+    def sampleNEE(self, bi : BoundaryInfo, sample : Float, conf_number : UInt32) -> tuple[Float, Float, Float, Point2f]:
+        return self.out_boundary.sampleNEE(bi, sample, conf_number)
+    
+    def get_point_neumann(self, bi : BoundaryInfo, conf_number : UInt32) -> tuple[list[Float], list[Float], list[Float], list[Point2f]]:
+        return self.out_boundary.get_point_neumann(bi, conf_number)
+
+    @dr.syntax
+    def inside_closed_surface(self, points : Point2f, L : ArrayXf, conf_numbers = list[UInt32]):
+        num_conf = len(conf_numbers)
+        if self.num_shapes>0:
+            assert (num_conf == dr.width(self.dirichlets[0])) or (dr.width(self.dirichlets[0]) == 1)
+        
+        active, L = self.out_boundary.inside_closed_surface(points, L)
+        for i, boundary in enumerate(self.in_boundaries):
+            mask, L = boundary.inside_closed_surface(points, L)
+            active &= ~mask
+            if mask:
+                L += ArrayXf(self.dirichlets[i])
+        return active, L
+    
+    @dr.syntax
+    def inside_closed_surface_mask(self, points : Point2f):
+        active = self.out_boundary.inside_closed_surface_mask(points)
+        for i, boundary in enumerate(self.in_boundaries):
+            mask = boundary.inside_closed_surface_mask(points)
+            active &= ~mask
+        return active
+                
+    def get_opt_params_shape(self, param_dict: dict, opt_params: list):
+        self.out_boundary.get_opt_params_shape(param_dict, opt_params)
+        for boundary in self.in_boundaries:
+            boundary.get_opt_params_shape(param_dict, opt_params)
+                
+    def update_shape(self, optimizer):
+        #if post_process is not None:
+        #    post_process(optimizer)
+        #self.out_boundary.update_shape(optimizer)
+        #for boundary in self.in_boundaries:
+        #    boundary.update_shape(optimizer)
+        self.in_boundaries[0].update_shape(optimizer)
+
+    def zero_grad_shape(self):
+        self.out_boundary.zero_grad_shape()
+        for boundary in self.in_boundaries:
+            boundary.zero_grad_shape()
+
+    
+    def sketch_image(self, ax, bbox, resolution, channel = 0, colors = ["orange", "green"], image = None, 
+                     color_factor = 0.6):        
+        image = np.zeros([resolution[0], resolution[1], 3])
+        for shape in self.in_boundaries:
+            image = shape.sketch_image(ax, bbox, resolution, channel = channel, 
+                                       image =image, color_factor=color_factor)
+        ax.imshow(image)
+
+        self.out_boundary.sketch(ax, bbox, resolution, colors = colors)
+        return image
+            
+    def sketch(self, ax, bbox, resolution, colors = ["orange","green", "red"], fill = False, sketch_center = False, sketch_in_boundaries = True):
+        if sketch_in_boundaries:
+            for shape in self.in_boundaries:
+                shape.sketch(ax, bbox, resolution, colors = [colors[2], colors[0]], fill = fill, sketch_center = sketch_center)
+        self.out_boundary.sketch(ax, bbox, resolution, colors = colors[0:2])
+
+    def create_boundary_points(self, distance: float, res: int, spp: int, discrete_points : bool = True):
+        with dr.suspend_grad():
+            points = []
+            normals = []
+            s_points = []
+            p, s_p, n = self.out_boundary.create_boundary_points(distance, res, spp, discrete_points)
+            points.append(p)
+            normals.append(n)
+            s_points.append(s_p)
+            for boundary in self.in_boundaries:
+                p, s_p, n = boundary.create_boundary_points(distance, res, spp, discrete_points)
+                points.append(p)
+                s_points.append(s_p)
+                normals.append(n)
+        return points, s_p, normals
+
+    def create_boundary_result(self, result, resolution):
+        with dr.suspend_grad():
+            tensor = []
+            tensor_mi = []
+            t, t_mi = self.out_boundary.create_boundary_result(result[0], resolution)
+            tensor.append(t)
+            tensor_mi.append(t_mi)
+            for i, boundary in enumerate(self.in_boundaries):
+                t, t_mi = boundary.create_boundary_result(result[i+1], resolution)
+                tensor.append(t)
+                tensor_mi.append(t_mi)
+        return tensor, tensor_mi
+
+    def create_boundary_coefficient(self, tensor_mi, name = "boundary-val"):
+        with dr.suspend_grad():
+            self.boundary_coeff = []
+            self.boundary_coeff.append(self.out_boundary.create_boundary_coefficient(tensor_mi[0], f'{name}-0'))
+            for i, boundary in enumerate(self.in_boundaries):
+                self.boundary_coeff.append(boundary.create_boundary_coefficient(tensor_mi[i+1], f'{name}-{i}'))
+        return self.boundary_coeff
+
+    
+    #def set_normal_derivative(self, tensor_mi, name = "normal-derivative"):
+    #    self.normal_derivative = []
+    #    self.normal_derivative.append(self.out_boundary.set_normal_derivative(tensor_mi[0], f"{name}-0"))
+    #    for i, boundary in enumerate(self.in_boundaries):
+    #            self.normal_derivative.append(boundary.set_normal_derivative(tensor_mi[i+1], f'{name}-{i}'))
+    #    return self.normal_derivative
+    
+    #@dr.syntax
+    #def jakobian_to_boundary(self, bi : BoundaryInfo, distance = None):
+        # This one computes the minimum of the distances to compute the boundary result.
+    #    jak = Float(0)
+    #    for i, shape in enumerate(self.in_boundaries):
+    #        if bi.d_shape == UInt32(i+1):
+    #            jak = shape.jakobian_to_boundary(bi, max_distance)
+    #    return jak
+    
+    
+    def get_normal_derivative(self, points : Point2f):
+        return self.in_boundaries[0].get_normal_derivative(points)
+    
+    def get_jacobian_factor(self, bi : BoundaryInfo, distance : float):
+        ri = self.ray_intersect(bi, bi.bn)
+        distance = dr.minimum(distance, 0.3 * ri.t)
+        return self.in_boundaries[0].jakobian_to_boundary(bi, distance)
+
+    
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.in_boundaries[0].get_opt_params_shape(param_dict, opt_params)
+    
+    def update(self, optimizer):
+        self.out_boundary.update(optimizer)
+        for shape in self.in_boundaries:
+            shape.update(optimizer)
+        
+    def zero_grad(self):
+        self.out_boundary.zero_grad()
+        for shape in self.in_boundaries:
+            shape.zero_grad()
+
+def merge_boundary_info(bi1, bi2, radius_fnc : callable = None):
+    # merges 2 boundary informations created with different shapes.
+    # it does not handle the star generation!
+    # Here bi2 must be only dirichlet, it is created for circlewithdirichletsshape
+    mask = bi1.d < bi2.d
+    mask_d = bi1.dd < bi2.dd
+    bi = BoundaryInfo()
+    bi.origin = Point2f(bi1.origin)
+    #bi.on_boundary = dr.select(mask, bi1.on_boundary, bi2.on_boundary)
+    bi.on_boundary = bi1.on_boundary
+    bi.d = dr.select(mask, bi1.d, bi2.d)
+    bi.is_far = dr.select(mask, bi1.is_far, bi2.is_far)
+    bi.dd = dr.select(mask_d, bi1.dd, bi2.dd)
+    bi.r = bi.dd
+    bi.bpoint = dr.select(mask, bi1.bpoint, bi2.bpoint)
+    bi.curvature = dr.select(mask, bi1.curvature, bi2.curvature)
+    bi.dval = dr.select(mask_d, bi1.dval, bi2.dval)
+    bi.dpoint = dr.select(mask_d, bi1.dpoint, bi2.dpoint)
+    bi.bdir = dr.select(mask, bi1.bdir, bi2.bdir)
+    bi.bn = dr.select(mask, bi1.bn, bi2.bn)
+    bi.is_d = dr.select(mask, bi1.is_d, bi2.is_d)
+    bi.is_n = dr.select(mask, bi1.is_n, bi2.is_n)
+    bi.is_e = dr.select(mask, bi1.is_e, bi2.is_e)
+    bi.shape = dr.select(mask, bi1.shape, bi2.shape)
+    bi.d_shape = dr.select(mask_d, bi1.d_shape, bi2.d_shape)
+    return bi 

data/PDE2D/BoundaryShape/circle.py

@@ -0,0 +1,463 @@
+from .boundary_shape import *
+from ..utils.helpers import *
+from ..utils.sketch import *
+from .interaction import *
+from mitsuba import UInt
+from ..utils.imageUtils import create_circle_from_result, create_circle_points
+from ..Coefficient import *
+from .sdf_grid import SDFGrid
+class CircleShape(Shape):
+    def __init__(self, origin=[0, 0], radius=1,
+                 angle_partition=np.array([0]),
+                 dirichlet_map: np.array = np.array([True]),
+                 dirichlet: list[Coefficient] = [ConstantCoefficient("dirichlet", 0)],
+                 neumann: list[Coefficient] = [ConstantCoefficient("neumann", 0)],
+                 epsilon=1e-4, name = "boundary", normal_derivative_dist = 0.01,
+                 inside = True):
+        super().__init__(np.all(dirichlet_map), single_closed_shape=True, epsilon=epsilon,
+                         inside = inside, derivative_dist=normal_derivative_dist)
+        self.name = name
+        self.origin = Point2f(origin)
+        self.radius = Float(radius)
+        dr.make_opaque(self.origin)
+        dr.make_opaque(self.radius)
+        # check if there is no neumann boundary
+        self.dirichlet_map = Bool(dirichlet_map)
+        dr.make_opaque(self.dirichlet_map)
+        self.is_full_dirichlet = dr.all(self.dirichlet_map)
+        self.is_full_neumann = dr.all(~self.dirichlet_map)
+
+        # Create interval vector of size (n_interval, 2)
+        # The first angle partition
+        self.init_angle_partition = Float(float(angle_partition[0]))
+        angle_partition = np.append(
+            angle_partition, angle_partition[0] + 2 * np.pi)
+        angle_intervals = np.stack([angle_partition[:-1],
+                                    angle_partition[1:]], axis=0)
+        self.angle_partition = Point2f(angle_intervals)
+        dr.make_opaque(angle_partition)
+        self.num_intervals = dr.width(self.angle_partition)
+
+        # Get the dirichlet and neumann intervals
+        self.dirichlet_angles = Point2f(angle_intervals[:, np.array(dirichlet_map, dtype = bool)])
+        self.neumann_angles = Point2f(angle_intervals[:, ~np.array(dirichlet_map, dtype = bool)])
+
+        self.bbox = [[self.origin[0] - radius, self.origin[1] - radius], 
+                     [self.origin[0] + radius, self.origin[1] + radius]]
+    
+        # Dirichlet and neumann boundary values (instance of Coefficient).
+        self.dirichlet = dirichlet
+        self.neumann = neumann
+
+        self.num_conf_d = len(dirichlet)
+        self.num_conf_n = len(neumann)
+        assert (self.num_conf_d == self.num_conf_n) or (self.num_conf_n == 1) or (self.num_conf_d == 1)
+
+        self.max_distance = self.radius
+        self.measureCurrent = False
+
+    @dr.syntax
+    def ray_intersect(self, bi : BoundaryInfo, direction : Point2f, conf_numbers : list[UInt32] = None):  # change this for outside!
+
+        # if outside due to numerical errors (we always assume that we compute solution inside!)
+        # origin = dr.select(dr.norm(o_b) >= self.radius - 1e-1,
+        #                   self.origin - o_b * (self.radius - 1e-1) / dr.norm(o_b),
+        #                   origin)
+        # Solve second order polynomial
+        origin = Point2f(bi.origin)
+        on_boundary = Bool(bi.on_boundary)
+        o_b = Point2f(0)
+        if on_boundary & self.inside:
+            o_b = dr.normalize(self.origin - origin)
+            cos_angle = dr.dot(o_b, direction)
+            t = 2 * cos_angle * self.radius
+        else:
+            o_b = origin - self.origin
+            a = dr.dot(direction, direction)
+            b = 2 * dr.dot(o_b, direction)
+            c = dr.dot(o_b, o_b) - dr.sqr(self.radius)
+            sign = dr.select(self.inside, 1, -1)
+            t = (- b + sign * dr.sqrt(dr.sqr(b) - 4 * a * c)) / (2 * a)
+
+        intersected = mi.Point2f(origin + direction * t)
+        # if intersected point is outside the domain, put it back in!
+        diff = intersected -self.origin
+        normals = dr.normalize(diff)
+        normals = -normals if self.inside else normals
+
+        angles = correct_angle(dr.atan2(diff[0], diff[1]))
+        is_dirichlet = self.is_dirichlet_boundary(angles, Bool(True))
+        
+        neumann_vals = None
+        if dr.hint(conf_numbers is not None, mode = 'scalar'):
+            num_conf = len(conf_numbers)
+            neumann_vals = dr.zeros(ArrayXf, shape = (num_conf, dr.width(intersected))) 
+            if not dr.hint(self.is_full_dirichlet, mode = "scalar"):
+                if ~is_dirichlet:
+                    if dr.hint(self.num_conf_n == 1, mode = "scalar"):
+                        neumann = self.neumann[0].get_value(intersected)
+                        for i in range(num_conf):
+                            neumann_vals[i] = neumann
+                    else:
+                        for i in range(self.num_conf_n): 
+                            for j, conf in enumerate(conf_numbers):    
+                                neumann_vals[j] = dr.select(i == conf, self.neumann[i].get_value(intersected), neumann_vals[j])
+        return RayInfo(origin, direction, t, intersected, normals, is_dirichlet, neumann_vals)
+    
+
+        
+    @dr.syntax
+    def get_nearest_distances(self, points, active):
+        # active mask needs to be the points where we have nearest neumann boundary!
+        # otherwise we need to check the closest point to the boundary, too!
+        npoints = dr.width(points)
+        min_distance, angles, boundary_points =self.closest_points(points)
+        if dr.hint(self.is_full_neumann, mode = 'scalar'):
+            return min_distance, boundary_points, dr.full(Bool, False, npoints), dr.inf, Point2f(dr.inf)
+        if dr.hint(self.is_full_dirichlet, mode = 'scalar'):
+            return min_distance, boundary_points, dr.full(Bool, True, npoints), min_distance, boundary_points
+        
+        is_dirichlet = self.is_dirichlet_boundary(angles, dr.copy(active))
+        if is_dirichlet:
+            nearest_dirichlet_dist = Float(min_distance)
+            nearest_dirichlet_point = boundary_points
+        else:
+            nearest_dirichlet_dist = Float(dr.inf)
+            nearest_dirichlet_point = Point2f(dr.inf)
+        
+        i = dr.zeros(UInt, npoints)
+        num_dirichlet_arcs = dr.width(self.dirichlet_angles)
+        
+        while active & (i < num_dirichlet_arcs):
+            interval = dr.gather(Point2f, self.dirichlet_angles, i)
+
+            points1 = self.origin + self.radius * \
+                Point2f(dr.sin(interval[0]), dr.cos(interval[0]))
+            points2 = self.origin + self.radius * \
+                Point2f(dr.sin(interval[1]), dr.cos(interval[1]))
+
+            distance1 = dr.norm(points1 - points)
+            distance2 = dr.norm(points2 - points)
+            dist_mask1 = distance1 < distance2
+            nearest_point_temp = dr.select(dist_mask1, points1, points2)
+            dist_to_arc = dr.minimum(distance1, distance2)
+            dist_mask2 = dist_to_arc < nearest_dirichlet_dist
+            nearest_dirichlet_point = Point2f(dr.select(dist_mask2, nearest_point_temp, nearest_dirichlet_point))
+            nearest_dirichlet_dist = dr.select(dist_mask2, dist_to_arc, nearest_dirichlet_dist)
+            i += 1
+        return min_distance, boundary_points, is_dirichlet, nearest_dirichlet_dist, nearest_dirichlet_point
+        
+        
+    @dr.syntax
+    def is_dirichlet_boundary(self, angles: Float, active: Bool = Bool(True)):
+        num_angles = dr.width(angles)
+        if dr.hint(self.is_full_dirichlet, mode = "scalar"):
+            return Bool(True)
+        elif dr.hint(self.is_full_neumann, mode = 'scalar'):
+            return Bool(False)
+        else:
+            if angles < self.init_angle_partition:
+                angles += 2 *dr.pi
+            i = dr.zeros(UInt, num_angles)
+            is_dirichlet = dr.zeros(Bool, num_angles)
+            num_dirichlet = dr.width(self.dirichlet_angles)
+            while active & (i < num_dirichlet):
+                interval = dr.gather(Point2f, self.dirichlet_angles, i)
+                interval_found = (angles >= interval[0]) & (
+                    angles < interval[1])
+                is_dirichlet |= (interval_found & active)
+                active &= ~interval_found
+                i += 1
+        return is_dirichlet
+    
+    @dr.syntax
+    def boundary_interaction(self, points, 
+                             radius_fnc : callable = None, star_generation = True, 
+                             max_radius = Float(dr.inf), conf_numbers : list[UInt32] = [UInt32(0)]):
+        min_distance, boundary_point, is_dirichlet, nearest_dirichlet_d, nearest_dirichlet_p = self.get_nearest_distances(points, Bool(True))
+        
+        if dr.hint(self.is_full_neumann, mode = "scalar"):
+            merge_dirichlet = Bool(False)
+            is_neumann = Bool(True)
+            nearest_dirichlet_d = Float(self.radius)
+        elif dr.hint(self.is_full_dirichlet, mode = "scalar"):
+            merge_dirichlet = Bool(False)
+            is_neumann = Bool(False)
+        else:
+            merge_dirichlet = (nearest_dirichlet_d < (5*dr.epsilon(Float)))
+            is_dirichlet |=  merge_dirichlet 
+            is_neumann = ~is_dirichlet 
+            
+        radius = nearest_dirichlet_d if radius_fnc is None else radius_fnc(nearest_dirichlet_d)
+        radius = dr.minimum(radius, max_radius)
+        boundary_dir = dr.normalize(boundary_point - points)
+        # boundary normal defined to the outside of the shape, be careful with this
+        boundary_normal = dr.normalize(boundary_point - self.origin) # be careful with inside outside cases
+        boundary_normal = -boundary_normal if self.inside else boundary_normal
+        is_epsilon_shell = ((min_distance < self.epsilon))
+        on_boundary = (is_neumann & (min_distance < 200 * dr.epsilon(Float)))
+        
+        
+        # Set the dirichlet_values to the correct channels.
+        num_conf = len(conf_numbers)
+        nearest_dirichlet_val = dr.zeros(ArrayXf, shape = (num_conf, dr.width(points)))
+        if dr.hint(not self.is_full_neumann, mode = "scalar"):
+            if dr.hint(self.num_conf_d == 1, mode = 'scalar'):
+                dirichlet = self.dirichlet[0].get_value(boundary_point)
+                for i in range(num_conf):
+                    nearest_dirichlet_val[i] = dirichlet
+            else:
+                for i in range(self.num_conf_d): 
+                    for j, conf in enumerate(conf_numbers):
+                        nearest_dirichlet_val[j] = dr.select(i == conf, 
+                                                             self.dirichlet[i].get_value(boundary_point), 
+                                                             nearest_dirichlet_val[j])
+                        
+        is_far = min_distance > self.inf_distance
+        curvature = 1/self.radius
+
+        bi = BoundaryInfo(points, on_boundary, radius, min_distance, is_far, boundary_point, curvature, nearest_dirichlet_d,
+                          nearest_dirichlet_val, nearest_dirichlet_p, boundary_dir, boundary_normal, is_dirichlet, 
+                          is_neumann, is_epsilon_shell, UInt32(0), UInt32(0))
+        
+        if dr.hint(not self.is_full_dirichlet, mode = 'scalar'):
+            if dr.hint(star_generation, mode = 'scalar'):
+                bi = self.star_generation(bi)
+        return bi
+            
+    def star_generation(self, bi):
+        bi.is_star = bi.is_n & (bi.r > bi.d)
+        # If we are very close to the boundary, we will stamp it to the boundary
+        diff_centers = bi.origin - self.origin
+        diff_dist = dr.norm(diff_centers)
+        # only works for  strictly convex boundaries
+        angle_centers = correct_angle(dr.atan2(diff_centers[0], diff_centers[1]))
+        # cosine theorem
+        cos_alpha = (-dr.sqr(bi.r) + dr.sqr(self.radius) + dr.sqr(diff_dist)) / (2 * self.radius * diff_dist)
+        angle_diff = dr.acos(cos_alpha)
+        angle1 = correct_angle(angle_centers - angle_diff)
+        angle2 = correct_angle(angle_centers + angle_diff)
+        n1 = - Point2f(dr.sin(angle1), dr.cos(angle1))
+        n2 = - Point2f(dr.sin(angle2), dr.cos(angle2))
+        bi.x1 = self.origin - self.radius * n1
+        bi.x2 = self.origin - self.radius * n2
+        vec_c1 = bi.x1 - bi.origin
+        vec_c2 = bi.x2 - bi.origin
+        bi.angle1 = correct_angle(dr.atan2(vec_c1[0], vec_c1[1]))
+        bi.angle2 = correct_angle(dr.atan2(vec_c2[0], vec_c2[1]))
+        bi.angle1_adj = dr.copy(bi.angle1)
+        bi.angle2_adj = dr.copy(bi.angle2)
+        bi.gamma1 = angle1 - bi.angle1
+        bi.gamma2 = angle2 - bi.angle2
+        return bi
+        
+    def closest_points(self, points):
+        vecs = points - self.origin
+        min_distance = dr.norm(vecs) - self.radius
+        angles = correct_angle(dr.atan2(vecs[0], vecs[1]))
+        boundary_points = self.origin + self.radius * Point2f(dr.sin(angles), dr.cos(angles))
+        min_distance *= -1 if self.inside else 1
+        return dr.abs(min_distance), angles, boundary_points
+    
+    def get_closest_dist(self, points):
+        min_distance, _, _ =self.closest_points(points)
+        return min_distance
+    
+    def get_distance_correction(self, points):
+        return mi.Float(1)
+
+    def inside_closed_surface(self, points : Point2f, L : Float, conf_numbers : list[UInt32] = None):
+        vecs = points - self.origin
+        return (dr.norm(vecs) <= self.radius), L
+    
+    def inside_closed_surface_mask(self, points : Point2f):
+        vecs = points - self.origin
+        return (dr.norm(vecs) <= self.radius)
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        #self.dirichlet.get_opt_params(param_dict, opt_params)
+        #self.neumann.get_opt_params(param_dict, opt_params)
+        pass
+                
+    def get_opt_params_shape(self, param_dict: dict, opt_params: list):
+        for key in opt_params:
+            vals = key.split(".")
+            boundary_name = vals[0]
+            boundary_type = vals[1]
+            param = vals[2]
+            if (param == "radius") and (boundary_type == "dirichlet") and (boundary_name == self.name):
+                param_dict[f"{self.name}.dirichlet.radius"] = self.radius
+            elif (param == "origin") and (boundary_type == "dirichlet") and (boundary_name == self.name):
+                param_dict[f"{self.name}.dirichlet.origin"] = self.origin
+            elif (boundary_name == self.name):
+                raise Exception(
+                    f"CircleShape ({self.name}) does not have a parameter called \"{param}\"")
+        
+
+    def update(self, optimizer):
+        #self.dirichlet.update(optimizer)
+        #self.neumann.update(optimizer)
+        pass      
+    def update_shape(self, optimizer):
+        for key in optimizer.keys():
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if (name == self.name) & (param == "radius") & (type == "dirichlet"):
+                self.radius = optimizer[key]
+            elif (name == self.name) & (param == "origin") & (type == "dirichlet"):
+                self.origin = optimizer[key]
+        
+    def zero_grad(self):
+        self.dirichlet.zero_grad()
+        self.neumann.zero_grad()
+        
+    def zero_grad_shape(self):
+        if dr.grad_enabled(self.radius):
+            dr.set_grad(self.radius, 0.0)
+        if dr.grad_enabled(self.origin):
+            dr.set_grad(self.origin, 0)
+
+
+    def create_result_on_boundary(self, result, film_points, resolution=1024):
+        return create_circle_from_result(result, resolution=resolution)
+
+    
+    def sketch_image(self, ax, bbox, resolution, channel = 1, image = None, color_factor = 0.8):
+        points = create_image_points(bbox, resolution, spp = 1, centered=True)
+        result = dr.select(self.inside_closed_surface_mask(points), 1.0, 0.0)
+        image_i, tensor = create_image_from_result(result=result, resolution = resolution)
+        
+        image = np.zeros([resolution[0], resolution[1], 3]) if image is None else image
+        image[:,:,channel] += image_i[0] * color_factor
+        #image_b = self.get_boundary_image(bbox, resolution)
+        #image += image_b
+        ax.imshow(image)
+        ax.set_axis_off()
+        return image
+    
+    
+    def sketch(self, ax, bbox, resolution, colors = ["red", "orange"], fill = False, sketch_center = False, lw = 3):
+        origin_s = point2sketch(self.origin, bbox, resolution)
+        origin_s = np.array([origin_s[0][0] - 0.5, origin_s[1][0] - 0.5])
+        if sketch_center:
+            ax.scatter(origin_s[0], origin_s[1], color = colors[0], s = 5)
+            return
+        radius_x, radius_y, radius = dist2sketch(self.radius, bbox, resolution)
+        radius_x = radius_x[0]
+        radius_y = radius_y[0]
+        angles1 = self.neumann_angles[0].numpy() * 180 / np.pi
+        angles2 = self.neumann_angles[1].numpy() * 180 / np.pi
+        sphere = patches.Ellipse(origin_s, radius_x * 2, radius_y * 2, linewidth= lw,
+                                fill = fill, color = colors[0], label = self.name)
+        ax.add_patch(sphere)
+        for angle1, angle2 in zip(angles1, angles2):
+            neumann_arc = patches.Arc(origin_s,  2 * radius_x, 2 * radius_y, angle = -90, theta1=angle1, theta2=angle2, linewidth= lw, color=colors[1])
+            ax.add_patch(neumann_arc)  
+        
+
+    
+    def create_boundary_points(self, distance: float, res: int, spp: int, discrete_points : bool = True):
+        with dr.suspend_grad():
+            distance = -distance if self.inside else distance
+            points = create_circle_points(
+                self.origin, self.radius + distance, res, spp, discrete_points=discrete_points)
+            normal_dir = dr.normalize(points - self.origin)
+        return points, points, normal_dir
+
+    def create_boundary_result(self, result, points = None, resolution = 256):
+        with dr.suspend_grad():
+            tensor, tensor_mi = create_circle_from_result(result, resolution)
+        return tensor, tensor_mi
+    
+    def create_boundary_coefficient(self, tensor_mi, name = "boundary-val"):
+        def boundary_val(points, parameters):
+            resolution = dr.width(parameters["bval"].array)
+            vec = points - self.origin
+            angles = correct_angle(dr.atan2(vec[0], vec[1]))
+            angles = correct_angle(angles)
+            angles = dr.select(angles<0, angles + 2 * dr.pi, angles)
+            indices = angles / (2 * dr.pi) * resolution
+            index0 =  UInt32(dr.floor(indices)) % resolution
+            index1 = (index0 + 1) % resolution
+            residual = indices - Float(index0)
+            vals0 = dr.gather(Float, parameters["bval"].array, index0)
+            vals1 = dr.gather(Float, parameters["bval"].array, index1)
+            return vals0 * (1-residual) + vals1 * residual
+
+        coeffs = []
+        for i in range(tensor_mi.shape[0]):
+            parameters = {}
+            parameters["bval"] = Float(tensor_mi[i])
+            coeffs.append(FunctionCoefficient(name, dict(parameters), boundary_val))
+        return coeffs
+    
+    def set_normal_derivative(self, tensor_mi):
+        self.normal_derivatives = self.create_boundary_coefficient(tensor_mi, "normal-derivative")
+        return self.normal_derivatives
+    
+    def jakobian_to_boundary(self, bi : BoundaryInfo, distance : Float):
+        return 1 + distance / self.radius
+    
+    def get_normal_derivative(self, points : Point2f):
+        num_conf = len(self.normal_derivatives)
+        normal_ders = dr.zeros(ArrayXf, shape = [num_conf, dr.width(points)])
+        for i in range(num_conf):
+            normal_ders[i] = self.normal_derivatives[i].get_value(points)
+        return normal_ders
+    
+    def get_max_intersection_dist(self, bi : BoundaryInfo):
+        return 2 * self.radius
+    
+    def generate_sdf_grid(self, resolution, box_length = 2, box_center = [0,0],
+                          wrapping = "clamp", interpolation = "cubic", redistance = True, high_res = 2048):
+        bbox = [[box_center[0] - box_length/2, box_center[1] - box_length/2],
+                [box_center[0] + box_length/2, box_center[1] + box_length/2]]
+        points = create_image_points(bbox = bbox, resolution = resolution, spp = 1, centered = True)
+        inside = self.inside_closed_surface_mask(points)
+        min_d, a, b = self.closest_points(points)
+        distance = dr.select(inside, -min_d, min_d)
+        image_np, image_mi = create_image_from_result(distance, resolution)
+        return SDFGrid(image_np[0], box_length, box_center, self.dirichlet, self.epsilon, self.inf_distance,
+                       self.inside, self.name,
+                       normal_derivative_dist= self.normal_derivative_dist, wrapping = wrapping, interpolation=interpolation, 
+                       redistance = redistance, high_res = high_res, low_res=resolution[0])
+    
+        '''    
+    def generate_sdf_grid(self, resolution, box_length = 2, box_center = [0,0],
+                          wrapping = "clamp", interpolation = "cubic", redistance = True, high_res = 2048):
+        bbox = [[box_center[0] - box_length/2, box_center[1] - box_length/2],
+                [box_center[0] + box_length/2, box_center[1] + box_length/2]]
+        points, film_points = create_image_points(bbox = bbox, resolution = resolution, spp = 1, centered = True)
+        inside = self.inside_closed_surface(points)
+        min_d, a, b = self.closest_points(points)
+        distance = dr.select(inside, -min_d, min_d)
+        image_np, image_mi = create_image_from_result(distance, resolution)
+        return SDFGrid(image_np, box_length, box_center, self.dirichlet, self.epsilon, self.inf_distance, self.inf_boundary,
+                       self.inside, self.name,
+                       normal_derivative_dist= self.normal_derivative_dist, wrapping = wrapping, interpolation=interpolation, 
+                       redistance = redistance, high_res = high_res, low_res=resolution[0])
+    '''
+        
+    def move_circle_fd(self, fd_step, type = "x"):
+        origin1 = [self.origin[0], self.origin[1]]
+        origin2 = [self.origin[0], self.origin[1]]
+        radius1 = self.radius[0]
+        radius2 = self.radius[0]
+        if type == "x":
+            origin1 = [origin1[0] + fd_step / 2, origin1[1]]
+            origin2 = [origin2[0] - fd_step / 2, origin2[1]]
+        elif type == "y":
+            origin1 = [origin1[0], origin1[1] + fd_step / 2]
+            origin2 = [origin2[0], origin2[1] - fd_step / 2]
+        elif type == "r":
+            radius1 = radius1 + fd_step/2
+            radius2 = radius2 - fd_step/2
+        else: 
+            raise Exception("There is no such type.")
+        
+        circle1 =  CircleShape(origin1, radius1, dirichlet = self.dirichlet, neumann = self.neumann, epsilon = self.epsilon)
+        circle2 =  CircleShape(origin2, radius2, dirichlet = self.dirichlet, neumann = self.neumann, epsilon = self.epsilon)
+        return circle1, circle2
+        

data/PDE2D/BoundaryShape/circlewithelectrodes.py

@@ -0,0 +1,320 @@
+
+import drjit as dr
+import numpy as np
+from PDE2D.Coefficient import *
+from PDE2D.BoundaryShape import *
+from PDE2D.utils import *
+from PDE2D import ArrayXb, ArrayXu
+from mitsuba import Point2i
+import scipy
+
+class CircleWithElectrodes(CircleShape):
+    def __init__(self, origin = [0.0, 0.0], radius = 1.0, name = "electrodeCircle", epsilon = 1e-5,
+                 num_electrodes = 16, is_delta = False, electrode_length = 0.01, 
+                 injection_confs = [[0,1]], injected_current = 1.0, electrode_potentials = None,
+                 offset_angle = 0.0, centered = False, fileset = None, injection_set = None, delete_injection = True):
+        self.name = name
+        super().__init__(origin, radius, dirichlet_map = np.array([False]), epsilon = epsilon, name = self.name)
+        if fileset is not None:
+            mat = scipy.io.loadmat(fileset)
+            range_exp = self.get_injection_range_file_all(fileset=fileset, injection_sets=injection_set)
+            self.measured_current = True
+            self.voltages_first = mat["Uel"].T[range_exp]
+            self.num_confs = self.voltages_first.shape[0]
+            self.num_electrodes = self.voltages_first.shape[1]
+            self.voltages_first = np.hstack([np.zeros([self.num_confs,1]), self.voltages_first])
+            self.voltages_first = self.voltages_first.cumsum(axis = 1)[:, :16]
+            self.currents = mat["CurrentPattern"].T[range_exp]
+            nonzeros = np.nonzero(self.currents)
+            if delete_injection:
+                self.voltages = self.voltages_first
+                self.voltages[self.currents!=0] = 0
+                self.voltages = self.voltages - (np.sum(self.voltages, axis = 1))[:,np.newaxis] / (num_electrodes - 2)
+                self.voltages[self.currents!=0] = 0
+            else:
+                self.voltages = self.voltages_first
+                self.voltages = self.voltages - (np.mean(self.voltages, axis = 1))[:,np.newaxis]
+            #self.voltages = self.voltages.astype(np.float32)
+            self.voltages_std = np.zeros(num_electrodes)
+            positive_inj = nonzeros[1][np.nonzero((self.currents[nonzeros] > 0).astype(np.int16) )]
+            negative_inj = nonzeros[1][np.nonzero((self.currents[nonzeros] < 0).astype(np.int16) )]
+            current_confs = np.vstack([positive_inj, negative_inj]).T
+            self.electrode_length = 0.025
+            self.injected_current = np.abs(self.currents[nonzeros][0])
+            self.injections = current_confs
+            self.injection_confs = Point2i(current_confs.T)
+        else:
+            self.num_electrodes = num_electrodes
+            
+            if injection_set is None:
+                if injection_confs is not None:
+                    self.injections = injection_confs 
+                else:
+                    raise Exception("Either specify an injection set or injection configuration.")
+            else:
+                self.injections = self.create_injection_set_all(injection_set, num_electrodes)
+            self.num_confs = len(self.injections)
+            self.injection_confs = Point2i(np.array(self.injections).T) # The first one is injected, the second one is received.
+            
+            self.injected_current = injected_current
+            self.voltages = electrode_potentials
+            self.electrode_length = electrode_length 
+        
+        self.is_delta = is_delta
+        self.has_delta = is_delta
+        self.NEE = NEE.Special
+        self.has_continuous_neumann = not is_delta
+        self.el_diff_angle = 2 * dr.pi / self.num_electrodes
+        self.el_center_angles = correct_angle(offset_angle +  dr.arange(Float, self.num_electrodes) * self.el_diff_angle)
+        
+        self.normal_ders = {}
+        if not is_delta:
+            self.el_angle = self.electrode_length / self.radius
+            if not centered:
+                self.el_center_angles += self.el_angle/2
+                self.el_center_angles = correct_angle(self.el_center_angles)
+            el_ending1 = correct_angle(self.el_center_angles - self.el_angle/2)
+            el_ending2 = correct_angle(self.el_center_angles + self.el_angle/2) 
+            self.el_endings = Point2f(el_ending1, el_ending2)
+            dr.make_opaque(self.el_endings)
+            
+        dr.make_opaque(self.el_center_angles)
+        self.num_conf_n = self.num_confs
+        
+
+    def create_injection_set_all(self, injection_sets, num_electrodes):
+        sets = injection_sets.split("-")
+        final_set = []
+        for set in sets:
+            final_set.extend(self.create_injection_set(set, num_electrodes))
+        return final_set
+
+    def create_injection_set(self, injection_set, num_electrodes):
+        if injection_set == "adjacent":
+            set = [[i, (i + 1) % num_electrodes] for i in range(num_electrodes)]
+        elif injection_set[:4] == "skip":
+            try:
+                skip =  int(injection_set[4:])
+            except:
+                print("You need to specify a number after skip.")
+            set = [[i, (i + skip + 1) % num_electrodes] for i in range(num_electrodes)]
+        elif injection_set[:7] == "against":
+            try:
+                against =  int(injection_set[7:])
+            except:
+                print("You need to specify a number after against.")
+            set = [[against, (against + i) % num_electrodes] for i in range(num_electrodes - 1)]
+        else:
+            raise Exception("There is no such injection set.")
+        return set
+
+    def get_injection_range_file_all(self, fileset, injection_sets):
+        sets = injection_sets.split("-")
+        range_all = []
+        for set in sets:
+            range_all.extend(self.get_injection_range_file(fileset, set))
+        return range_all
+
+    def get_injection_range_file(self, fileset, injection_set : str):
+        if injection_set == "adjacent":
+            range_exp = [i for i in range(0, 16)]
+        elif injection_set == "skip1":
+            range_exp = [i for i in range(16, 32)]
+        elif injection_set == "skip2":
+            range_exp = [i for i in range(32, 48)]
+        elif injection_set == "skip3":
+            range_exp = [i for i in range(48, 64)]
+        elif injection_set == "against1":
+            range_exp = [i for i in range(64, 79)]
+        elif injection_set == "all":
+            range_exp = [i for i in range(0, 79)]
+        else:
+            raise Exception("There is no such injection!")
+        return range_exp
+    
+    def get_injection_confs(self, allsets : str, vis_set, num_electrodes : int):
+        sets = allsets.split("-")
+        range_all = []
+        begin = 0
+        end = 0
+        found = False
+        for set in sets:
+            if set == vis_set:
+                set = self.create_injection_set(set, num_electrodes)
+                found = True
+                begin = len(range_all)
+                end = begin + len(set)
+            else:
+                range_all.extend(self.create_injection_set(set, num_electrodes))
+        if not found:
+            raise Exception("Such set does not exist")
+        else:
+            return [dr.opaque(UInt32, i, shape = (1)) for i in range(begin, end)]
+    
+    @dr.syntax        
+    def sampleNEE(self, bi : BoundaryInfo, sample : Float, conf_number : UInt32) -> tuple[Float, Float, Float, Point2f]:
+        d, n, pdf_r, sampled = (Float(0), Float(0), Float(0), Point2f(0))
+        if dr.hint(self.has_continuous_neumann, mode = 'scalar'):
+            d, n, pdf_r, sampled  = (Float(0), Float(0), Float(0) , Point2f(0))
+            if sample < 0.5:
+                sample *= 2
+                d, n, pdf_r, sampled = self.sample_electrode(bi, sample, conf_number, injected = True)
+            else:
+                sample = 2 * (sample - 0.5) 
+                d, n, pdf_r, sampled = self.sample_electrode(bi, sample, conf_number, injected = False)
+        return d, n, pdf_r/2, sampled
+        
+    def get_point_neumann(self, bi : BoundaryInfo, conf_number : UInt32) -> tuple[list[Float], list[Float], list[Float], list[Point2f]]:
+        if self.has_delta:
+            d1, n1, pdf1_r, sampled1 = self.sample_electrode(bi, Float(0), conf_number, injected = True)
+            d2, n2, pdf2_r, sampled2 = self.sample_electrode(bi, Float(0), conf_number, injected = False)
+        return [d1, d2], [n1, n2], [pdf1_r, pdf2_r], [sampled1, sampled2]
+
+    def sample_electrode(self, bi : BoundaryInfo, sample : Float, conf_number : UInt32 , injected = True):
+        sign = 1 if injected else -1
+        electrode_num = 0 if injected else 1
+        # This function assumes there is only 2 electrode injection
+        current_conf = dr.gather(Point2i, self.injection_confs, conf_number)
+        diff1 = bi.x1 - self.origin
+        diff2 = bi.x2 - self.origin
+        star_angle1 = correct_angle(dr.atan2(diff1[0], diff1[1]))
+        star_angle2 = correct_angle(dr.atan2(diff2[0], diff2[1]))
+        if self.is_delta:
+            s = dr.gather(Float, self.el_center_angles, current_conf[electrode_num])
+            valid =  self.inside_range(star_angle1, star_angle2, s)
+            neumann = dr.select(valid & bi.is_star, self.injected_current, 0) * sign
+            sampled_point = self.origin + self.radius * Point2f(dr.sin(s), dr.cos(s))
+            distance = dr.norm(sampled_point - bi.origin)
+            pdf_r = 2 * dr.pi * distance # actual pdf is "1", we multiply everything by 2 pi r, (cancels out Green's function computation)
+        else: # either one of the electrode ends are inside the star or the whole electrode covers the star.
+            el_end1 = dr.gather(Float, self.el_endings[0], current_conf[electrode_num])
+            el_end2 = dr.gather(Float, self.el_endings[1], current_conf[electrode_num])
+            el_end1_inside = self.inside_range(star_angle1, star_angle2, el_end1)
+            el_end2_inside = self.inside_range(star_angle1, star_angle2, el_end2)
+            el_active = bi.is_star & (el_end1_inside | el_end2_inside | self.inside_range(el_end1, el_end2, star_angle1))
+            sample_range1 = dr.select(el_end1_inside, el_end1, star_angle1)
+            sample_range2 = dr.select(el_end2_inside, el_end2, star_angle2)
+            current_flux = self.injected_current / self.electrode_length
+            neumann = dr.select(el_active, current_flux, 0) * sign
+            # We are going to sample an angle from the star center! So we find the range of angles first
+            sample_p_range1 = self.origin + self.radius * Point2f(dr.sin(sample_range1), dr.cos(sample_range1))
+            sample_p_range2 = self.origin + self.radius * Point2f(dr.sin(sample_range2), dr.cos(sample_range2))
+            range_vec1 = sample_p_range1 - bi.origin
+            range_vec2 = sample_p_range2 - bi.origin
+            angle1 = correct_angle(dr.atan2(range_vec1[0], range_vec1[1]))
+            angle2 = correct_angle(dr.atan2(range_vec2[0], range_vec2[1]))
+            bi.update_angles(angle1, angle2)
+            # We also need to change on_boundary value. We sample as if we are on the boundary only 
+            # if the star origin is on the boundary and inside electrode!
+            angle_n = correct_angle(dr.atan2(bi.bn[0], bi.bn[1]))
+            star_origin_angle = correct_angle(angle_n + dr.pi) 
+            on_boundary_electrode = bi.on_boundary & self.inside_range(el_end1, el_end2, star_origin_angle)
+            direction, pdf = bi.sample_neumann(sample, on_boundary_electrode)
+            # distance, sampled_point, normals = self.ray_intersect(bi.origin, direction, bi.on_boundary)
+            ri = self.ray_intersect(bi, direction)
+            pdf_r = pdf * dr.abs(dr.dot(direction, ri.normal)) * 2 * dr.pi # pdf with respect to area and also multiplied with 2 pi r
+            distance = ri.t
+            sampled_point = ri.intersected
+        return distance, neumann, pdf_r, sampled_point
+            
+    def inside_range(self, angle1, angle2, angle):
+        electrode_start = angle1 > angle2
+        normal_case = (angle1 < angle) & (angle2 > angle)
+        start_case = (angle1 < angle) | (angle2 > angle)
+        return  dr.select(electrode_start, start_case, normal_case)
+
+    def create_neumann_function(self, conf_numbers : list[UInt32]):
+        if self.is_delta:
+            raise NotImplementedError
+        confs = []
+        for conf_number in conf_numbers: 
+            params = {}
+            params["conf"] = conf_number
+            def neumann_val(point, params):
+                injections = dr.gather(Point2i, self.injection_confs, params["conf"])
+                el1_ending1 = dr.gather(Float, self.el_endings[0], injections[0])
+                el1_ending2 = dr.gather(Float, self.el_endings[1], injections[0])
+                el2_ending1 = dr.gather(Float, self.el_endings[0], injections[1])
+                el2_ending2 = dr.gather(Float, self.el_endings[1], injections[1])
+                diff = point - self.origin
+                angle_point = correct_angle(dr.atan2(diff[0], diff[1]))
+                inside_el1 = self.inside_range(el1_ending1, el1_ending2, angle_point)
+                inside_el2 = self.inside_range(el2_ending1, el2_ending2, angle_point)
+                neumann_val = self.injected_current / self.electrode_length
+                result = dr.select(inside_el1, neumann_val, 0)
+                result = dr.select(inside_el2, -neumann_val, result)
+                return result
+            neumann_coeff = FunctionCoefficient(f"neumann-{conf_number}", params, neumann_val)
+            confs.append(neumann_coeff)
+        return confs
+    
+    def create_electrode_points(self, spe, conf_numbers : list[UInt32], delete_injection : bool = True):
+        
+        angles = Float(self.el_center_angles)
+        points = self.origin + self.radius * Point2f(dr.sin(angles), dr.cos(angles))
+        dr.make_opaque(points)
+        points = dr.repeat(points, spe)
+
+        electrode_nums = dr.zeros(ArrayXu, shape = (len(conf_numbers), self.num_electrodes))
+        active_confs = dr.zeros(ArrayXb, shape=(len(conf_numbers), self.num_electrodes))
+        for i, conf_number in enumerate(conf_numbers):
+            electrode_num = np.arange(self.num_electrodes)
+            active_conf = np.zeros(self.num_electrodes, dtype = bool)
+            if delete_injection:
+                current_conf = dr.gather(Point2i, self.injection_confs, conf_number)
+                electrode_num = np.delete(electrode_num, current_conf.numpy())
+                active_conf[electrode_num] = True
+            electrode_nums[i] = UInt32(electrode_num)
+            active_confs[i] = Bool(active_conf)
+        
+        dr.make_opaque(active_confs)
+        active_confs = dr.repeat(active_confs, spe)
+        dr.make_opaque(electrode_nums)
+        return points, active_confs, electrode_nums
+    
+    def sketch(self, ax, bbox, resolution, colors = ["orange", "green"], lw = 3, e_size = None):
+        origin_s = point2sketch(self.origin, bbox, resolution)
+        origin_s = np.array([origin_s[0][0], origin_s[1][0]])
+        radius_x, radius_y, radius = dist2sketch(self.radius, bbox, resolution)
+        radius_x = radius_x.numpy()[0]
+        radius_y = radius_y.numpy()[0]
+        sphere = patches.Ellipse(origin_s, radius_x * 2, radius_y * 2, linewidth= lw,
+                                fill = False, color = colors[0], label = self.name)
+        ax.add_patch(sphere)
+
+        origin_s = point2sketch(self.origin, bbox, resolution)
+        origin_s = np.array([origin_s[0][0] - 0.5, origin_s[1][0] - 0.5])
+        radius_x, radius_y, radius = dist2sketch(self.radius, bbox, resolution)
+        radius_x = radius_x.numpy()[0]
+        radius_y = radius_y.numpy()[0]
+        if self.is_delta:
+            el_points = point2sketch(self.origin + self.radius * Point2f(dr.sin(self.el_center_angles), dr.cos(self.el_center_angles)),
+                                     bbox, resolution).numpy().squeeze()
+            if e_size is None:
+                ax.scatter(el_points[0,:] -0.5, el_points[1,:]-0.5, color = colors[1])
+            else:
+                ax.scatter(el_points[0,:] -0.5, el_points[1,:]-0.5, color = colors[1], s = e_size)
+        else:
+            angles1 = self.el_endings.numpy()[0, :] * 180 / np.pi
+            angles2 = self.el_endings.numpy()[1, :] * 180 / np.pi
+            for angle1, angle2 in zip(angles1, angles2):
+                neumann_arc = patches.Arc(origin_s,  2 * radius_x, 2 * radius_y, angle = -90, theta1=angle1, 
+                                          theta2=angle2, linewidth = lw, color = colors[1])
+                ax.add_patch(neumann_arc)  
+
+    def sketch_electrode_input(self, ax, bbox, resolution, conf_number = UInt32(0), color = "red"):
+        current_conf = dr.gather(Point2i, self.injection_confs, conf_number)
+        angle1 = dr.gather(Float, self.el_center_angles, current_conf[0])
+        angle2 = dr.gather(Float, self.el_center_angles, current_conf[1])
+        point1_start = point2sketch(self.origin + self.radius * 1.1 * Point2f(dr.sin(angle1), dr.cos(angle1)), bbox, resolution).numpy().squeeze()
+        point1_diff = dir2sketch(-0.08 * self.radius * Point2f(dr.sin(angle1), dr.cos(angle1)), bbox, resolution).numpy().squeeze()
+        point2_start = point2sketch(self.origin + self.radius * 1.02 * Point2f(dr.sin(angle2), dr.cos(angle2)), bbox, resolution).numpy().squeeze()
+        point2_diff = dir2sketch(self.radius * 0.08 * Point2f(dr.sin(angle2), dr.cos(angle2)), bbox, resolution).numpy().squeeze()
+        arrow_1 = patches.FancyArrow(point1_start[0] - 0.5, point1_start[1] - 0.5, point1_diff[0], point1_diff[1], 
+                                    width=2 / 512 * resolution[0], length_includes_head=True, color = color)
+        arrow_2 = patches.FancyArrow(point2_start[0] - 0.5, point2_start[1] - 0.5, point2_diff[0], point2_diff[1], 
+                                    width=2 / 512 * resolution[0], length_includes_head=True, color = color)
+        ax.add_patch(arrow_1)
+        ax.add_patch(arrow_2)
+        
+    

data/PDE2D/BoundaryShape/interaction.py

@@ -0,0 +1,186 @@
+import drjit as dr
+from ..utils.helpers import *
+from ..utils.sketch import *
+from matplotlib import patches as patches
+from mitsuba import Point2f, Vector2f, Bool, Float, UInt32 
+from PDE2D import ArrayXf
+from ..Sampling import sample_star_direction, sample_sec_direction, pdf_sec_direction
+
+
+class BoundaryInfo:
+    DRJIT_STRUCT = {
+        'origin' : Point2f,
+        'on_boundary': Bool,
+        'r' : Float,
+        'd' : Float,
+        'is_far' : Bool,
+        'bpoint' : Point2f,
+        'dd' : Float,
+        'dval' : ArrayXf,
+        'dpoint' : Point2f,
+        'bdir' : Vector2f,
+        'bn' : Vector2f,
+        'is_d' : Bool,
+        'is_n' : Bool,
+        'is_e' : Bool,
+        'shape' : UInt32, # Index of the closest boundary
+        'd_shape' : UInt32, # Index of the closest dirichlet boundary
+        'is_star' : Bool,
+        'x1' : Point2f,
+        'x2' : Point2f,
+        'angle1' : Float,
+        'angle2' : Float,
+        'angle1_adj': Float,
+        'angle2_adj' : Float,
+        'gamma1' : Float,
+        'gamma2' : Float,
+    }
+    def __init__(self, origin = None, on_boundary = None, r = None, d = None, is_far = None, 
+                 bpoint = None, curvature = None,
+                dd = None, dval = None, dpoint = None, bdir = None, bn = None,
+                is_d = None, is_n = None, is_e = None, shape = None, d_shape = None, 
+                is_star = None, x1 = None, x2 = None, angle1 = None, angle2 = None, 
+                angle1_adj = None, angle2_adj = None, gamma1 = None, gamma2 = None):
+        self.origin = origin
+        self.on_boundary = on_boundary
+        self.r = r
+        self.d = d
+        self.is_far = is_far 
+        self.bpoint = bpoint
+        self.curvature = curvature
+        self.dd = dd
+        self.dval = dval
+        self.dpoint = dpoint
+        self.bdir = bdir
+        self.bn = bn
+        self.is_d = is_d
+        self.is_n = is_n
+        self.is_e = is_e
+        self.shape = shape
+        self.d_shape = d_shape
+        self.is_star = is_star
+        self.x1 = x1
+        self.x2 = x2
+        self.angle1 = angle1
+        self.angle2 = angle2
+        self.angle1_adj = angle1_adj
+        self.angle2_adj = angle2_adj
+        self.gamma1 = gamma1
+        self.gamma2 = gamma2
+    
+    def sample_recursive(self, sample : Float): # samples the full star
+        direction, pdf = sample_star_direction(sample, self.on_boundary & self.is_star, self.bn)
+        sphere_points =  self.origin + self.r * direction
+        return direction, sphere_points, pdf
+    
+    def pdf_recursive(self):
+        return dr.select(self.on_boundary & self.is_star, 1/dr.pi, 1/(2 * dr.pi))
+    
+    @dr.syntax
+    def sample_brute_force(self, sample : Float, mis_rate : Float = Float(0.5), threshold : Float = Float(0.49 * dr.pi)):
+        "Applies a bit more sophisticated sampling scheme, mis between uniform and secant weighted distribution if we are near the boundary."
+        sampled_dir = Point2f(0)
+        pdf = Float(0)
+        if self.on_boundary | (self.d < (dr.abs(dr.rcp(self.curvature)) / 10)):
+            direction = dr.select(self.on_boundary, self.bn, self.bdir)
+            sec_mask = sample < mis_rate
+            sample = dr.select(sec_mask, sample / mis_rate, (sample - mis_rate) / (1.0-mis_rate))
+            if sec_mask:
+                sampled_dir = sample_sec_direction(sample, direction, threshold)
+            else:
+                sampled_dir, _, _ = self.sample_recursive(sample)
+            
+            pdf_sec = pdf_sec_direction(sampled_dir, direction, threshold)
+            pdf_rec = self.pdf_recursive()
+            pdf = mis_rate * pdf_sec + (1.0-mis_rate) * pdf_rec
+        else:
+            sampled_dir, _, pdf  = self.sample_recursive(sample)
+        
+        return sampled_dir, pdf
+        
+
+    def sample_neumann(self, sample : Float, on_boundary : Bool): # samples only the boundary part
+        # inside case
+        angle_diff = correct_angle(self.angle2_adj - self.angle1_adj)
+        angle_in = correct_angle(self.angle1_adj + angle_diff * sample)
+        direction_in = Vector2f(dr.sin(angle_in), dr.cos(angle_in))
+        # on-boundary case
+        angle_n = correct_angle(dr.atan2(self.bn[0], self.bn[1]))
+        angle_n1 = dr.pi/2 - correct_angle(self.angle1_adj - angle_n)
+        angle_n2 = dr.pi/2 - correct_angle(angle_n - self.angle2_adj)
+        angle_sum = angle_n1 + angle_n2
+        angle_diff_b = dr.pi - angle_sum
+        angle_boundary = sample * angle_sum 
+        angle_boundary += dr.select(angle_boundary > angle_n2, angle_diff_b, 0)
+        angle_boundary -= dr.pi/2
+        dir_n = Vector2f(dr.sin(angle_boundary), dr.cos(angle_boundary))
+        direction_boundary = to_world_direction(dir_n, self.bn)
+        direction = dr.select(on_boundary, direction_boundary, direction_in)
+        pdf = dr.select(on_boundary, 1/angle_sum, 1/(angle_diff))
+        return direction, pdf
+    
+    def pdf_neumann():
+        pass
+    
+    def update_angles(self, angle1, angle2): 
+        # this is done if we do not want to sample the whole Neumann part of the star
+        self.angle1_adj = angle1
+        self.angle2_adj = angle2
+    
+    def sketch_stars(self, ax, indices, bbox, resolution, color_star = "green", color_critical = "blue"):
+        actives = self.is_star.numpy()[indices]
+        origins = point2sketch(self.origin, bbox, resolution).numpy()[:, indices]
+        radii_x, radii_y, radii = dist2sketch(self.r, bbox, resolution)
+        radii_x = radii_x.numpy()[indices]
+        radii_y = radii_y.numpy()[indices]
+        x1s = point2sketch(self.x1, bbox, resolution).numpy()[:, indices]
+        x2s = point2sketch(self.x2, bbox, resolution).numpy()[:, indices]
+        angles1 = self.angle1.numpy()[indices] * 180 / np.pi
+        angles2 = self.angle2.numpy()[indices] * 180 / np.pi
+        for origin, radius_x, radius_y, x1, x2, angle1, angle2, active \
+            in zip(origins, radii_x, radii_y, x1s, x2s, angles1, angles2, actives):
+                if active:
+                    #star = patches.Ellipse(origin, 
+                    #                radius_x * 2, radius_y * 2, 
+                    #                fill = False, color = color_star)
+                    star = patches.Arc(origin,  2 * radius_x, 2 * radius_y, angle = -90, 
+                                              theta1=angle2, theta2=angle1, linewidth=2.5, color=color_star)
+                    center = patches.Ellipse(origin, 4, 4, 
+                                    fill = True, color = color_star)
+                    critical1 = patches.Ellipse([x1[0], x1[1]], 4, 4, 
+                                        fill = True, color = color_critical)
+                    critical2 = patches.Ellipse([x2[0], x2[1]], 4, 4, 
+                                        fill = True, color = color_critical)
+                    #ax.arrow(x1[0], x1[1], n1[0], n1[1], color = color_critical,
+                    #    edgecolor = "none", width = 0.03)
+                    #ax.arrow(x2[0], x2[1], n2[0], n2[1], color = color_critical,
+                    #    edgecolor = "none", width = 0.03)
+                    ax.add_patch(star)
+                    ax.add_patch(center)
+                    ax.add_patch(critical1)
+                    ax.add_patch(critical2)
+
+
+class RayInfo:
+    DRJIT_STRUCT = {
+        'origin' : Point2f,
+        'direction' : Vector2f,
+        't' : Float,
+        'intersected' : Point2f,
+        'normal' : Vector2f,
+        'is_dirichlet' : Bool,
+        'neumann' : ArrayXf # We want to get multiple neumann values at once.
+    }
+    def __init__(self, origin = None, direction = None, t = None, intersected = None, normal = None, is_dirichlet = None,  neumann = None):
+        self.origin = origin
+        self.direction = direction
+        self.t = t
+        self.intersected = intersected
+        self.normal = normal
+        self.is_dirichlet = is_dirichlet
+        self.neumann = neumann 
+
+        
+
+
+    

data/PDE2D/BoundaryShape/sdf_grid.py

@@ -0,0 +1,491 @@
+
+from .boundary_shape import *
+from ..utils.helpers import *
+from ..utils.sketch import *
+from ..Coefficient import ConstantCoefficient
+import skfmm
+from scipy import optimize
+from .interaction import *
+
+class SDFGrid(Shape):
+    def __init__(self, tensor_np = np.zeros([16, 16]), box_length = 2.1, box_center = [0,0], dirichlet : list[Coefficient] = [], 
+                 epsilon=1e-5, inf_distance=10, inside = False, name = "boundary", type = "sdf", 
+                 normal_derivative_dist = 0.01, wrapping = "clamp", interpolation = "cubic", redistance = True,
+                 translation = [0,0], low_res = None, high_res = 2048):
+        super().__init__(True, single_closed_shape=True, epsilon=epsilon,
+                         inf_distance=inf_distance, inside = inside)
+        low_res = tensor_np.shape[0] if low_res is None else low_res
+        tensor_np = tensor_np.squeeze()
+        if not (tensor_np.shape[0] == tensor_np.shape[1]):
+            raise Exception("You need to specify a square image.")
+        self.name = name
+        self.res =  low_res
+        self.resolution = [low_res, low_res]
+        self.high_res_factor = int(high_res / self.res)
+        self.res_high =  high_res
+        self.type = type
+        self.box_center = mi.Point2f(box_center)
+        self.box_length = mi.Float(box_length)
+        self.bbox = [[box_center[0] - box_length/2, box_center[1] - box_length/2],
+                     [box_center[0] + box_length/2, box_center[1] + box_length/2]]
+        
+        
+        #self.dx = box_length / self.res
+        self.dx_high = box_length / self.res_high
+        #self.threshold = self.dx * 0.25
+        # SDF shape only supports dirichlet boundary conditions.
+        self.is_full_dirichlet = True
+        # Dirichlet Boundary Values
+        self.dirichlet = dirichlet
+        self.normal_derivative_dist = normal_derivative_dist
+        self.redistance = redistance
+        self.translation_x = mi.Float(translation[0])
+        self.translation_y = mi.Float(translation[1])
+        self.tensor = mi.TensorXf(tensor_np[..., np.newaxis])
+
+        dr.make_opaque(self.translation_x)
+        dr.make_opaque(self.translation_y)
+        dr.make_opaque(self.tensor)
+        self.wrapping = wrapping
+        self.interpolation = interpolation
+
+        if redistance:
+            self.tensor = self.redistance_tensor(self.tensor)
+        self.texture = self.update_texture(self.tensor)
+        dr.make_opaque(self.texture)
+
+        self.num_conf_d = len(dirichlet)
+        self.num_conf_n = 1
+        assert (self.num_conf_d == self.num_conf_n) or (self.num_conf_n == 1) or (self.num_conf_d == 1)
+    
+    
+    def redist(self):
+        self.tensor = self.redistance_tensor(self.tensor)
+        self.texture = self.update_texture(self.tensor)
+        
+    def update_texture(self, tensor):
+        # Creating the texture!
+        wrap_mode = None
+        if self.wrapping == "clamp":
+            wrap_mode = dr.WrapMode.Clamp
+        elif self.wrapping == "mirror":
+            wrap_mode = dr.WrapMode.Mirror
+        elif self.wrapping == "repeat":
+            wrap_mode = dr.WrapMode.Repeat
+        else:
+            raise Exception("Such wrapping is not defined.")
+
+        texture = mi.Texture2f(
+            tensor, wrap_mode=wrap_mode, use_accel=False, migrate=False, filter_mode=dr.FilterMode.Linear)
+        return texture
+    
+    def rasterize_tensor(self, res, texture):
+        resolution = [res, res]
+        points = create_image_points(self.bbox, resolution, spp = 1, centered = True)
+        vals = self.get_texture_value(points, texture)   
+        image, _ = create_image_from_result(vals,  resolution)
+        return image[0]
+    
+    def get_texture_value(self, points: mi.Point2f, texture):
+        points_bbox = self.get_position(points)
+        if (self.interpolation == "cubic"):
+            texture_val =  texture.eval_cubic(points_bbox)[0]
+        elif (self.interpolation == "linear"):
+            texture_val = texture.eval(points_bbox)[0]
+        else:
+            raise Exception(
+                f"There is no interpolation called \"{self.interpolation}\"")
+        return texture_val
+    
+    def redistance_tensor(self, tensor):
+        texture_low = self.update_texture(tensor)
+        high_array  = self.rasterize_tensor(self.res_high, texture_low)
+        high_array = skfmm.distance(high_array.astype(np.float64), dx = self.dx_high)
+
+        tensor_high = mi.TensorXf(high_array[..., np.newaxis])
+        texture_high = self.update_texture(tensor_high)
+        low_array = self.rasterize_tensor(self.res, texture_high)
+        tensor_low = mi.TensorXf(low_array[..., np.newaxis])
+        return tensor_low
+    
+    def update(self, optimizer : mi.ad.Optimizer):
+        for key in optimizer.keys():
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if (name == self.name) & (param == "tensor") & (type == "dirichlet"):
+                # Apply redistancing.
+                optimizer[key] = self.redistance_tensor(optimizer[key])
+                self.tensor = optimizer[key]
+                dr.make_opaque(self.tensor)
+                self.texture = self.update_texture(self.tensor)
+            
+            if (name == self.name) & (param == "translation_x") & (type == "dirichlet"):
+                self.translation_x = optimizer[key]
+                dr.make_opaque(self.translation_x)
+            
+            if (name == self.name) & (param == "translation_y") & (type == "dirichlet"):
+                self.translation_y = optimizer[key]
+                dr.make_opaque(self.translation_y)
+            
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.dirichlet.get_opt_params(param_dict, opt_params)
+
+    def get_opt_params_shape(self, param_dict: dict, opt_params: list):
+        for key in opt_params:
+            vals = key.split(".")
+            boundary_name = vals[0]
+            boundary_type = vals[1]
+            param = vals[2]
+            if (param == "tensor") and (boundary_type == "dirichlet") and (boundary_name == self.name):
+                param_dict[f"{self.name}.dirichlet.tensor"] = self.tensor
+            elif (param == "translation_x") and (boundary_type == "dirichlet") and (boundary_name == self.name):
+                param_dict[f"{self.name}.dirichlet.translation_x"] = self.translation_x
+            elif (param == "translation_y") and (boundary_type == "dirichlet") and (boundary_name == self.name):
+                param_dict[f"{self.name}.dirichlet.translation_y"] = self.translation_y
+            elif (boundary_name == self.name):
+                raise Exception(
+                    f"SDFGrid ({self.name}) does not have a parameter called \"{param}\"")
+             
+    def get_position(self, points_ : mi.Point2f):
+        points = points_ - mi.Point2f(self.translation_x, self.translation_y)
+        "Get the new positions of the points normalized for the bbox."
+        x = (points[0] - self.bbox[0][0]) / (self.bbox[1][0] - self.bbox[0][0])
+        y = 1.0 - (points[1] - self.bbox[0][1]) / (self.bbox[1][1] - self.bbox[0][1])
+        return mi.Point2f(x, y) 
+    
+    
+    def get_closest_dist(self, points : mi.Point2f):
+        dist = self.get_texture_value(points, self.texture)
+        return dist
+    
+    @dr.syntax
+    def ray_intersect(self, bi : BoundaryInfo, direction, on_boundary : mi.Bool, max_step = 100):
+        with dr.suspend_grad():
+            dist = self.get_closest_dist(bi.origin)
+            close_mask = dist < 100 * dr.epsilon(mi.Float)
+            normal = self.get_normal(bi.origin)
+            point = dr.select(close_mask & (dr.dot(normal, direction) > 0),
+                           bi.origin + normal * 200 * dr.epsilon(mi.Float),
+                           bi.origin)
+            active = mi.Bool(True)
+            i = mi.UInt(0)
+            while (active & (i < max_step)):
+                i += 1
+                dist = self.get_closest_dist(point)
+                close_mask = dist < 10 * dr.epsilon(mi.Float)
+                far_mask = dist > self.inf_distance
+                active &= (~far_mask & ~close_mask)
+                point = dr.select(active, point + direction * mi.Point2f(dist, dist), point)
+                point = dr.select(far_mask, dr.inf, point) 
+            point = dr.select(active, dr.inf, point)
+            t = dr.norm(point - bi.origin)
+            normals = self.get_normal(point)
+        
+        return RayInfo(bi.origin, direction, t, point, normals, mi.Bool(True), mi.Float(0))
+    
+    def get_distance_correction(self, points):
+        grad = self.get_grad(points)
+        return dr.norm(grad)
+    
+    def get_grad_hessian(self, points : mi.Point2f):
+        # We are not using high res texture here as we only compute
+        # gradient at the boundary
+        dilate_x = self.bbox[1][0] - self.bbox[0][0]
+        dilate_y = self.bbox[1][1] - self.bbox[0][1]
+        points_bbox = self.get_position(points)
+        eval_result = self.texture.eval_cubic_hessian(points_bbox)
+        grad = eval_result[1][0] / mi.Point2f(dilate_x, -dilate_y)
+        hessian_ = eval_result[2][0]
+        hessian_x = hessian_[0, 0] / (dilate_x ** 2)
+        hessian_y = hessian_[1, 1] / (dilate_y ** 2)
+        hessian_xy = hessian_[0, 1] / (-dilate_x * dilate_y)
+        hessian = mi.Matrix2f([[hessian_x, hessian_xy],
+                               [hessian_xy, hessian_y]])
+        return grad, hessian
+    
+                
+    def get_grad(self, points: mi.Point2f):
+        dilate_x = self.bbox[1][0] - self.bbox[0][0]
+        dilate_y = self.bbox[1][1] - self.bbox[0][1]
+        points_bbox = self.get_position(points)
+        eval_result = self.texture.eval_cubic_grad(points_bbox)
+        grad = eval_result[1][0] / mi.Point2f(dilate_x, -dilate_y)
+        return mi.Point2f(grad)
+    
+                
+    def get_normal(self, points : mi.Point2f):
+        grad = self.get_grad(points)
+        return dr.normalize(grad)
+    
+    def get_boundary_distance(self, points : mi.Point2f):
+        dist0 = self.get_texture_value(points, self.texture)
+        grad0 = self.get_grad(points)
+        norm0 = dr.norm(grad0)
+        normal_dir = dr.detach(grad0 / norm0)
+        
+        # We first take a step in the sphere direction. 
+        # Now we are most probably in the problematic region where norm of 
+        # the gradient is not 1.
+        points1 = dr.detach(points - normal_dir * dist0)
+        dist1 = self.get_texture_value(points1, self.texture)
+        grad1 = self.get_grad(points1)
+        norm1 = dr.norm(grad1)
+        normal1 = dr.detach(grad1 / norm1)
+        
+        # Now we will take another step.
+        points2 = dr.detach(points1 - normal1 * dist1)
+        dist2 = self.get_texture_value(points2, self.texture)
+        grad2 = self.get_grad(points2)
+        norm2 = dr.norm(grad2)
+        
+        # Now we linearly approximate the norm of the gradient in the direction of the normal dir.
+        # We set the loc of points2 to 0 and points1 to dist1.
+        x2 = mi.Float(0)
+        x1 = mi.Float(dist1)
+        # The norm of the gradient along the line will be ax + b near the boundary.
+        a = (norm1 - norm2) / (x1 - x2)
+        b = norm2
+        
+        # Now the texture value near the boundary in the normal direction is the integral of this.
+        # axˆ2/2 + bx + dist2
+        # Zero crossing value (the root) of this function is the following.
+        x_zero =  (-b  + dr.sqrt((dr.sqr(b) - 2 * a * dist2))) / a
+        return dist0 + dist1 - x_zero
+        
+        # Now this value is wrong
+
+    
+    def boundary_interaction(self, points: mi.Point2f, radius_fnc : callable = None, 
+                             star_generation = False, max_radius = Float(dr.inf), conf_numbers : list[mi.UInt32] = [mi.UInt32(0)]) -> BoundaryInfo:
+
+        min_distance = self.get_closest_dist(points)
+        bpoints = mi.Point2f(points)
+        radius = mi.Float(min_distance)
+        if radius_fnc is not None:
+            radius = radius_fnc(radius)
+        radius = dr.minimum(radius, max_radius)
+        is_epsilon_shell = (min_distance < self.epsilon) 
+        boundary_normal = self.get_normal(bpoints)
+        
+        num_conf = len(conf_numbers)
+        dirichlet = dr.zeros(ArrayXf, shape = (num_conf, dr.width(points)))
+
+        if dr.hint(self.num_conf_d == 1, mode = 'scalar'):
+            dirichletval = self.dirichlet[0].get_value(bpoints)
+            for i in range(num_conf):
+                dirichlet[i] = dirichletval
+        else:
+            for i in range(self.num_conf_d): 
+                for j, conf in enumerate(conf_numbers):
+                    dirichlet[j] = dr.select(i == conf, 
+                                            self.dirichlet[i].get_value(bpoints), 
+                                            dirichlet[j])
+
+        curvature =  self.compute_curvature(points)
+        return BoundaryInfo(points, mi.Bool(False), radius, min_distance, min_distance > self.inf_distance, 
+                     bpoints, curvature, min_distance, dirichlet, bpoints, -boundary_normal, boundary_normal, 
+                     mi.Bool(True), mi.Bool(False), is_epsilon_shell, UInt32(0), UInt32(0)) 
+        
+                
+    @dr.syntax
+    def get_touch_point(self, points, num_steps = 16, active_ = mi.Bool(True)):
+        with dr.suspend_grad():
+            active = Bool(active_)
+            touch_point = mi.Point2f(points)
+            d = mi.Float(dr.inf)
+            i = mi.UInt(0)
+            while (active & (i < num_steps)):
+                i+=1
+                d = mi.Float(self.get_closest_dist(touch_point))
+                active &= dr.abs(d) > dr.epsilon(mi.Float) * 10
+                normal = self.get_normal(touch_point)
+                touch_point = mi.Point2f(dr.select(active, touch_point - normal * mi.Point2f(d,d) * 0.99, touch_point))
+            return touch_point, d
+            
+    
+    def compute_curvature(self, points):
+        grad, hessian = self.get_grad_hessian(points)
+        norm_grad = dr.norm(grad)
+        grad_ = mi.Point2f(-grad[1], grad[0])
+        return -(grad_ @ hessian @ grad_) / (norm_grad * dr.sqr(norm_grad))
+    
+        
+    def get_boundary_indices(self, resolution): 
+        x_length = self.bbox[1][0] - self.bbox[0][0]
+        y_length = self.bbox[1][1] - self.bbox[0][1]
+        dx = x_length / resolution[0]
+        dy = y_length / resolution[1]
+        x, y = dr.meshgrid(dr.arange(mi.Float, resolution[0]), 
+                       dr.arange(mi.Float, resolution[1]), indexing='xy')
+        
+        film_points = mi.Point2f(x, y)
+        p = mi.Point2f(self.bbox[0][0], self.bbox[1][1]) +  film_points / mi.Point2f(resolution) *  mi.Point2f(x_length, -y_length)
+        p_x = p + mi.Point2f(dx, 0)
+        p_y = p + mi.Point2f(0, -dy)
+        p_xy = p + mi.Point2f(dx, -dy)
+        
+        p_pos = self.get_closest_dist(p) > 0
+        p_x_pos = self.get_closest_dist(p_x) > 0
+        p_y_pos = self.get_closest_dist(p_y) > 0
+        p_xy_pos = self.get_closest_dist(p_xy) > 0
+
+        non_boundary_mask = (p_pos & p_x_pos & p_y_pos & p_xy_pos) | (~p_pos & ~p_x_pos & ~p_y_pos & ~p_xy_pos)
+        boundary_mask =  ~non_boundary_mask 
+        boundary_mask_np = boundary_mask.numpy()
+        film_points_np = film_points.numpy().astype(np.int16).T
+        return mi.Point2f((film_points_np[boundary_mask_np].T).astype(np.float32))
+    
+    def create_boundary_points(self, distance: float, res: int, spp: int, discrete_points : bool = True, seed : int = 42):
+        with dr.suspend_grad():
+            resolution = [res, res]
+            film_points = self.get_boundary_indices(resolution)
+            film_points = dr.repeat(film_points, spp) + mi.Point2f(0.5, 0.5)
+            
+            if not discrete_points:
+                sampler = mi.load_dict({'type': 'independent'})
+                sampler.seed(seed, dr.width(film_points))
+                film_points_ = film_points + sampler.next_2d() - 1/2
+            else:
+                film_points_ = film_points
+    
+            
+            points_ = (mi.Point2f(self.bbox[0][0], self.bbox[1][1]) +  
+                      film_points_ / mi.Point2f(resolution) *  
+                      (mi.Point2f(self.bbox[1][0], self.bbox[0][1]) - mi.Point2f(self.bbox[0][0], self.bbox[1][1])))
+
+            boundary_points, d = self.get_touch_point(points_)
+            normal_dir = self.get_normal(boundary_points)
+            points = boundary_points + mi.Point2f(distance, distance) * normal_dir
+        return points, points_,  normal_dir
+
+    def create_boundary_result(self, result, points = None, res = 256):
+        if points is None:
+            raise Exception("Specify the points corresponding to the estimates in result.")
+        with dr.suspend_grad():
+            resolution = [res, res]
+            i2, i1 = get_position_bbox(points, self.bbox)
+            i2 = dr.minimum(mi.UInt(resolution[1] * i2), resolution[1] - 1)
+            i1 = dr.minimum(mi.UInt(resolution[0] * i1), resolution[0] - 1)
+
+            dim = 1 if result.ndim == 1 else result.shape[0]
+            tensor = dr.zeros(mi.TensorXf, shape = (dim, resolution[0], resolution[1]))
+            index = dr.zeros(mi.TensorXu, shape = (resolution[0], resolution[1]))
+            n = resolution[0] * resolution[1]
+            dr.scatter_add(index.array, mi.UInt(1), i1 * resolution[1] + i2)
+            #if dim == 1:
+            #    dr.scatter_add(tensor.array, i1 * resolution[1] + i2, result)
+            for i in range(dim):
+                dr.scatter_add(tensor.array, result[i], i * n  +  i1 * resolution[1] + i2)
+        
+        index = dr.select(index.array == 0, 1, index.array)
+        index = dr.reshape(mi.TensorXu, index, shape = (resolution[0], resolution[1]))
+        tensor /= index
+        return tensor.numpy(), tensor
+
+    def create_boundary_coefficient(self, tensor_mi, name = "boundary-val"):
+        coeffs = []
+        for i in range(tensor_mi.shape[0]):
+            coeffs.append(TextureCoefficient(name, self.bbox, tensor_mi[i].numpy().squeeze(), interpolation = "nearest"))
+        return coeffs
+    
+    def set_normal_derivative(self, tensor_mi, name = "normal-derivative"):
+        self.normal_derivatives = self.create_boundary_coefficient(tensor_mi, name = "normal-derivative")
+        return self.normal_derivatives
+    
+    def get_normal_derivative(self, points : Point2f):
+        #points_, _ = self.get_touch_point(points)
+        num_conf = len(self.normal_derivatives)
+        normal_ders = dr.zeros(ArrayXf, shape = [num_conf, dr.width(points)])
+        for i in range(num_conf):
+            normal_ders[i] = self.normal_derivatives[i].get_value(points)
+        return normal_ders
+    
+    def jakobian_to_boundary(self, bi : BoundaryInfo, distance = None, max_distance : mi.Float = dr.inf):
+        distance = self.normal_derivative_dist if distance is None else distance
+        distance = dr.minimum(distance, max_distance)
+        comp_points = dr.detach(bi.bpoint + bi.bn * distance)
+        distance = self.get_closest_dist(comp_points)
+        curvature = self.compute_curvature(dr.detach(bi.bpoint))
+        return 1 - distance * curvature
+    
+    def sketch_image(self, ax, bbox, resolution, image = None, channel = 1, color_factor = 0.6):
+        points = create_image_points(bbox, resolution, spp = 1, centered=True)
+        result = dr.select(self.get_closest_dist(points) < 0, 1.0, 0.0)
+        image_i, tensor = create_image_from_result(result=result, resolution = resolution)
+        
+        image = np.zeros([resolution[0], resolution[1], 3]) if image is None else image
+        image[:,:,channel] = image_i * 0.6
+        #image_b = self.get_boundary_image(bbox, resolution)
+        #image += image_b
+        ax.imshow(image * color_factor)
+        ax.set_axis_off()
+        return image
+    
+    def get_boundary_image(self, bbox, resolution, channel = 0):
+        indices = self.get_boundary_indices(bbox, resolution)
+        image = np.zeros([resolution[0], resolution[1], 3])
+        image[indices[:,1], indices[:,0], channel] += 1
+        #ax.imshow(image)
+        return image 
+    
+    def inside_closed_surface(self, points, L):
+        return self.get_closest_dist(points) < 0, L
+    
+    def inside_closed_surface_mask(self, points):
+        return self.get_closest_dist(points) < 0
+    
+    
+    def get_boundary_polyline(self, start = [0,0], step = 0.01):
+        points = []
+        point, d = self.get_touch_point(mi.Point2f(start))
+        points.append(point.numpy())
+        first = True
+        while True:
+            normal = self.get_normal(mi.Point2f(points[-1]))
+            tangent = mi.Point2f(normal[1], -normal[0])
+            if first:
+                tangent_first = mi.Point2f(tangent)
+            next_point = mi.Point2f(points[-1]) + tangent * step
+            next_point, d = self.get_touch_point(next_point)
+            if (not first) and (dr.norm(next_point - point)[0] < 1.1 * step) and dr.dot(dr.normalize(next_point - point), tangent_first)[0] < 0.1:
+                break
+            else:
+                points.append(next_point.numpy())
+            first = False
+        points = np.array(points).squeeze()
+        self.polyline = mi.Point2f(points.T)
+        return points
+        
+    def sketch_boundary_polyline(self, ax, bbox, resolution, esize = 0.2):
+        points = self.polyline.numpy().T
+        sketch_points = []
+        xscale = bbox[1][0] - bbox[0][0]
+        yscale = bbox[1][1] - bbox[0][1]
+        pointsx = (points[:, 0]-bbox[0][0])/xscale*resolution[1]
+        pointsy = resolution[0] - (points[:, 1]-bbox[0][1])/yscale*resolution[0]
+        pointsx = np.append(pointsx, pointsx[0])
+        pointsy = np.append(pointsy, pointsy[0])
+        sketch_points = np.vstack([pointsx, pointsy])
+        ax.plot(sketch_points[0,:], sketch_points[1,:], zorder = 0)
+        ax.scatter(sketch_points[0,0], sketch_points[1,0], color = "red", zorder = 1, s = 0.1)
+        return np.array(sketch_points).T
+
+    
+    def vis_images(self, bbox, resolution = [1024, 1024], spp = 16):
+        points = create_image_points(bbox, resolution = resolution, spp = spp, centered = False)
+        d = self.get_closest_dist(points)
+        crossing = dr.select(d<0, 1.0, 0.0)
+        grad = self.get_grad(points)
+        norm_grad = dr.norm(grad)
+        
+        d_im, _ = create_image_from_result(d, resolution)
+        crossing_im, _ = create_image_from_result(crossing, resolution)
+        gradx_im, _ = create_image_from_result(grad[0], resolution)
+        grady_im, _ = create_image_from_result(grad[1], resolution)
+        normgrad_im, _ = create_image_from_result(norm_grad, resolution)
+        return d_im[0], crossing_im[0], gradx_im[0], grady_im[0], normgrad_im[0]
+    
+    
+        

data/PDE2D/BoundaryShape/sdf_utils.py

@@ -0,0 +1,322 @@
+import numpy as np
+import drjit as dr
+import mitsuba as mi
+import matplotlib.pyplot as plt
+from ..Coefficient import TextureCoefficient
+from PDE2D.utils.sketch import *
+from PDE2D.Solver import *
+from .boundary_shape import *
+import skfmm
+from .sdf_grid import *
+import matplotlib.gridspec as gridspec
+import matplotlib.ticker as ticker
+from PDE2D.utils.common import *
+
+def disable_ticks(ax):
+    """Disable ticks around plot (useful for displaying images)"""
+    ax.axes.get_xaxis().set_ticklabels([])
+    ax.axes.get_yaxis().set_ticklabels([])
+    ax.axes.get_xaxis().set_ticks([])
+    ax.axes.get_yaxis().set_ticks([])
+
+
+def disable_border(ax):
+    """Disable border around plot"""
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    ax.spines['bottom'].set_visible(False)
+    ax.spines['left'].set_visible(False)
+
+def get_image_shape(image_name, image_center, image_length_x, sdf_res, sdf_center, sdf_length, square = False, high_res = 2048):
+    image = plt.imread(image_name)
+    image = image[...,:3].sum(axis = 2)/3
+    ratio = image.shape[0] / image.shape[1]
+    image_length_y = image_length_x if square else image_length_x * ratio
+    image[image > 0.5] = 1
+    image[image<0.5] = -1
+    image_bbox = [[image_center[0] - image_length_x/2, image_center[1] - image_length_y/2],
+                  [image_center[0] + image_length_x/2, image_center[1] + image_length_y/2]]
+    bbox = [[sdf_center[0] - sdf_length/2, sdf_center[1] - sdf_length/2],
+            [sdf_center[0] + sdf_length/2, sdf_center[1] + sdf_length/2]]
+    tex = TextureCoefficient("a", image_bbox, image)
+    res_high = [high_res, high_res]
+    upsample = int(high_res / sdf_res)
+    points = create_image_points(bbox = bbox, resolution = res_high, 
+                                              spp = 1, centered = True)
+    vals = tex.get_value(points)
+    image, _= create_image_from_result(vals, resolution = res_high)
+    image = skfmm.distance(image, dx = sdf_length/high_res)
+    image = image[int(upsample/2-1)::upsample, int(upsample/2-1)::upsample]
+    return SDFGrid(image, box_length = sdf_length, box_center = sdf_center, redistance = False)
+
+
+def get_intersection_tensor(shape1 : Shape, shape2 : Shape, resolution, bbox):
+    points = create_image_points(bbox, resolution, spp = 1, centered = True)
+    vals1 = shape1.get_closest_dist(points)
+    vals2 = shape2.get_closest_dist(points)
+    new = dr.maximum(vals1, vals2)
+    image, _ = create_image_from_result(new, resolution)
+    return image
+
+def visualize1(bbox, resolution, sdf1, sdf2, bpoints = None, name1 = "Old", name2 = "Optimized", res_angle = 32, max = None):
+    d1, c1, gx1, gy1, ng1 = sdf1.vis_images(bbox = bbox, resolution = resolution)
+    d2, c2, gx2, gy2, ng2 = sdf2.vis_images(bbox = bbox, resolution = resolution)
+    fig, ax = plt.subplots(4, 3, figsize = (13, 16))
+    ax[0][0].set_title(name1)
+    ax[0][1].set_title(name2)
+    ax[0][2].set_title("Difference")
+    
+    
+    # distance
+    ax[0][0].set_ylabel("Distance")
+    d_range = get_common_range(d1, d2)
+    plot_image(d1, ax[0][0], input_range = d_range)
+    plot_image(d2, ax[0][1], input_range = d_range) 
+    plot_image(np.abs(d1 - d2), ax[0][2], input_range = [None, max])
+    
+
+    # grad_norm
+    ax[1][0].set_ylabel("|Grad|")
+    ng_range = get_common_range(ng1, ng2)
+    plot_image(ng1, ax[1][0], input_range = ng_range)
+    plot_image(ng2, ax[1][1], input_range = ng_range) 
+    plot_image(ng1 - ng2, ax[1][2])
+    
+    # modified grad_norm
+    ax[2][0].set_ylabel("||grad|-1|")
+    ng1_modified = ng1.copy()
+    ng2_modified = ng2.copy()
+    #ng1_modified[d1 < -0.1] = np.nan
+    #ng2_modified[d2 < -0.1] = np.nan
+    ng1_modified = np.abs(ng1_modified - 1)
+    ng2_modified = np.abs(ng2_modified - 1) 
+    ng_modified_range = get_common_range(ng1_modified, ng2_modified)
+    plot_image(ng1_modified, ax[2][0], input_range = ng_modified_range)
+    plot_image(ng2_modified, ax[2][1], input_range = ng_modified_range) 
+    plot_image(ng1_modified - ng2_modified, ax[2][2])
+    
+
+    # grad direction
+    ax[3][2].set_axis_off()
+    ax[3,0].set_ylabel("Direction Grad")
+    
+    gx1_tex = TextureCoefficient("gx1", bbox, gx1, "nearest")
+    gx2_tex = TextureCoefficient("gx2", bbox, gx2, "nearest")
+    gy1_tex = TextureCoefficient("gy1", bbox, gy1, "nearest")
+    gy2_tex = TextureCoefficient("gy2", bbox, gy2, "nearest")
+    
+    plot_image(c1, ax[3][0])
+    plot_image(c2, ax[3][1])
+    
+    xlength = bbox[1][0] - bbox[0][0]
+    ylength = bbox[1][1] - bbox[0][1]
+    scale = mi.Point2f(xlength/res_angle, ylength/res_angle)
+    
+    points = create_image_points(bbox, resolution = [res_angle, res_angle], spp = 1, centered = True)
+    
+    dx1 = dr.normalize(mi.Point2f(gx1_tex.get_value(points), gy1_tex.get_value(points))) * scale * 0.48
+    dx2 = dr.normalize(mi.Point2f(gx2_tex.get_value(points), gy2_tex.get_value(points))) * scale * 0.48
+    
+    points_sketch = point2sketch(points, bbox, resolution = resolution).numpy().T
+    dir1_sketch = dir2sketch(dx1, bbox, resolution = resolution).numpy().T
+    dir2_sketch = dir2sketch(dx2, bbox, resolution = resolution).numpy().T
+
+
+    
+    for point, dir1, dir2 in zip(points_sketch, dir1_sketch, dir2_sketch):
+        ax[3][0].arrow(point[0], point[1], dir1[0], dir1[1])
+        ax[3][1].arrow(point[0], point[1], dir2[0], dir2[1])
+    
+    if bpoints is not None:
+        bpoints_sketch = point2sketch(bpoints, bbox, resolution).numpy()
+        for aa in ax:
+            for a in aa:
+                a.scatter(bpoints_sketch[0] - 0.5, bpoints_sketch[1] - 0.5, s = 0.4, color  ="white")
+
+
+def plot_shape_sdf(out_boundary, in_boundary, ax, bbox, resolution, linewidth = 3, e_size = 5):
+    image = in_boundary.sketch_image(ax, bbox = bbox, resolution = resolution, channel = 2)
+    black_region = image.sum(axis = 2) < 0.1
+    image[black_region]  = 1
+    ax.imshow(image)
+    ax.axis("on")
+    out_boundary.sketch(ax, bbox = bbox, resolution = resolution, lw = linewidth, e_size = e_size)
+
+def visualize2(wos, bbox, curvature_distance = 0.0, 
+               resolution = [1024, 1024], num_points = 10, step = 0.03, spp = 18,
+               distances = None, color_points = "green", colors = None, lw = 1, e_size = 2, image_width = 3.36):
+
+    fig = plt.figure(figsize= (image_width, image_width))
+    pad1 = 3
+    pad2 = 3
+    s = 3
+    imsize=  20
+    g = gridspec.GridSpec(2 * imsize + pad2 + s, 2 * imsize + pad1 + s, figure = fig, wspace = 0, hspace=0)
+    ax = fig.add_subplot(g[:,:])
+    disable_ticks(ax)
+    plt.setp(ax.spines.values(), color="white")
+    ax1 = fig.add_subplot(g[pad1 : pad1 + imsize, pad2 : pad2 + imsize])
+    ax2 = fig.add_subplot(g[pad1 : pad1 + imsize, pad2 + imsize + s :  pad2 + 2 * imsize + s])
+    ax3 = fig.add_subplot(g[pad1 + s + imsize : pad1 + 2 * imsize + s, pad2 : pad2 + imsize])
+    ax4 = fig.add_subplot(g[pad1 + imsize + s : pad1 + 2 * imsize + s, pad2 + imsize + s :  pad2 + 2 * imsize + s])
+    #fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,2,figsize = (8,8))
+    plot_shape_sdf(wos.input.shape.out_boundary, wos.input.shape.in_boundaries[0], ax1, bbox, resolution, linewidth=lw, e_size=e_size)
+    points_polyline = wos.input.shape.in_boundaries[0].get_boundary_polyline(step = step)
+    sketch_points = wos.input.shape.in_boundaries[0].sketch_boundary_polyline(ax1, bbox, resolution, esize = e_size)
+    sketch_points_plot = sketch_points[::num_points]
+    disable_border(ax1)
+    disable_ticks(ax1)
+
+    indices = np.arange(dr.width(wos.input.shape.in_boundaries[0].polyline))
+    normal = wos.input.shape.in_boundaries[0].get_normal(wos.input.shape.in_boundaries[0].polyline)
+    points_curvature = wos.input.shape.in_boundaries[0].polyline  + curvature_distance * normal
+    curvature = wos.input.shape.in_boundaries[0].compute_curvature(points_curvature).numpy()
+    ax2.plot(indices, curvature, label = f"Curvature")
+
+    spp = 2 ** spp
+    distances = [1e-2, 5e-2, 1e-1] if distances is None else distances
+    colors = ["cyan", "green", "blue"] if colors is None else colors
+    points_normalders = []
+    range_all = [np.nan, -np.nan]
+    for distance, color in zip(distances, colors):
+        print(f"distance = {distance}")
+        normal = wos.input.shape.in_boundaries[0].get_normal(wos.input.shape.in_boundaries[0].polyline)
+        points_normal_der = wos.input.shape.in_boundaries[0].polyline  + distance * normal
+        points_normalders.append(points_normal_der)
+        points_polyline = dr.repeat(points_normal_der, spp)
+        normals = dr.repeat(normal, spp)
+        L, _ = wos.solve(conf_numbers = [mi.UInt32(0)], points_in = points_polyline, derivative_dir = normals)
+        result = dr.block_sum(L, spp) / spp
+        result = result.numpy()
+        
+        result_corrected = result * (1 - distance * curvature)
+
+        range_ = get_common_range(result_corrected, result)
+        range_all = get_common_range(np.array(range_all), range_)
+        
+        ax3.plot(indices, result[0], label = f"t = {distance}", color = color, linewidth = 1)
+        ax4.plot(indices, result_corrected[0], label = f"t = {distance}", color = color, linewidth = 1)
+        
+    range_all[0] -= 1
+    range_all[1] += 1
+    ax3.set_ylim(range_all)
+    ax4.set_ylim(range_all)
+
+    #ax2.legend()
+    ax3.legend(framealpha = 1)
+    ax4.legend(framealpha = 1)
+
+    ax2.axhline(0, lw = 0.5, color = "black")
+    ax3.axhline(0, lw = 0.5, color = "black")
+    ax4.axhline(0, lw = 0.5, color = "black")
+    
+    ax2.axvline(0, lw = 0.5, color = "red")
+    ax3.axvline(0, lw = 0.5, color = "red")
+    ax4.axvline(0, lw = 0.5, color = "red")
+    ax2.set_xticks([])
+    ax3.set_xticks([])
+    ax4.set_xticks([])
+    
+    ax2.set_xlim([-1, sketch_points.shape[0]])
+    ax3.set_xlim([-1, sketch_points.shape[0]])
+    ax4.set_xlim([-1, sketch_points.shape[0]])
+
+    for i in range(num_points, sketch_points.shape[0], num_points):
+        ax2.axvline(i, lw = 0.5, color = color_points)
+        ax3.axvline(i, lw = 0.5, color = color_points)
+        ax4.axvline(i, lw = 0.5, color = color_points)
+    pad = 4
+    ax1.set_title("(a) Shape", pad = pad, fontsize = DEFAULT_FONTSIZE_SMALL)
+    ax3.set_title("(c) Normal derivatives", pad = pad, fontsize = DEFAULT_FONTSIZE_SMALL)
+    ax2.set_title(f"(b) Curvatures", pad = pad, fontsize = DEFAULT_FONTSIZE_SMALL)
+    ax4.set_title("(d) Corrected normal deriv.", pad = pad, fontsize = DEFAULT_FONTSIZE_SMALL)
+
+    ax1.scatter(sketch_points_plot[0,0], sketch_points_plot[0,1], color = "red", zorder = 1, s = e_size)
+    ax1.scatter(sketch_points_plot[1:,0], sketch_points_plot[1:,1], color = color_points, zorder = 1, s = e_size)
+
+    #fig.tight_layout()
+    
+def visualize_grad(sdf, bbox, resolution, bpoints = None, res_angle = 32, range_d =None, range = 1e-2, norm =True, cmap = "coolwarm", col_width_image = 3.36):
+    xlength = bbox[1][0] - bbox[0][0]
+    ylength = bbox[1][1] - bbox[0][1]
+    d, c, gx, gy, ng = sdf.vis_images(bbox = bbox, resolution = resolution)
+    imsize = 250
+    num_images = 3
+    cbar_offset = 15
+    pre_cbar_offset = 10
+    post_cbar_offset = 60
+    total_cbar_offset = cbar_offset + pre_cbar_offset + post_cbar_offset
+    scale = col_width_image / (num_images * imsize + 2 * total_cbar_offset)
+    cbar_b = 1
+    fig = plt.figure(figsize = ((num_images * imsize + 2 * total_cbar_offset) * scale, imsize * scale))
+    g = gridspec.GridSpec(imsize, imsize * num_images + total_cbar_offset * 2, wspace = 0.0, hspace=0.0)
+    ax = fig.add_subplot(g[:,:])
+    disable_ticks(ax)
+    plt.setp(ax.spines.values(), color="white")
+    ax1 = fig.add_subplot(g[:, :imsize])
+    ax2 = fig.add_subplot(g[:, imsize + total_cbar_offset :2 * imsize + total_cbar_offset])
+    ax3 = fig.add_subplot(g[:, 2 * imsize + 2 * total_cbar_offset :3 * imsize + 2 * total_cbar_offset])
+
+    ax1_cbar = fig.add_subplot(g[cbar_b: -cbar_b, imsize + pre_cbar_offset : imsize + pre_cbar_offset + cbar_offset])
+    ax2_cbar = fig.add_subplot(g[cbar_b: -cbar_b, 2 * imsize + total_cbar_offset + pre_cbar_offset : 2*imsize+ total_cbar_offset+ cbar_offset + pre_cbar_offset])
+    
+    if range_d is not None:
+        im1 = plot_image(d, ax1, input_range = [-range_d, range_d], colorbar= False, cmap = cmap)
+    else:
+        im1 = plot_image(d, ax1, colorbar = False, cmap = cmap)
+    if norm:
+        im2 = plot_image(ng, ax2, input_range = [1-range, 1+range], cmap = cmap, colorbar = False)
+    else:    
+        im2 = plot_image(np.abs(ng-1), ax2, input_range = [0, range], colorbar = False)
+
+    cbar1 = plt.colorbar(im1, cax = ax1_cbar)
+    tick_locator = ticker.MaxNLocator(nbins=3)
+    cbar1.locator = tick_locator
+    cbar1.formatter.set_powerlimits((0, 0))
+    cbar1.ax.yaxis.set_offset_position('left') 
+    cbar1.update_ticks()
+    cbar2 = plt.colorbar(im2, cax = ax2_cbar)
+    tick_locator = ticker.MaxNLocator(nbins=3)
+    cbar2.locator = tick_locator
+    cbar2.formatter.set_powerlimits((0, 0))
+    cbar2.ax.yaxis.set_offset_position('right') 
+    cbar2.update_ticks()
+    #if bpoints is not None:
+    #    mask = (bpoints[0] > bbox[0][0]) &  (bpoints[0] < bbox[1][0]) & (bpoints[1] > bbox[0][1]) & (bpoints[1] < bbox[1][1])
+    #    mask = mask.numpy().squeeze()
+    #    if len(mask) > 0:
+    #        bpoints_np = bpoints.numpy().squeeze()
+    #        bpoints_ = mi.Point2f(bpoints_np[mask])
+    #        bpoints_sketch = point2sketch(bpoints_, bbox, resolution).numpy()
+    #        ax2.scatter(bpoints_sketch[:,0], bpoints_sketch[:,1], s = ps, color = "green")
+    #        ax1.scatter(bpoints_sketch[:,0], bpoints_sketch[:,1], s = ps, color = "white")
+
+    x = (np.arange(resolution[0]) + 0.5) / 1024 * d.shape[0]
+    y = (np.arange(resolution[1]) + 0.5) / 1024 * d.shape[0]
+    X, Y = np.meshgrid(x, y)
+    # Creating contour plot
+    ax1.contour(X, Y, d, colors = ["white"], lw = 5, levels = np.array([0]))
+    ax2.contour(X, Y, d, colors = ["white"], lw = 5, levels = np.array([0]))
+
+    gx_tex = TextureCoefficient("gx", bbox, gx, "nearest")
+    gy_tex = TextureCoefficient("gy", bbox, gy, "nearest")
+    plot_image(-2 * c+1, ax3, colorbar = False, cmap = "coolwarm", input_range = [-2, 2])
+    scale = mi.Point2f(xlength/res_angle, ylength/res_angle)
+    points = create_image_points(bbox, resolution = [res_angle, res_angle], spp = 1, centered = True)
+    dx = dr.normalize(mi.Point2f(gx_tex.get_value(points), gy_tex.get_value(points))) * scale * 0.48
+    
+    points_sketch = point2sketch(points, bbox, resolution = resolution).numpy().T
+    dir_sketch = dir2sketch(dx, bbox, resolution = resolution).numpy().T
+
+    for point, dir, in zip(points_sketch, dir_sketch):
+        ax3.arrow(point[0], point[1], dir[0], dir[1])
+    pad = 4
+    ax1.set_title("$d(x)$", fontsize = DEFAULT_FONTSIZE_SMALL, pad = pad)
+    if norm:
+        ax2.set_title("$||\\nabla d(x)||$", fontsize = DEFAULT_FONTSIZE_SMALL, pad = pad)
+    else:
+        ax2.set_title("$||\\nabla d(x)|| - 1|$", fontsize = DEFAULT_FONTSIZE_SMALL, pad = pad)
+    ax3.set_title("Direction", fontsize = DEFAULT_FONTSIZE_SMALL, pad = pad)
+    #fig.tight_layout()
+
+        

data/PDE2D/BoundaryShape/shape_utils.py

@@ -0,0 +1,248 @@
+from .bezierquadratic import *
+from PDE2D.Coefficient import *
+
+def load_bunny(scale = 1, dirichlet  = None, neumann = None, all_dirichlet = False, epsilon = 1e-5, conf : int = 1):
+    points = np.array([[ 36.0,  -28.6],
+                    [ 49.9,  -25.2],
+                    [ 66.6,  -38.7],
+                    [ 67.2,  -47.3],
+                    [ 71.2,  -52.8],
+                    [ 65.1,  -55.7],
+                    [ 61.7,  -56.0],
+                    [ 40.7,  -57.0],
+                    [ 14.2,  -56.8],
+                    [ 12.0,  -54.3],
+                    [ 14.3,  -50.4],
+                    [ 13.6,  -44.4],
+                    [ 12.9,  -41.0],
+                    [ 11.0,  -40.0],
+                    [  9.0,  -38.9],
+                    [  8.2,  -29.0],
+                    [ 18.3,  -20.9],
+                    [ 25.5,  -9.2],
+                    [ 32.7,  -5.2],
+                    [ 33.5, -13.0],
+                    [ 29.9, -20.5],
+                    [ 31.1, -27.6]]) / 38 + np.array([-1 ,0.9])
+
+    normals = np.array([[ -3.3,  9.3],
+                    [  0.4,  10.0],
+                    [  7.5, -0.0],
+                    [  1.5,  4.6],
+                    [  5.8, -1.4],
+                    [ -1.6, -6.1],
+                    [  1.8, -6.2],
+                    [  0.0, -6.2],
+                    [ -0.8, -5.0],
+                    [ -4.1,  3.9],
+                    [ -7.3,  0.5],
+                    [ -7.3, -0.8],
+                    [ -2.0,  -1.0],
+                    [ -0.4,  -3.0],
+                    [ -3.1, -4.5],
+                    [ -7.3,  5.0],
+                    [ -3.2,  8.1],
+                    [ -8.3,  1.9],
+                    [  0.2,  1.0],
+                    [  7.9, -3.8],
+                    [  7.9, -2.8],
+                    [  4.7,  5.1]])
+    
+    if conf == 1:
+        dirichlet_map = np.array([False, 
+                                False, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                False, 
+                                False,
+                                True,
+                                True,
+                                True])
+
+    elif conf == 2:
+        dirichlet_map = np.array([True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                False, 
+                                False,
+                                False,
+                                True,
+                                True])
+    elif conf == 3:
+        dirichlet_map = np.array([True, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                False, 
+                                False,
+                                True,
+                                True,
+                                True]) 
+    elif conf == 4:
+        dirichlet_map = np.array([False, 
+                                False, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                False, 
+                                False,
+                                False,
+                                True,
+                                True])
+    
+    elif conf == 5:
+        dirichlet_map = np.array([False, 
+                                False, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                False, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                True, 
+                                False, 
+                                True, 
+                                True, 
+                                True, 
+                                False,
+                                False,
+                                True,
+                                True])
+
+    
+    
+    if all_dirichlet:
+        dirichlet_map = np.ones_like(dirichlet_map, dtype=np.bool_)
+    points = Point2f(points.T)
+    normals = dr.normalize(Point2f(normals.T))
+    return QuadraticBezierShape(points.numpy(), normals.numpy(), dirichlet = dirichlet, 
+                                neumann = neumann, epsilon = epsilon,
+                                dirichlet_map = dirichlet_map, n_segment = 20, newton_steps = 5)
+
+def load_boundary_data(only_dirichlet = False, constant = False, zero = False):
+    dirichlet_coeffs = []
+    neumann_coeffs = []
+
+    if zero:
+        return [ConstantCoefficient("coeff", 0)], [ConstantCoefficient("coeff", 0)]
+
+
+    if only_dirichlet:
+        constant_values = [0, 2, -2]
+        for c in constant_values:
+            dirichlet_coeffs.append(ConstantCoefficient("coeff", c))
+    else:
+        constant_values = [0, 2, 20, -2, -20]
+        for c1 in constant_values:
+            for c2 in constant_values:
+                dirichlet_coeffs.append(ConstantCoefficient("coeff", c1))
+                neumann_coeffs.append(ConstantCoefficient("coeff", c2))
+
+    if constant:
+        return dirichlet_coeffs, neumann_coeffs
+
+
+    def ramp(points, parameters):
+        direction = dr.normalize(parameters["direction"])
+        z = dr.dot(points, direction)
+        return z * parameters["ramp"] + parameters["bias"]
+    
+    def freq(points, parameters):
+        direction = dr.normalize(parameters["direction"])
+        z = dr.dot(points, direction)
+        return parameters["power"] * dr.cos(2 * dr.pi * parameters["freq"] * z) + parameters["bias"]
+
+    directions = [[0., 1.], [1, 0], [1., 1]]
+    ramp_values = [1, 3, 10]
+    for direction in directions:
+        for ramp_v in ramp_values:
+            for bias in [-ramp_v, 0, ramp_v]:
+                p_ramp = {}  
+                dir = Point2f(direction)
+                dr.make_opaque(dir)
+                p_ramp["direction"] = dir
+                p_ramp["ramp"] = dr.opaque(Float, ramp_v, shape = (1))
+                p_ramp["bias"] = dr.opaque(Float, bias, shape = (1))
+                dirichlet_coeffs.append(FunctionCoefficient("coeff", dict(p_ramp), ramp))
+                if not only_dirichlet:
+                    neumann_coeffs.append(FunctionCoefficient("coeff", dict(p_ramp), ramp))
+
+
+    freqs = [2, 4, 8]
+    powers = [1, 10]
+    for direction in directions:
+        for f in freqs:
+            for power in powers:
+                for bias in [-power, 0, power]:
+                    p_freq = {}  
+                    dir = Point2f(direction)
+                    dr.make_opaque(dir)
+                    p_freq["direction"] = dir
+                    p_freq["power"] = dr.opaque(Float, power, shape = (1))
+                    p_freq["freq"] = dr.opaque(Float, f, shape = (1))
+                    p_freq["bias"] = dr.opaque(Float, bias, shape = (1))
+                    dirichlet_coeffs.append(FunctionCoefficient("coeff", dict(p_freq), freq))
+                    if not only_dirichlet:
+                        neumann_coeffs.append(FunctionCoefficient("coeff", dict(p_freq), freq))
+
+    if len(neumann_coeffs) == 0:
+        neumann_coeffs.append(ConstantCoefficient("coeff", 0))
+
+    return dirichlet_coeffs, neumann_coeffs

data/PDE2D/Coefficient/__init__.py

@@ -0,0 +1,7 @@
+from .coefficient import *
+from .constant import ConstantCoefficient
+from .texture import TextureCoefficient
+from .function import FunctionCoefficient
+from .gaussian import GaussianMixtureCoefficient
+from .disk_texture import DiskTextureCoefficient
+from .coefficient_utils import *

data/PDE2D/Coefficient/coefficient.py

@@ -0,0 +1,41 @@
+import numpy as np
+import drjit as dr
+import mitsuba as mi
+from ..utils.sketch import plot_function
+
+class Coefficient(object):
+    def __init__(self, name):
+        self.name = name
+        self.type = ""
+        self.is_zero = False
+        self.constant_thickness = 0
+    
+    def get_value(self, points):
+        pass
+    def get_grad_laplacian(self, points):
+        pass
+    def get_opt_params(self, param_dict : dict, opt_params : list["str"]):
+        pass
+    def update(self, optimizer):
+        pass
+    def zero_grad(self):
+        pass
+    
+    def copy(self):
+        pass
+    
+    def visualize(self, ax, bbox, resolution = [1024, 1024], spp = 4, colorbar = True, input_range = [None, None], cmap = "viridis"):
+        return plot_function(ax, self.get_value, bbox, resolution, spp, colorbar, input_range, cmap)
+        
+    def visualize_grad(self):
+        pass
+
+    def upsample2(self):
+        pass
+        
+
+    
+
+                
+                
+

data/PDE2D/Coefficient/coefficient_utils.py

@@ -0,0 +1,52 @@
+from matplotlib.patches import Polygon
+import numpy as np
+
+def build_grid_squares(points_per_edge, resolution, bbox, ax=None):
+    xscale = bbox[1][0] - bbox[0][0]
+    yscale = bbox[1][1] - bbox[0][1]
+    binx = xscale / resolution[0]
+    biny = yscale / resolution[1]
+    stepx = binx / points_per_edge
+    stepy = biny / points_per_edge
+    points = np.zeros([0, 2])
+    for i in range(resolution[0]):
+        for j in range(resolution[1]):
+            vec = np.zeros([4 * points_per_edge + 1, 2])
+            vec[0:points_per_edge, 0] = np.arange(
+                i * binx, (i+1) * binx, stepx)[0:points_per_edge]
+            vec[0:points_per_edge, 1] = -j * biny
+            vec[points_per_edge: 2 * points_per_edge, 0] = (i+1) * binx
+            vec[points_per_edge: 2 * points_per_edge,
+                1] = np.arange(-j * biny, -(j+1) * biny, -stepy)[0:points_per_edge]
+            vec[2 * points_per_edge: 3 * points_per_edge,
+                0] = np.arange((i+1) * binx, i * binx, -stepx)[0:points_per_edge]
+            vec[2 * points_per_edge: 3 * points_per_edge, 1] = - (j + 1) * biny
+            vec[3 * points_per_edge: 4 * points_per_edge, 0] = i * binx
+            vec[3 * points_per_edge: 4 * points_per_edge,
+                1] = np.arange(-(j+1) * biny, -j * biny, stepy)[0:points_per_edge]
+            vec[-1] = vec[0]
+            vec += np.array([bbox[0][0], bbox[1][1]])
+            points = np.vstack([points, vec])
+            if (ax is not None):
+                color = 'red' if (i+j) % 2 == 1 else "blue"
+                polygon = Polygon(vec, edgecolor=None, facecolor=color)
+                ax.add_patch(polygon)
+    return points.T
+
+def sketch_grid_squares(points, points_per_edge, resolution,  ax):
+    num_points = points.shape[0] // (4 * points_per_edge + 1)
+    for i in range(num_points):
+        p = points[i * (4 * points_per_edge + 1): (i+1)
+                   * (4 * points_per_edge + 1)]
+        color = 'red' if (
+            ((i // resolution[0]) + (i % resolution[1])) % 2 == 0) else "blue"
+        polygon = Polygon(p, edgecolor=None, facecolor=color)
+        ax.add_patch(polygon)
+    disable_ticks(ax)
+
+def disable_ticks(ax):
+    """Disable ticks around plot (useful for displaying images)"""
+    ax.axes.get_xaxis().set_ticklabels([])
+    ax.axes.get_yaxis().set_ticklabels([])
+    ax.axes.get_xaxis().set_ticks([])
+    ax.axes.get_yaxis().set_ticks([])

data/PDE2D/Coefficient/concentric_disk_map.py

@@ -0,0 +1,39 @@
+import drjit as dr
+import mitsuba as mi
+# Peter Shirley and Kenneth Chiu in 1997 derived an area preserving map between square to disc.
+
+@dr.syntax
+def square_to_disk(point : mi.Point2f):
+    if dr.abs(point[0]) > dr.abs(point[1]):
+        u = point[0] * dr.cos(dr.pi/4 * point[1] / point[0])
+        v = point[0] * dr.sin(dr.pi/4 * point[1] / point[0])
+    else:
+        u = point[1] * dr.sin(dr.pi/4 * point[0] / point[1])
+        v = point[1] * dr.cos(dr.pi/4 * point[0] / point[1])
+    return mi.Point2f(u, v)
+
+@dr.syntax
+def disk_to_square(point : mi.Point2f):
+    r = dr.norm(point)
+    if dr.abs(point[0]) >= dr.abs(point[1]):
+        p =  r * mi.Point2f(dr.sign(point[0]), 4 / dr.pi * dr.atan2(point[1], dr.abs(point[0])))
+    else:
+        p = r * mi.Point2f(4 / dr.pi * dr.atan2(point[0], (dr.abs(point[1]) + dr.epsilon(mi.Float))), dr.sign(point[1]))
+    return p
+
+@dr.syntax
+def jakobian(point: mi.Point2f):
+    
+    if dr.abs(point[0]) > dr.abs(point[1]):
+        A = dr.pi * point[1] / (4 * point[0])
+        cos_A = dr.cos(A)
+        sin_A = dr.sin(A)
+        mat = mi.Matrix2f(cos_A + A * sin_A, -dr.pi/4 * sin_A,
+                        sin_A - A * cos_A, dr.pi/4 * cos_A)
+    else:
+        B = dr.pi * point[0] / (4 * point[1]) 
+        cos_B = dr.cos(dr.pi / 4 + B)
+        sin_B = dr.sin(dr.pi / 4 + B)
+        mat = mi.Matrix2f(dr.pi/4 * cos_B, sin_B - B * cos_B,
+                       -dr.pi/4 * sin_B, cos_B + B * sin_B)
+    return mat

data/PDE2D/Coefficient/constant.py

@@ -0,0 +1,51 @@
+from .coefficient import *
+
+class ConstantCoefficient(Coefficient):
+    DRJIT_STRUCT = { 
+        'value' : mi.Float
+        }
+    
+    def __init__(self, name: str, value: float = 0):
+        self.is_zero = (value == 0)
+        self.value = mi.Float(value)
+        self.name = name
+        self.type = "constant"
+        self.constant_thickness = dr.inf
+        dr.make_opaque(self.value)
+
+    def get_value(self, points : mi.Point2f):
+        return self.value
+
+    def get_grad_laplacian(self, points: mi.Point2f): # type: ignore
+        return dr.zeros(mi.Point2f, dr.width(points)), dr.zeros(mi.Float, dr.width(points)) 
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        for key in opt_params:
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if name == self.name and type == self.type:
+                if param == "value":
+                    param_dict[key] = self.value
+                else:
+                    raise Exception(
+                        f"ConstantCoefficient ({self.name}) does not have a parameter called \"{param}\"")
+
+    def update(self, optimizer):
+        for key in optimizer.keys():
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if (name == self.name) & (type == self.type) & (param == "value"):
+                self.value = optimizer[key]
+
+    def zero_grad(self):
+        if dr.grad_enabled(self.value):
+            dr.set_grad(self.value, 0.0)
+
+    def copy(self):
+        new = ConstantCoefficient(self.name, self.value)
+        new.zero_grad()
+        return new

data/PDE2D/Coefficient/disk_texture.py

@@ -0,0 +1,132 @@
+from .coefficient import *
+from .elliptic_disk_map import *
+from PDE2D.utils.helpers import get_position_bbox
+from mitsuba import TensorXf
+
+class DiskTextureCoefficient(Coefficient):
+    def __init__(self, name: str, tensor_np: np.array,
+                 origin : list = [0, 0], radius : float = 1, constant_thickness = 0.1,
+                 out_val = 1, interpolation: str = "cubic"):
+        self.is_zero = False
+        self.interpolation = interpolation
+        self.tensor = TensorXf(tensor_np.squeeze()[..., np.newaxis])
+        self.name = name
+        self.type = "disktexture"
+        self.origin = mi.Point2f(origin)
+        self.radius = mi.Float(radius)
+        self.constant_thickness = constant_thickness
+        self.inner_radius = self.radius - self.constant_thickness
+        self.bbox = [[origin[0] - self.inner_radius, origin[1] - self.inner_radius], 
+                     [origin[0] + self.inner_radius, origin[1] + self.inner_radius]]
+        self.out_val = mi.Float(out_val)
+        dr.make_opaque(self.out_val)
+        dr.make_opaque(self.tensor)
+        self.update_texture()
+        
+    def create_tensor(self, tensor : TensorXf, expand = 2):
+        # Creating the texture!
+        nx = tensor.shape[0] + 2 * expand
+        ny = tensor.shape[1] + 2 * expand
+        nz = tensor.shape[2]
+        new_tensor = TensorXf(dr.repeat(self.out_val, nx * ny * nz))
+        new_tensor = dr.reshape(TensorXf, new_tensor, shape = (nx, ny, nz))
+        # Get middle indices to scatter
+        i = dr.arange(mi.UInt32, expand, nx - expand)
+        j = dr.arange(mi.UInt32, expand, ny - expand)
+        ii, jj = dr.meshgrid(i, j)
+        indices = (jj - expand) * tensor.shape[1] + (ii - expand)
+        indices2 = jj * ny + ii
+
+        scatter_vals = dr.gather(mi.Float, tensor.array, mi.UInt32(indices))
+        dr.scatter(new_tensor.array, scatter_vals, mi.UInt32(indices2))
+        return new_tensor
+
+    def update_texture(self):
+        self.tensor2 = self.create_tensor(self.tensor)
+        self.texture = mi.Texture2f(self.tensor2, use_accel=False, migrate=False)
+        
+    def get_value(self, points : mi.Point2f):
+        r = dr.norm(points - self.origin)
+        inside = r < self.inner_radius
+        points_square = disk_to_square(points, origin = self.origin, radius = self.inner_radius)
+        x, y = get_position_bbox(points_square, self.bbox)
+        if (self.interpolation == "cubic"):
+            res = self.texture.eval_cubic(mi.Point2f(x, y))[0]
+        elif (self.interpolation == "linear"):
+            res =  self.texture.eval(mi.Point2f(x, y))[0]
+        else:
+            raise Exception(
+                f"There is no interpolation called \"{self.interpolation}\"")
+        return dr.select(inside, res, self.out_val)
+        #return res
+    def get_grad_laplacian(self, points: mi.Point2f, use_tensor_only = False):
+        dilate_x = self.bbox[1][0] - self.bbox[0][0]
+        dilate_y = self.bbox[1][1] - self.bbox[0][1]
+        
+        points_square = disk_to_square(points, origin = self.origin, radius = self.inner_radius)
+        x, y = get_position_bbox(points_square, self.bbox)
+        eval_result = self.texture.eval_cubic_hessian(mi.Point2f(x, y))
+        grad_square = eval_result[1][0] / mi.Point2f(dilate_x, -dilate_y)
+        hessian_square = eval_result[2][0]
+        hessian_x = hessian_square[0, 0] / (dilate_x ** 2) 
+        hessian_y = hessian_square[1, 1] / (dilate_y ** 2)
+        hessian_xy = hessian_square[0, 1] / (-dilate_x * dilate_y)
+        jak, jak2 = inverse_jakobian(points, origin = self.origin, radius = self.inner_radius)
+        
+        grad_x = grad_square[0] * jak[0, 0] + grad_square[1] * jak[1, 0]
+        grad_y = grad_square[0] * jak[0, 1] + grad_square[1] * jak[1, 1]
+        
+        laplacian_u = (hessian_x * dr.sqr(jak[0,0]) + grad_square[0] * jak2[0,0] +
+                       hessian_y * dr.sqr(jak[1,0]) + grad_square[1] * jak2[1,0] +
+                        2 * hessian_xy * jak[0, 0] * jak[1, 0])
+        laplacian_v = (hessian_x * dr.sqr(jak[0, 1]) + grad_square[0] * jak2[0, 1] +
+                       hessian_y * dr.sqr(jak[1, 1]) + grad_square[1] * jak2[1, 1] +
+                       2 * hessian_xy * jak[0, 1] * jak[1, 1])
+        
+        grad = mi.Point2f(grad_x, grad_y)
+        laplacian = laplacian_u + laplacian_v
+        r = dr.norm(points - self.origin)
+        return dr.select(r<self.inner_radius, grad, 0), dr.select(r<self.inner_radius, laplacian, 0)
+        #return grad, laplacian
+    
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        for key in opt_params:
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if name == self.name and type == self.type:
+                if param == "tensor":
+                    param_dict[key] = self.tensor
+                elif param == "outval":
+                    param_dict[key] = self.outval
+                else:
+                    raise Exception(
+                        f"DiskTexture ({self.name}) does not have a parameter called \"{param}\"")
+
+    def update(self, optimizer):
+        name_outval = f"{self.name}.{self.type}.outval"
+        if name_outval in optimizer.keys():
+            self.out_val = optimizer[name_outval]
+        
+        name_tensor = f"{self.name}.{self.type}.tensor"
+        if name_tensor in optimizer.keys():
+                self.tensor = optimizer[name_tensor]
+        
+        self.update_texture()
+
+    def zero_grad(self):
+        if dr.grad_enabled(self.tensor):
+            dr.set_grad(self.tensor, 0.0)
+        if dr.grad_enabled(self.out_val):
+            dr.set_grad(self.out_val, 0.0)
+            
+    def upsample(self, scale_factor=[2, 2]):
+        self.tensor = dr.upsample(self.tensor, scale_factor=scale_factor)
+        self.update_texture()
+
+
+    def copy(self):
+        return DiskTextureCoefficient(name = self.name, tensor_np = self.tensor.numpy(),
+                                      origin  = self.origin, radius = self.radius, constant_thickness = self.constant_thickness,
+                                      out_val = self.out_val, interpolation = self.interpolation)

data/PDE2D/Coefficient/elliptic_disk_map.py

@@ -0,0 +1,64 @@
+import mitsuba as mi
+import drjit as dr
+# Peter Shirley and Kenneth Chiu in 1997 derived an area preserving map between square to disc.
+
+def square_to_disk(point : mi.Point2f, radius : mi.Float = 1, origin : mi.Point2f = mi.Point2f(0)):
+    x = (point[0] - origin[0]) / radius
+    y = (point[1] - origin[1]) / radius
+    u = x * dr.sqrt(1 - dr.sqr(y) / 2)
+    v = y * dr.sqrt(1 - dr.sqr(x) / 2)
+    return origin + radius * mi.Point2f(u,v)
+
+def disk_to_square(point: mi.Point2f, radius: mi.Float = 1, origin: mi.Point2f = mi.Point2f(0)):
+    u = (point[0] - origin[0]) / radius
+    v = (point[1] - origin[1]) / radius
+    u2 = dr.sqr(u)
+    v2 = dr.sqr(v)
+    x = 0.5 * (dr.sqrt(2 + u2 - v2 + 2 * dr.sqrt(2) * u) - 
+               dr.sqrt(2 + u2 - v2 - 2 * dr.sqrt(2) * u))
+    y = 0.5 * (dr.sqrt(2 - u2 + v2 + 2 * dr.sqrt(2) * v) -
+               dr.sqrt(2 - u2 + v2 - 2 * dr.sqrt(2) * v))
+    return origin + radius * mi.Point2f(x, y)
+
+def jakobian(point: mi.Point2f, radius : mi.Float = 1, origin : mi.Point2f = mi.Point2f(0)):
+    x = (point[0] - origin[0]) / radius
+    y = (point[1] - origin[1]) / radius
+    x2 = dr.sqr(x)
+    y2 = dr.sqr(y)
+    a11 = dr.sqrt(1 - y2 / 2) # du/dx
+    a12 = -x * y / dr.sqrt(4 - 2 * y2) # du/dy
+    a21 = -x * y / dr.sqrt(4 - 2 * x2) # dv/dx
+    a22 = dr.sqrt(1 - x2 / 2) # dv/dy
+    return mi.Matrix2f(a11, a12, a21, a22)
+
+def inverse_jakobian(point : mi.Point2f, radius : mi.Float = 1, origin : mi.Point2f = mi.Point2f(0)):
+    u = (point[0] - origin[0]) / radius
+    v = (point[1] - origin[1]) / radius
+    u2 = dr.sqr(u)
+    v2 = dr.sqr(v)
+    c11 = 1/(2 * dr.sqrt(2 + u2 - v2 + 2*dr.sqrt(2) * u))
+    c12 = 1/(2 * dr.sqrt(2 + u2 - v2 - 2*dr.sqrt(2) * u))
+    c21 = 1/(2 * dr.sqrt(2 - u2 + v2 + 2*dr.sqrt(2) * v))
+    c22 = 1/(2 * dr.sqrt(2 - u2 + v2 - 2*dr.sqrt(2) * v))
+    
+    a11 = 1/2 * c11 * (2 * u + 2*dr.sqrt(2)) - 1/2 * c12 * (2 * u - 2*dr.sqrt(2)) # dx/du
+    a12 = -c11 * v + c12 * v  # dx/dv
+    a21 = -c21 * u + c22 * u # dy/du
+    a22 = 1/2 * c21 * (2 * v + 2*dr.sqrt(2)) - 1/2 * c22 * (2 * v - 2*dr.sqrt(2)) # dy/dv
+    
+    c11_u = -2 * dr.sqr(c11) * c11 * (2 * u + 2*dr.sqrt(2))
+    c12_u = -2 * dr.sqr(c12) * c12 * (2 * u - 2*dr.sqrt(2))
+    c21_u =  4 * dr.sqr(c21) * c21 * u
+    c22_u =  4 * dr.sqr(c22) * c22 * u
+    
+    c11_v = 4 * dr.sqr(c11) * c11 * v
+    c12_v = 4 * dr.sqr(c12) * c12 * v
+    c21_v = -2 * dr.sqr(c21) * c21 * (2 * v + 2*dr.sqrt(2))
+    c22_v = -2 * dr.sqr(c22) * c22 * (2 * v - 2*dr.sqrt(2))
+    
+    a11_u = 1/2 * c11_u * (2 * u + 2*dr.sqrt(2)) + c11 - 1/2 * c12_u * (2 * u - 2 * dr.sqrt(2)) - c12 # d2x/du2
+    a12_v = -c11 + c12 + v * (c12_v - c11_v)# d2x/dv2
+    a21_u = -c21 + c22 + u * (c22_u - c21_u) # d2y/du2
+    a22_v = 1/2 * c21_v * (2 * v + 2*dr.sqrt(2)) + c21 - 1/2 * c22_v * (2 * v - 2*dr.sqrt(2)) - c22  # d2y/dv2
+    
+    return mi.Matrix2f(a11, a12, a21, a22), mi.Matrix2f(a11_u, a12_v, a21_u, a22_v)

data/PDE2D/Coefficient/function.py

@@ -0,0 +1,75 @@
+
+from .coefficient import *
+
+class FunctionCoefficient(Coefficient):
+    DRJIT_STRUCT = { 
+        'parameters' : dict,
+        'function_generator' : callable,
+        }
+    def __init__(self, name: str, parameters: dict, function_generator: callable,
+                 grad_generator: callable = None, laplacian_generator: callable = None):
+        self.is_zero = False
+        self.parameters = parameters
+        self.function_generator = function_generator
+        self.grad_generator = grad_generator
+        self.laplacian_generator = laplacian_generator
+        self.name = name
+        self.type = "CustomFunction"
+        for key in parameters.keys():
+            dr.make_opaque(parameters[key])
+        self.update_function()
+
+    def update_function(self):
+        self.function = lambda points : self.function_generator(points, self.parameters)
+        if ((self.grad_generator is not None) & (self.laplacian_generator is not None)):
+            self.grad = lambda points : self.grad_generator(points, self.parameters)
+            self.laplacian = lambda points : self.laplacian_generator(points, self.parameters)
+        else:
+            self.grad = None
+            self.laplacian = None
+
+    def get_value(self, points):
+        return self.function(points)
+
+    def get_grad_laplacian(self, points):
+        if ((self.grad is not None) & (self.laplacian is not None)):
+            return self.grad(points), self.laplacian(points)
+        else:
+            raise Exception(
+                f"Laplacian or gradient is not defined for the function coefficient\"{self.name}\"!")
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        for i in opt_params:
+            param_exists = False
+            for j in self.parameters.keys():
+                if i == j:
+                    param_dict[f"{self.name}.{self.type}.{i}"] = self.parameters[i]
+                    param_exists = True
+            if not param_exists:
+                raise Exception(
+                    f"Function coefficient \"{self.name}\" of type \"{self.type}\" does not have parameter called \"{i}\".")
+
+    def update(self, optimizer):
+        param_exists = False
+        for key in optimizer.keys():
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if (name == self.name) & (type == self.type):
+                for p in self.parameters.keys():
+                    if p == param:
+                        param_exists = True
+                        self.parameters[p] = optimizer[key]
+        if param_exists:
+            self.update_function()
+
+    def zero_grad(self):
+        for key in self.parameters.keys():
+            if dr.grad_enabled(self.parameters[key]):
+                dr.set_grad(self.parameters[key], 0.0)
+
+    def copy(self):
+        new = FunctionCoefficient(self.name, self.parameters, self.function_generator,
+                                  self.grad_generator, self.laplacian_generator)
+        return new

data/PDE2D/Coefficient/gaussian.py

@@ -0,0 +1,104 @@
+from .coefficient import *
+from mitsuba import UInt
+
+class GaussianMixtureCoefficient(Coefficient):
+    def __init__(self, name, mean, std, power=1.0, corr=1, bias=0, num_lobes: int = 1):
+        self.name = name
+        self.is_zero = False
+        self.type = "gaussian"
+        self.power = mi.Float(power) if (dr.width(
+            mi.Float(power)) == num_lobes) else dr.full(mi.Float, power, num_lobes)
+        std0 = mi.Float(std[0]) if (dr.width(mi.Float(std[0]))
+                                    == num_lobes) else dr.full(mi.Float, std[0], num_lobes)
+        std1 = mi.Float(std[1]) if (dr.width(mi.Float(std[1]))
+                                    == num_lobes) else dr.full(mi.Float, std[1], num_lobes)
+        self.std = mi.Point2f(std0, std1)
+        self.corr = mi.Float(corr) if (
+            dr.width(mi.Float(corr)) == num_lobes) else dr.full(mi.Float, corr, num_lobes)
+        self.bias = mi.Float(bias)
+        mean0 = mi.Float(mean[0]) if (dr.width(
+            mi.Float(mean[0])) == num_lobes) else dr.full(mi.Float, mean[0], num_lobes)
+        mean1 = mi.Float(mean[1]) if (dr.width(
+            mi.Float(mean[1])) == num_lobes) else dr.full(mi.Float, mean[1], num_lobes)
+        self.mean = mi.Point2f(mean0, mean1)
+        self.num_lobes = num_lobes
+
+    def get_lobe_params(self, lobe_num: UInt):
+        mean = dr.gather(mi.Point2f, self.mean, lobe_num)
+        std = dr.gather(mi.Point2f, self.std, lobe_num)
+        power = dr.gather(mi.Float, self.power, lobe_num)
+        corr = dr.gather(mi.Float, self.corr, lobe_num)
+        return mean, std, corr, power
+
+    def get_value(self, points):
+        value = mi.Float(0)
+        for i in range(self.num_lobes):
+            mean, std, corr, power = self.get_lobe_params(mi.Float(i))
+            m = dr.rcp(1 - dr.sqr(corr))
+            A = dr.rcp(2 * dr.pi * std[0] * std[1]) * dr.sqrt(m)
+            XY = (points - mean) / std
+            exponent = dr.sqr(XY[0]) + dr.sqr(XY[1]) - 2 * corr * XY[0] * XY[1]
+            exponent *= (-m / 2)
+            value += A * power * dr.exp(exponent)
+        return value + self.bias
+
+    def get_grad_laplacian(self, points):
+        grad = mi.Point2f(0)
+        laplacian = mi.Float(0)
+        for i in range(self.num_lobes):
+            mean, std, corr, power = self.get_lobe_params(mi.Float(i))
+            m = dr.rcp(1 - dr.sqr(corr))
+            A = dr.rcp(2 * dr.pi * std[0] * std[1]) * dr.sqrt(m)
+            XY = (points - mean) / std
+            exponent = dr.sqr(XY[0]) + dr.sqr(XY[1]) - 2 * corr * XY[0] * XY[1]
+            exponent *= (-m / 2)
+            E = dr.exp(exponent)
+            C_x = -m * (XY[0] - corr * XY[1]) / std[0]
+            C_y = -m * (XY[1] - corr * XY[0]) / std[1]
+            grad_ = A * E * power * mi.Point2f(C_x, C_y)
+            grad += grad_
+            k = dr.rcp(dr.sqr(std[0])) + dr.rcp(dr.sqr(std[1]))
+            laplacian += A * E * power * (dr.sqr(C_x) + dr.sqr(C_y) - m * k)
+        return grad, laplacian
+
+    def zero_grad(self):
+        for param in [self.power, self.std, self.corr, self.bias, self.mean]:
+            if dr.grad_enabled(param):
+                dr.set_grad(param, 0.0)
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        for i in opt_params:
+            if i == "mean":
+                param_dict[f"{self.name}.{self.type}.mean"] = self.mean
+            elif i == "std":
+                param_dict[f"{self.name}.{self.type}.std"] = self.std
+            elif i == "power":
+                param_dict[f"{self.name}.{self.type}.power"] = self.power
+            elif i == "correlation":
+                param_dict[f"{self.name}.{self.type}.correlation"] = self.corr
+            elif i == "bias":
+                param_dict[f"{self.name}.{self.type}.bias"] = self.bias
+            else:
+                raise Exception(
+                    f"Gaussian Coefficient ({self.name}) does not have a parameter called \"{i}\"")
+
+    def update(self, optimizer):
+        for key in optimizer.keys():
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if (name == self.name) & (type == self.type):
+                if param == "mean":
+                    self.mean = optimizer[key]
+                elif param == "std":
+                    self.std = optimizer[key]
+                elif param == "power":
+                    self.power = optimizer[key]
+                elif param == "correlation":
+                    self.corr = optimizer[key]
+                elif param == "bias":
+                    self.bias = optimizer[key]
+                else:
+                    raise Exception(
+                        f"Gaussian Coefficient ({self.name}) does not have a parameter called \"{param}\"")

data/PDE2D/Coefficient/texture.py

@@ -0,0 +1,149 @@
+from .coefficient import *
+#from PDE2D import mi.TensorXf, mi.Float, mi.Point2f, mi.Texture2f, mi.UInt32, mi.TensorXb
+from PDE2D.utils.helpers import get_position_bbox
+from PDE2D.utils import upsample
+
+class TextureCoefficient(Coefficient):
+    def __init__(self, name: str, bbox: list, tensor_np: np.array,
+                 interpolation: str = "cubic", wrapping: str = "clamp", 
+                 grad_zero_points = None, out_val : mi.Float = None):
+        self.is_zero = False
+        self.interpolation = interpolation
+        self.tensor = mi.TensorXf(tensor_np.squeeze()[..., np.newaxis])
+        self.name = name
+        self.type = "texture"
+        self.wrapping = wrapping
+        self.bbox = bbox
+        dr.make_opaque(self.tensor)
+        self.grad_zero_points = grad_zero_points
+        self.out_val = out_val
+        self.grad_zero_mask = None
+        
+        if self.grad_zero_points is not None:
+            mask = self.compute_grad_zero_mask()
+            self.grad_zero_mask = mi.TensorXb(mask, shape = (self.tensor.shape))
+            dr.eval(self.grad_zero_mask)
+            if self.out_val is None:
+                raise Exception("If you want to force gradient to be zero in some locations, "
+                                "please specify a forced texture value (out_val).")
+            else:
+                dr.make_opaque(self.out_val)
+        
+        self.texture = None
+        self.update_texture()
+
+    def compute_grad_zero_mask(self):
+        tensor = dr.arange(mi.Float, dr.width(self.tensor.array))
+        tensor = mi.TensorXf(tensor, shape = self.tensor.shape)
+        dr.enable_grad(tensor)
+        texture = self.create_texture(tensor)
+        dr.backward(self.get_grad_laplacian_(self.grad_zero_points, texture)[0])
+        mask = dr.abs(dr.grad(tensor).array) > 0
+        dr.disable_grad(tensor)
+        return mask
+        
+
+    def create_texture(self, tensor : mi.TensorXf):
+        # Creating the texture!
+        wrap_mode = None
+        if self.wrapping == "clamp":
+            wrap_mode = dr.WrapMode.Clamp
+        elif self.wrapping == "mirror":
+            wrap_mode = dr.WrapMode.Mirror
+        elif self.wrapping == "repeat":
+            wrap_mode = dr.WrapMode.Repeat
+        else:
+            raise Exception("Such wrapping is not defined.")
+            
+        filter_type = dr.FilterMode.Nearest if self.interpolation=="nearest" else dr.FilterMode.Linear
+        return mi.Texture2f(tensor, wrap_mode=wrap_mode, use_accel=False, migrate=False, filter_mode=filter_type)
+
+    def update_texture(self):
+        tensor = mi.TensorXf(self.tensor)
+        if self.grad_zero_mask is not None:
+            tensor = dr.select(self.grad_zero_mask, mi.TensorXf(dr.detach(self.out_val)), tensor)
+        if self.texture is None:
+            self.texture = self.create_texture(tensor)
+        else:
+            self.texture.set_tensor(tensor)
+
+    def get_value(self, points: mi.Point2f):
+        x, y = get_position_bbox(points, self.bbox)
+        if (self.interpolation == "cubic"):
+            return self.texture.eval_cubic(mi.Point2f(x, y))[0]
+        elif (self.interpolation == "linear" or self.interpolation == "nearest"):
+            return self.texture.eval(mi.Point2f(x, y))[0]
+        else:
+            raise Exception(
+                f"There is no interpolation called \"{self.interpolation}\"")
+
+    def get_grad_laplacian(self, points):
+        return self.get_grad_laplacian_(points, self.texture)
+    
+    def get_grad_laplacian_(self, points: mi.Point2f, texture : mi.Texture2f):
+        if not self.interpolation == "cubic":
+            raise Exception("Laplacian is only defined for cubic interpolation.")
+        dilate_x = self.bbox[1][0] - self.bbox[0][0]
+        dilate_y = self.bbox[1][1] - self.bbox[0][1]
+        x, y = get_position_bbox(points, self.bbox)
+        eval_result = texture.eval_cubic_hessian(mi.Point2f(x, y))
+        grad = eval_result[1][0] / mi.Point2f(dilate_x, -dilate_y)
+        hessian_image = eval_result[2][0]
+        laplacian = hessian_image[0, 0] / \
+            (dilate_x ** 2) + hessian_image[1, 1] / (dilate_y ** 2)
+        return mi.Point2f(grad), mi.Float(laplacian)
+    
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        for key in opt_params:
+            vals = key.split(".")
+            name = vals[0]
+            type = vals[1]
+            param = vals[2]
+            if name == self.name and type == self.type:
+                if param == "tensor":
+                    param_dict[key] = self.tensor
+                elif param == "outval":
+                    param_dict[key] = self.out_val 
+                else:
+                    raise Exception(
+                        f"TextureCoefficient ({self.name}) does not have a parameter called \"{param}\"")
+
+    def update(self, optimizer):
+        name_outval = f"{self.name}.{self.type}.outval"
+        if name_outval in optimizer.keys():
+            self.out_val = optimizer[name_outval]
+        
+        name_tensor = f"{self.name}.{self.type}.tensor"
+        if name_tensor in optimizer.keys():
+            #if self.grad_zero_mask is not None:
+            self.tensor = optimizer[name_tensor]
+        self.update_texture()
+
+
+    def zero_grad(self):
+        if dr.grad_enabled(self.tensor):
+            dr.set_grad(self.tensor, 0.0)
+
+    def copy(self):
+        new = TextureCoefficient(self.name, self.bbox, self.tensor.numpy().squeeze(),
+                                 self.interpolation, self.wrapping, self.grad_zero_points, self.out_val)
+        new.zero_grad()
+        return new
+
+    def upsample(self, scale_factor=[2, 2]):
+        self.tensor = dr.upsample(self.tensor, scale_factor=scale_factor)
+        self.update_texture()
+
+    def copy(self):
+        return TextureCoefficient(name = self.name, bbox = self.bbox, tensor_np=self.tensor.numpy().squeeze(), 
+                                  interpolation = self.interpolation, wrapping = self.wrapping, 
+                                  grad_zero_points=self.grad_zero_points, out_val = self.out_val)
+    
+    def upsample2(self):
+        self.tensor = upsample(self.tensor, scale_factor=[2,2])
+        dr.eval(self.tensor)
+        if self.grad_zero_points is not None:
+            mask = self.compute_grad_zero_mask()
+            self.grad_zero_mask = mi.TensorXb(mask, shape = (self.tensor.shape))
+        self.update_texture()
+        

data/PDE2D/GreenModels/green_2d_12.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d93ab9ad31b28cd5e2da82eada7c14e19bc9f5a126f0cf58f0387c194fd729cd
+size 48073

data/PDE2D/GreenModels/green_2d_8.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31e20b18e9838f307d8a1a5b3d01e232b32c50c04a1ae26c349c3f2e96e93652
+size 32057

data/PDE2D/GreenModels/green_3d_12.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36e0e9b18c145616c5403d652013320acfa3245fd326bfa7a214c925b03874de
+size 48073

data/PDE2D/GreenModels/green_3d_8.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31dde834a30d27c672690d41c365d5d23d024abed684bf4edd893457ad537793
+size 32057

data/PDE2D/GreenModels/green_grad_2d_12.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a982772513fb02866d781b27c38c6e84206247935cfce80e880ab86e54baf456
+size 48073

data/PDE2D/GreenModels/green_grad_2d_8.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1ba97475407f902e490921cff5ef2484acccc87ee0a52e02073f7ad84dbbe9e
+size 32057

data/PDE2D/GreenModels/green_grad_3d_12.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:124f1ed9fe1849ad04e0d2208378f50900d7073c8e4314709767223204658a05
+size 48073

data/PDE2D/GreenModels/green_grad_3d_8.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:958dfbc57b9d7fbea592a47b89e405b5ab9f6256c087582cc50f30a776e12100
+size 32057

data/PDE2D/Sampling/__init__.py

@@ -0,0 +1,5 @@
+from .sampling_wos import *
+#from .tabulated import TabulatedLinearPDF1D
+from .green import GreensFunction
+from .green_polynomial import GreensFunctionPolynomial
+from .green_analytic import GreensFunctionAnalytic

data/PDE2D/Sampling/green.py

@@ -0,0 +1,41 @@
+import mitsuba as mi
+from PDE2D import DIM
+from PDE2D.Sampling.special import *
+from mitsuba import Float
+ 
+z_threshold = Float(0.05)
+
+class GreensFunction:
+    def __init__(self, dim : DIM, grad : bool = False, newton_steps : int = 5) -> None:
+        """
+        The parameter ``newton_it`` specifies how many Newton iteration steps
+        the implementation should perform in the ``.sample()`` method following
+        initialization from a starting guess.
+        """
+        self.dim = dim
+        self.newton_steps = newton_steps
+        self.is_grad = grad
+    
+    def initialize(self, z : Float) -> None:
+        pass
+
+    def eval(self, r:Float, radius:Float, σ: Float) -> Float:
+        return Float(0)
+    
+    def eval_pdf(self, r: Float, radius: Float, σ : Float) -> tuple[Float, Float, Float]:
+        return Float(0), Float(0), Float(0)
+    
+    def eval_norm(self, radius : Float, σ : Float) -> Float:
+        return Float(0)
+
+    def sample(self, x: Float, radius: Float, σ: Float) -> tuple[Float, Float]:
+        return Float(0), Float(0)
+
+    def eval_poisson_kernel(self, r : Float, radius : Float, σ : Float) -> Float:
+        return Float(0)
+    
+    def eval_pdf_only(self, r : Float, radius : Float, σ : Float) -> Float:
+        norm = self.eval_norm(radius, σ)
+        val = self.eval(r, radius, σ)
+        pdf = val * dr.rcp(norm)
+        return pdf

data/PDE2D/Sampling/green_analytic.py

@@ -0,0 +1,207 @@
+import drjit as dr
+import mitsuba as mi
+from PDE2D import DIM
+from PDE2D.Sampling.special import *
+from .green import GreensFunction
+ 
+z_threshold = mi.Float(0.05)
+
+class GreensFunctionAnalytic(GreensFunction):
+    def __init__(self, dim : DIM, grad : bool = False, newton_steps : int = 5) -> None:
+        """
+        The parameter ``newton_it`` specifies how many Newton iteration steps
+        the implementation should perform in the ``.sample()`` method following
+        initialization from a starting guess.
+        """
+
+        super().__init__(dim, grad, newton_steps)
+
+    @dr.syntax # type: ignore
+    def eval(self, r:mi.Float, radius:mi.Float, σ: mi.Float) -> mi.Float:
+        z = radius * dr.sqrt(σ)
+        y = r * dr.rcp(radius)
+        yz = y * z
+        rcpyz = dr.rcp(yz)
+        rcpz = dr.rcp(z)
+        val = mi.Float(0)
+
+        if dr.hint(self.dim == DIM.Two, mode = 'scalar'):
+            if dr.hint(self.is_grad, mode = 'scalar'):
+                #raise Exception("Not Implemented.")
+                if z < z_threshold:
+                    val = 1 - dr.square(y)
+                else:
+                    val = yz * dGσ(y, z)
+            else:
+                if z < z_threshold:
+                    val = dr.select(r ==0, 0, -r * dr.log(y))
+                else:
+                    val = r * Gσ(y, z) 
+        else:
+            #raise Exception("Not implemented.")
+            if dr.hint(self.is_grad, mode = 'scalar'):
+                if z < z_threshold:
+                    val = 1 - y * dr.square(y)
+                else:
+                    val = yz * (dr.exp(-yz) * (1 + rcpyz) -
+                                dr.exp(-z) * (1 + rcpz) *  ( (dr.cosh(yz) - dr.sinh(yz) * rcpyz) *  dr.rcp(dr.cosh(z) - dr.sinh(z) * rcpz) ))
+                val = dr.select(y <= 0, 1, val)
+                val = dr.select(y >= 1, 0, val)
+        
+            else:
+                if z < z_threshold:
+                    val = r * (1 - y)
+                else:
+                    val = radius * y * yz * (dr.exp(-yz) * dr.rcp(yz) - 
+                                                dr.exp(-z) * dr.rcp(yz) * dr.sinh(yz) * dr.rcp(dr.sinh(z)))
+                    val = dr.select(y == 0, 0, val)
+                    val = dr.select(y == 1, 0, val)
+                    
+        val = dr.select((y>=0) & (y<=1), val, 0)
+        return val
+    
+
+    @dr.syntax # type: ignore
+    def eval_pdf(self, r: mi.Float, radius: mi.Float, σ : mi.Float) -> tuple[mi.Float, mi.Float, mi.Float]:
+        norm = self.eval_norm(radius, σ)
+        val = self.eval(r, radius, σ)
+        pdf = val * dr.rcp(norm)
+        cdf = mi.Float(0)
+        y = r * dr.rcp(radius)
+        z = radius * dr.sqrt(σ)
+        coshz = dr.cosh(z)
+        sinhz = dr.sinh(z)
+        yz = y * z
+        zyz = z - yz
+        y2 = dr.square(y)
+
+        if dr.hint(self.dim == DIM.Two, mode = 'scalar'):
+            if dr.hint(self.is_grad, mode = 'scalar'):
+            #    raise Exception("Not implemented")
+                if z < z_threshold:
+                    cdf = y * (1.5 - dr.square(y) * 0.5)
+                else:
+                    cdf = mi.Float(dr.nan) # Other case requires evaluation of very expensive and complex functions.
+            else:
+                if z < z_threshold:
+                    cdf = dr.square(y) * (1 - 2 * dr.log(y))
+                else:
+                    cdf = Gσr_int(y,z) * dr.rcp(σ * norm)
+
+        else:
+            #raise Exception("Not implemented.")
+            if dr.hint(self.is_grad, mode = 'scalar'):
+                if z < z_threshold:
+                    cdf = (4 * y - dr.square(y2)) / 3
+                else:
+                    cdf = ((-2* coshz + (2- yz * z) * dr.cosh(zyz) + 2 * z * dr.sinh(z) + (y-2) * z * dr.sinh(zyz)) / 
+                            (2 - dr.square(z) - 2 * dr.cosh(z) + 2 * z * sinhz))
+            else:
+                if z < z_threshold:
+                    cdf = dr.square(y) * (3 - 2 * y)
+                else:
+                    cdf = (yz * dr.cosh(zyz) - dr.sinh(z) + dr.sinh(zyz)) * dr.rcp(z - dr.sinh(z))
+        
+        if y <= 0:
+            cdf = mi.Float(0)
+        if y >= 1: 
+            cdf = mi.Float(1)
+        return pdf, cdf, norm
+    
+    @dr.syntax # type: ignore
+    def eval_norm(self, radius : mi.Float, σ : mi.Float) -> mi.Float:
+        norm = mi.Float(0)
+        z = radius * dr.sqrt(σ)
+        coshz = dr.cosh(z)
+        sinhz = dr.sinh(z)  
+        
+        if dr.hint(self.dim == DIM.Two, mode = 'scalar'):
+            if dr.hint(self.is_grad, mode = 'scalar'):
+                raise Exception("Not Implemented")
+                if z < z_threshold:
+                    norm = 2 * radius / 3
+                else:
+                    norm = mi.Float(dr.nan) # Other case requires evaluation of very expensive and complex functions.
+            else:
+                if z < z_threshold:
+                    norm = dr.square(radius) / 4 
+                else:
+                    norm = dr.rcp(σ) * (1.0 - dr.rcp(i0(z)))
+                    
+        else:
+            #raise Exception("Not Implemented")
+            if dr.hint(self.is_grad, mode = 'scalar'):
+                if z < z_threshold:
+                    norm = 3 * radius / 4
+                else: 
+                    norm = radius * (2 - dr.square(z) - 2 * coshz + 2 * z * sinhz) * dr.rcp(z * (z * coshz - sinhz))
+            else:
+                if z < z_threshold:
+                    norm = dr.square(radius) / 6
+                else:
+                    norm = dr.rcp(σ) * (1 - z * dr.rcp(dr.sinh(z)))
+        return norm
+
+    @dr.syntax # type: ignore
+    def sample(self, x: mi.Float, radius: mi.Float, σ: mi.Float) -> tuple[mi.Float, mi.Float]:
+        # The expression to initialize the Newton iteration is numerically
+        # unstable when 'z' is too small. Clamp to 1e-1 (for this part only)
+        z = dr.sqrt(σ)
+        z_init = dr.maximum(z, 1e-1)
+        b = None
+
+        if dr.hint(not self.is_grad, mode='scalar'):
+            if dr.hint(self.dim == DIM.Two, mode='scalar'):
+                # Based on 'Sample3Composed2' from the Mathematica notebook
+                sqrt_x = dr.sqrt(x)
+                b = 1 - dr.acosh(dr.fma(dr.cosh(z_init), 1 - sqrt_x, sqrt_x)) / z_init
+            elif self.dim == DIM.Three:
+                # Based on 'Sample2Composed1' from the Mathematica notebook
+                b = (1 - dr.acosh(dr.fma(dr.cosh(z_init), 1 - x, x)) / z_init) ** (2 / 3)
+            else:
+                raise RuntimeError("Unsupported number of dimensions!")
+        else:
+            # No good sampling strategy yet
+            b = (1 - dr.sqrt(1-x))
+
+        # Bracketing interval
+        a, c = mi.Float(0), mi.Float(1)
+
+        # Iteration counter
+        i = mi.UInt32(0)
+        norm = mi.Float(0)
+        while i < self.newton_steps:
+            # Perform a Newton step
+            deriv, cdf, norm = self.eval_pdf(b * radius, radius, σ)
+            deriv *= radius 
+            b = b - (cdf - x) / deriv
+
+            # Newton-Bisection: potentially reject the Newton step
+            bad_step = ~((b >= a) & (b <= c))
+            b = dr.select(bad_step, (a + c) / 2, b)
+
+            # Update bracketing interval
+            is_neg = self.eval_pdf(b * radius, radius, σ)[1] - x < 0
+            a = dr.select(is_neg, b, a)
+            c = dr.select(is_neg, c, b)
+
+            i += 1
+        return b * radius, norm 
+    
+    @dr.syntax # type: ignore
+    def eval_poisson_kernel(self, r : mi.Float, radius : mi.Float, σ : mi.Float):
+        
+        # There is no such relation for poisson kernel in gradient.
+        # I did not look to the 3D case.
+        assert (not self.is_grad) & (self.dim == DIM.Two)
+        
+        z = radius * dr.sqrt(σ)
+        y = r/radius
+
+        result = mi.Float(0)
+        if z < z_threshold:
+            result =  1 - dr.square(y) * (1 - 2 * dr.log(y)) * self.eval_norm(radius, σ) *  σ
+        else: 
+            result = 1- Gσr_int(r/radius, z)
+        return result
+        

data/PDE2D/Sampling/green_polynomial.py

@@ -0,0 +1,219 @@
+import drjit as dr
+import numpy as np
+import mitsuba as mi 
+from mitsuba import Float, UInt32, Point1f, TensorXf
+from PDE2D import DIM, PATH
+import os
+from .green import GreensFunction
+
+class GreensFunctionPolynomial(GreensFunction):
+    def __init__(self, dim : DIM, newton_steps: int = 4, grad : bool = False, ncoeffs : int = 8) -> None:
+        """
+        Load a binary file containing series expansion coefficients describing
+        the Green's function in 2D or 3D.
+
+        The parameter ``newton_it`` specifies how many Newton iteration steps
+        the implementation should perform in the ``.sample()`` method following
+        initialization from a starting guess.
+        """
+
+        import array
+        import struct
+
+        super().__init__(dim, grad, newton_steps)
+
+        if self.is_grad:
+            filename = f"green_grad_3d_{ncoeffs}.model" if dim == DIM.Three else f"green_grad_2d_{ncoeffs}.model"
+        else:
+            filename = f"green_3d_{ncoeffs}.model" if dim == DIM.Three else f"green_2d_{ncoeffs}.model"
+
+        filename = os.path.join(PATH,"PDE2D", "GreenModels", filename)
+
+        with open(filename, "rb") as f:
+            # Double-check that this file was generated by the Mathematica notebook
+            if f.read(5) != b"GREEN":
+                raise RuntimeError(
+                    f'GreensFunction("{filename}"): incompatible input file.'
+                )
+
+            # Following the header, the file stores a few integers. The first
+            # one specifies whether the coefficients represent a Green's
+            # function or its gradient.
+            is_grad: int = struct.unpack("i", f.read(4))[0]
+            if is_grad != 0 and is_grad != 1:
+                raise RuntimeError(f'GreensFunction("{filename}"): invalid input.')
+            self.is_grad: bool = is_grad == 1
+
+            # The next field specifies the number of dimensions, which must be
+            # known by some functions below
+            self.ndim: int = struct.unpack("i", f.read(4))[0]
+            if self.ndim != 2 and self.ndim != 3:
+                raise RuntimeError(
+                    f'GreensFunction("{filename}"): expected a 2D or 3D model file.'
+                )
+
+            # Number of coefficients per 'z' value
+            self.ncoeffs: int = struct.unpack("i", f.read(4))[0]
+
+            # Number of sampled 'z' values contained in the file
+            self.nsamples: int = struct.unpack("i", f.read(4))[0]
+
+            # Largest 'z' value represented in the file
+            self.zmax: float = struct.unpack("f", f.read(4))[0]
+
+            data = f.read()
+            if len(data) != self.ncoeffs * self.nsamples * 4:
+                raise RuntimeError(f'GreensFunction("{filename}"): invalid file size.')
+
+        coeff_flat = np.array(array.array("f", data)).squeeze()
+        data_shape = (self.nsamples, self.ncoeffs)
+        #coeff_tensor = TensorXf(coeff_flat, shape = data_shape)
+        coeff_tensor = TensorXf(coeff_flat, shape=data_shape)
+
+        # Create a 1D texture to interpolate the loaded data
+        self.coeff_tex = mi.Texture1f(coeff_tensor)
+
+    def initialize(self, z : Float):
+        self.coeffs = self.fetch_coeffs(z)
+
+    def fetch_coeffs(self, z: Float) -> list[Float]:
+        """
+        Perform a linearly interpolated lookup into the texture to fetch
+        coefficients for a particular value of ``z``.
+        """
+        # Scale ``z`` according to the texture discretization
+        # that places samples at position .5 within each texel
+        n = self.nsamples
+        z_scaled = dr.fma(z, dr.rcp(self.zmax) * (n - 1) / n, 0.5 / n)
+        return self.coeff_tex.eval(Point1f(z_scaled))
+    
+    def eval(self, r: Float, radius: Float, σ : Float) -> Float:
+        pdf, _, norm = self.eval_pdf(r, radius, σ)
+        return pdf * norm
+    
+
+    def eval_pdf(self, r: Float, radius: Float, σ : Float) -> tuple[Float, Float, Float]:
+        """
+        Evaluate the Green's function CDF for position ``y`` (between 0 and 1)
+        and parameter ``z``. The function returns a tuple containing
+
+        - the CDF (normalized), which is normalized, i.e., ``eval(1, z)[0] == 1``
+        - the y-derivative of the normalized CDF
+        - the normalization constant
+
+        It's fine to call this function even if you do not need all of the
+        results. Dr.Jit will optimize the rest away.
+        """
+        #pdf, cdf, norm =  self.eval_pdf_with_coeffs_y(r/radius, self.fetch_coeffs(radius * dr.sqrt(σ)))
+        pdf, cdf, norm =  self.eval_pdf_with_coeffs_y(r/radius, self.coeffs)
+        pdf *= dr.rcp(radius)
+        norm *= radius if self.is_grad else dr.square(radius)
+        return pdf, cdf, norm
+
+
+    def eval_pdf_with_coeffs_y(
+        self, y: Float, coeffs: list[Float]
+    ) -> tuple[Float, Float, Float]:
+        """
+        Implementation of the ``eval`` function. This function has
+        essentially the same signature but expects that polynomial
+        coefficients (obtained via ``fetch_coeffs()``) are provided
+        via the ``coeffs`` parameter.
+        """
+        assert len(coeffs) == self.ncoeffs
+
+        L_accum, Ld_accum, R_accum, Rd_accum, norm = (
+            Float(0),
+            Float(0),
+            Float(0),
+            Float(0),
+            Float(0),
+        )
+
+        y2 = dr.square(y)
+
+        for i in reversed(range(0, self.ncoeffs, 2)):
+            exponent = i + 2 - int(self.is_grad)
+            R, L = coeffs[i], coeffs[i + 1]
+            R_accum = dr.fma(R_accum, y2, R)
+            L_accum = dr.fma(L_accum, y2, L)
+            Rd_accum = dr.fma(Rd_accum, y2, R * exponent)
+            Ld_accum = dr.fma(Ld_accum, y2, L * exponent)
+            norm += R
+
+        log_x = dr.log(dr.maximum(y, 1e-10))
+        inv_norm = dr.rcp(norm)
+
+        value = dr.fma(L_accum, log_x, R_accum) * inv_norm
+        deriv = dr.fma(Ld_accum, log_x, Rd_accum + L_accum) * inv_norm
+
+        if self.is_grad:
+            value *= y
+        else:
+            value *= y2
+            deriv *= y
+
+        return deriv, value, norm
+
+    def eval_norm(self, radius : Float, σ : Float) -> Float:
+        norm = Float(0)
+        #coeffs = self.fetch_coeffs(radius * dr.sqrt(σ))
+        for i in reversed(range(0, self.ncoeffs, 2)):
+            norm += self.coeffs[i]
+        norm *= radius if self.is_grad else dr.square(radius)
+        return norm
+
+
+    @dr.syntax # type: ignore
+    def sample(self, x: Float, radius : Float, σ: Float) -> tuple[Float, Float]:
+        # The expression to initialize the Newton iteration is numerically
+        # unstable when 'z' is too small. Clamp to 1e-1 (for this part only)
+        z = radius * dr.sqrt(σ)
+        z_init = dr.maximum(z, 1e-1)
+        b = None
+        norm = Float(0)
+        if dr.hint(not self.is_grad, mode='scalar'):
+            if dr.hint(self.ndim == 2, mode='scalar'):
+                # Based on 'Sample3Composed2' from the Mathematica notebook
+                sqrt_x = dr.sqrt(x)
+                b = 1 - dr.acosh(dr.fma(dr.cosh(z_init), 1 - sqrt_x, sqrt_x)) / z_init
+            elif self.ndim == 3:
+                # Based on 'Sample2Composed1' from the Mathematica notebook
+                b = (1 - dr.acosh(dr.fma(dr.cosh(z_init), 1 - x, x)) / z_init) ** (2 / 3)
+            else:
+                raise RuntimeError("Unsupported number of dimensions!")
+        else:
+            # No good sampling strategy yet
+            b = Float(x)
+
+        # Fetch the coefficients once and then reuse them
+        coeffs = self.coeffs
+
+        # Bracketing interval
+        a, c = Float(0), Float(1)
+
+        # Iteration counter
+        i = UInt32(0)
+
+        while i < self.newton_steps:
+            # Perform a Newton step
+            deriv, cdf, norm = self.eval_pdf_with_coeffs_y(b, coeffs)
+            b = b - (cdf - x) / deriv
+
+            # Newton-Bisection: potentially reject the Newton step
+            bad_step = ~((b >= a) & (b <= c))
+            b = dr.select(bad_step, (a + c) / 2, b)
+
+            # Update bracketing interval
+            is_neg = self.eval_pdf_with_coeffs_y(b, coeffs)[1] - x < 0
+            a = dr.select(is_neg, b, a)
+            c = dr.select(is_neg, c, b)
+
+            i += 1
+        norm *= radius if self.is_grad else dr.square(radius)
+        return b * radius, norm
+    
+    def eval_poisson_kernel(self, r: Float, radius: Float, σ : Float) -> Float:
+        _, cdf, norm = self.eval_pdf(r, radius, σ)
+        return 1 - cdf * norm * σ
+

data/PDE2D/Sampling/sampling_wos.py

@@ -0,0 +1,168 @@
+import mitsuba as mi 
+from mitsuba import Float, Bool
+from .special import *
+from ..utils import *
+from ..utils.helpers import *
+
+
+def sample_cosk_direction(sample, direction, k : Float = Float(2)): #k>2
+    # sample symmetrically w.r.t. the direction with cos(theta / k)
+    right_sphere = sample >= 0.5
+    sample = dr.select(right_sphere, 2 * sample - 1, 2 * sample)
+    angle_shift = k * dr.asin(sample * dr.sin(dr.pi /k))
+    angle_shift = dr.select(right_sphere, angle_shift, -angle_shift)
+    angle_initial = dr.atan2(direction[1], direction[0])
+    angle = angle_initial + angle_shift
+    sampled_direction = mi.Point2f(dr.cos(angle), dr.sin(angle))
+    pdf = dr.rcp(2 * k * dr.sin(dr.pi /k)) * dr.cos(angle_shift / k)
+    return sampled_direction, pdf
+
+def pdf_cosk_direction(sampled_direction, direction, k): #k>2
+    angle_diff = dr.abs(dr.acos(dr.dot(sampled_direction, direction)))
+    return dr.rcp(2 * k * dr.sin(dr.pi /k)) * dr.cos(angle_diff / k)
+
+@dr.syntax
+def sample_star_direction(sample,  half_space_mask : Bool, boundary_normal : mi.Point2f) -> tuple[mi.Point2f, mi.Float]:
+    angle = mi.Float(0)
+    direction = mi.Point2f(0)
+    pdf = mi.Float(0)
+    if half_space_mask:
+        angle = mi.Float((sample - 0.5) * dr.pi)
+        direction = mi.Point2f(dr.sin(angle), dr.cos(angle))
+        direction = dr.normalize(to_world_direction(direction, boundary_normal))
+        pdf = Float(1/dr.pi)
+    else:
+        angle = mi.Float(2 * dr.pi * sample)
+        direction = mi.Point2f(dr.sin(angle), dr.cos(angle))
+        pdf = Float(1 / (2 * dr.pi))
+    return direction, pdf
+
+def sample_uniform_direction(sample):
+    theta = 2 * dr.pi * sample
+    return mi.Point2f(dr.sin(theta), dr.cos(theta)), Float(1/(2 * dr.pi))
+
+def sample_uniform_boundary(sample, origin, radius):
+    direction, pdf = sample_uniform_direction(sample)
+    sampled_points = origin + radius * direction
+    return sampled_points, pdf / radius
+
+def sample_cosine_direction(sample : Float, direction : mi.Point2f) -> tuple[mi.Point2f, Float, Float]:
+    upper_sphere = sample >= 0.5
+    sample = dr.select(upper_sphere, 2 * sample - 1, 2 * sample)
+    angle_shift = dr.asin(2 * sample - 1)
+    abs_dot_prod = dr.sqrt(1 - dr.square(2 * sample -1))
+    angle_initial = dr.atan2(direction[1], direction[0])
+    angle = angle_initial + angle_shift
+    sampled_direction = mi.Point2f(dr.cos(angle), dr.sin(angle))
+    sign = dr.select(upper_sphere, Float(1), Float(-1))
+    sampled_direction *= sign
+    return sampled_direction, abs_dot_prod / 4, sign
+
+
+def sample_cosine_boundary(sample : Float, origin : mi.Point2f, radius : Float, direction : mi.Point2f) -> tuple[mi.Point2f, Float, Float]:
+    sampled_direction, pdf, sign = sample_cosine_direction(sample, direction)
+    point = origin + radius * sampled_direction
+    return point, pdf / radius, sign
+
+def sample_cosine_boundary_antithetic(sample, origin, radius, direction, active):
+    angle_shift = dr.asin(2 * sample - 1)
+    direction1 = mi.Point2f(dr.sin(angle_shift), dr.cos(angle_shift))
+    direction2 = mi.Point2f(dr.sin(angle_shift), -dr.cos(angle_shift))
+    direction1 = to_world_direction(direction1, direction)
+    direction2 = to_world_direction(direction2, direction)
+    point1 = mi.Point2f(dr.select(active, origin + radius * direction1, origin))
+    point2 = mi.Point2f(dr.select(active, origin + radius * direction2, origin))
+    return point1, point2, dr.cos(angle_shift) / (2 * radius) , 2
+    
+
+def pdf_cosine_boundary_(sampled_direction, R, direction):
+    return 1/4 * dr.abs(dr.dot(dr.normalize(sampled_direction), dr.normalize(direction))) / R
+
+def pdf_cosine_boundary(points, origin, R, direction):
+    d = dr.normalize(points - origin)
+    return pdf_cosine_boundary_(d, R, direction)
+
+def sample_uniform_volume(sample, origin, radius):
+    r =  radius * dr.sqrt(sample[0])
+    theta = 2 * dr.pi * sample[1]
+    return mi.Point2f(origin +  r * mi.Point2f(dr.cos(theta),dr.sin(theta))), dr.rcp(dr.pi * dr.sqr(radius))
+
+
+
+def sample_sec_direction(sample : Float, direction : mi.Point2f, threshold : Float = Float(0.49 * dr.pi)):
+    negative = sample >= 0.5
+    sample = dr.select(negative, 2 * sample - 1, 2 * sample)
+    angle_shift = sample_sec_angle(sample, threshold)
+    angle_shift *= dr.select(negative, -1., 1)
+
+    angle_initial = dr.atan2(direction[1], direction[0])
+    angle = angle_initial + angle_shift
+    sampled_direction = mi.Point2f(dr.cos(angle), dr.sin(angle))
+    return sampled_direction
+
+@dr.syntax
+def pdf_sec_direction(dir : mi.Point2f, direction : mi.Point2f, threshold : Float = Float(0.49 * dr.pi)):
+    pdf = Float(0)
+    sec = dr.rcp(dr.dot(dir, direction))
+    csc_d = dr.rcp(dr.sin(threshold))
+    sec_d = dr.rcp(dr.cos(threshold))
+    normalization = 0.5 * dr.log((1 + csc_d)/(-1 + csc_d)) + (dr.pi/2 - threshold) * sec_d
+
+    if (sec > 0) & (sec < sec_d):
+        pdf = sec
+    elif (sec >= sec_d):
+        pdf = sec_d
+    return pdf / normalization * 0.5
+
+
+@dr.syntax
+def sample_sec_angle(sample : Float, threshold : Float = Float(0.49 * dr.pi)):
+    csc_d = dr.rcp(dr.sin(threshold))
+    sec_d = dr.rcp(dr.cos(threshold))
+
+    th_val = 0.5 * dr.log((1 + csc_d)/(-1 + csc_d))
+    normalization = th_val + (dr.pi/2 - threshold) * sec_d
+    sample *= normalization
+    
+    sampled_p = Float(0)
+    if sample < th_val:
+        exp = dr.exp(2 * sample)
+        sampled_p = dr.asin((exp - 1)/(exp + 1))
+    else:
+        sampled_p = threshold + (sample - th_val) / (normalization - th_val) * (dr.pi / 2 - threshold)
+    return sampled_p
+
+
+@dr.syntax
+def pdf_sec_angle(angle : Float, threshold : Float = Float(0.49 * dr.pi)): # pdf with respect to secant.
+    pdf = Float(0)
+    sec = dr.rcp(dr.cos(angle))
+    csc_d = dr.rcp(dr.sin(threshold))
+    sec_d = dr.rcp(dr.cos(threshold))
+    normalization = 0.5 * dr.log((1 + csc_d)/(-1 + csc_d)) + (dr.pi/2 - threshold) * sec_d
+    if (angle >= 0) & (angle < threshold):
+        pdf = sec
+    elif (angle >= threshold) & (angle <= dr.pi/2):
+        pdf = sec_d
+    return pdf / normalization
+
+@dr.syntax
+def eval_dP_norm(radius : Float, σ : Float) -> Float: 
+    # used in directional derivative
+    sqrtσ = dr.sqrt(σ)
+    z = radius * sqrtσ
+    result = Float(0)
+    if z < 0.001:
+        result = dr.rcp(dr.pi * dr.square(radius))
+    else:
+        result = sqrtσ * dr.rcp(2 * dr.pi * radius * i1(radius * sqrtσ))
+    return result
+
+
+def eval_Pσr_(r, R, sigma, in_mask = Bool(False)): # multiplied with 2 * pi * r version
+    z = R * dr.sqrt(sigma)
+    y  = r / R
+    return dr.select(in_mask, Qσ(y, z), eval_Pσrs_(R, sigma))
+
+def eval_Pσrs_(R, sigma):
+    return dr.rcp(i0(R * dr.sqrt(sigma)))

data/PDE2D/Sampling/special.py

@@ -0,0 +1,346 @@
+import drjit as dr
+import mitsuba as mi
+import numpy as np
+from math import nan,inf
+from mitsuba import Float
+
+use_special_form = True
+#C = 5
+A_i0 = Float([
+    -4.41534164647933937950E-18, 3.33079451882223809783E-17,
+    -2.43127984654795469359E-16, 1.71539128555513303061E-15,
+    -1.16853328779934516808E-14, 7.67618549860493561688E-14,
+    -4.85644678311192946090E-13, 2.95505266312963983461E-12,
+    -1.72682629144155570723E-11, 9.67580903537323691224E-11,
+    -5.18979560163526290666E-10, 2.65982372468238665035E-9,
+    -1.30002500998624804212E-8, 6.04699502254191894932E-8,
+    -2.67079385394061173391E-7, 1.11738753912010371815E-6,
+    -4.41673835845875056359E-6, 1.64484480707288970893E-5,
+    -5.75419501008210370398E-5, 1.88502885095841655729E-4,
+    -5.76375574538582365885E-4, 1.63947561694133579842E-3,
+    -4.32430999505057594430E-3, 1.05464603945949983183E-2,
+    -2.37374148058994688156E-2, 4.93052842396707084878E-2,
+    -9.49010970480476444210E-2, 1.71620901522208775349E-1,
+    -3.04682672343198398683E-1, 6.76795274409476084995E-1])
+
+B_i0 = Float([
+    -7.23318048787475395456E-18, -4.83050448594418207126E-18,
+    4.46562142029675999901E-17, 3.46122286769746109310E-17,
+    -2.82762398051658348494E-16, -3.42548561967721913462E-16,
+    1.77256013305652638360E-15, 3.81168066935262242075E-15,
+    -9.55484669882830764870E-15, -4.15056934728722208663E-14,
+    1.54008621752140982691E-14, 3.85277838274214270114E-13,
+    7.18012445138366623367E-13, -1.79417853150680611778E-12,
+    -1.32158118404477131188E-11, -3.14991652796324136454E-11,
+    1.18891471078464383424E-11, 4.94060238822496958910E-10,
+    3.39623202570838634515E-9, 2.26666899049817806459E-8,
+    2.04891858946906374183E-7, 2.89137052083475648297E-6,
+    6.88975834691682398426E-5, 3.36911647825569408990E-3, 
+    8.04490411014108831608E-1])
+
+A_k0 = Float([
+    1.37446543561352307156E-16, 4.25981614279661018399E-14,
+    1.03496952576338420167E-11, 1.90451637722020886025E-9,
+    2.53479107902614945675E-7, 2.28621210311945178607E-5,
+    1.26461541144692592338E-3, 3.59799365153615016266E-2,
+    3.44289899924628486886E-1, -5.35327393233902768720E-1])
+
+B_k0 = Float([
+    5.30043377268626276149E-18, -1.64758043015242134646E-17,
+    5.21039150503902756861E-17, -1.67823109680541210385E-16,
+    5.51205597852431940784E-16, -1.84859337734377901440E-15,
+    6.34007647740507060557E-15, -2.22751332699166985548E-14,
+    8.03289077536357521100E-14, -2.98009692317273043925E-13,
+    1.14034058820847496303E-12, -4.51459788337394416547E-12,
+    1.85594911495471785253E-11, -7.95748924447710747776E-11,
+    3.57739728140030116597E-10, -1.69753450938905987466E-9,
+    8.57403401741422608519E-9,  -4.66048989768794782956E-8,
+    2.76681363944501510342E-7,  -1.83175552271911948767E-6,
+    1.39498137188764993662E-5,  -1.28495495816278026384E-4,
+    1.56988388573005337491E-3,  -3.14481013119645005427E-2, 
+    2.44030308206595545468E0])
+
+A_i1 = Float([
+    2.77791411276104639959E-18, -2.11142121435816608115E-17,
+    1.55363195773620046921E-16, -1.10559694773538630805E-15,
+    7.60068429473540693410E-15, -5.04218550472791168711E-14,
+    3.22379336594557470981E-13, -1.98397439776494371520E-12,
+    1.17361862988909016308E-11, -6.66348972350202774223E-11,
+    3.62559028155211703701E-10, -1.88724975172282928790E-9,
+    9.38153738649577178388E-9, -4.44505912879632808065E-8,
+    2.00329475355213526229E-7, -8.56872026469545474066E-7,
+    3.47025130813767847674E-6, -1.32731636560394358279E-5,
+    4.78156510755005422638E-5, -1.61760815825896745588E-4,
+    5.12285956168575772895E-4, -1.51357245063125314899E-3,
+    4.15642294431288815669E-3, -1.05640848946261981558E-2,
+    2.47264490306265168283E-2, -5.29459812080949914269E-2,
+    1.02643658689847095384E-1, -1.76416518357834055153E-1,
+    2.52587186443633654823E-1])
+
+B_i1 = Float([
+    7.51729631084210481353E-18, 4.41434832307170791151E-18,
+    -4.65030536848935832153E-17, -3.20952592199342395980E-17,
+    2.96262899764595013876E-16, 3.30820231092092828324E-16
+    -1.88035477551078244854E-15, -3.81440307243700780478E-15,
+    1.04202769841288027642E-14, 4.27244001671195135429E-14,
+    -2.10154184277266431302E-14,-4.08355111109219731823E-13,
+    -7.19855177624590851209E-13,2.03562854414708950722E-12,
+    1.41258074366137813316E-11, 3.25260358301548823856E-11,
+    -1.89749581235054123450E-11, -5.58974346219658380687E-10,
+    -3.83538038596423702205E-9, -2.63146884688951950684E-8,
+    -2.51223623787020892529E-7,-3.88256480887769039346E-6,
+    -1.10588938762623716291E-4, -9.76109749136146840777E-3,
+    7.78576235018280120474E-1])
+
+A_k1 = Float([
+    -7.02386347938628759343E-18, -2.42744985051936593393E-15,
+    -6.66690169419932900609E-13,-1.41148839263352776110E-10,
+    -2.21338763073472585583E-8,-2.43340614156596823496E-6,
+    -1.73028895751305206302E-4,-6.97572385963986435018E-3,
+    -1.22611180822657148235E-1,-3.53155960776544875667E-1,
+    1.52530022733894777053E0])
+
+B_k1 = Float([
+    -5.75674448366501715755E-18,1.79405087314755922667E-17,
+    -5.68946255844285935196E-17,1.83809354436663880070E-16,
+    -6.05704724837331885336E-16,2.03870316562433424052E-15,
+    -7.01983709041831346144E-15,2.47715442448130437068E-14,
+    -8.97670518232499435011E-14,3.34841966607842919884E-13,
+    -1.28917396095102890680E-12,5.13963967348173025100E-12,
+    -2.12996783842756842877E-11,9.21831518760500529508E-11,
+    -4.19035475934189648750E-10,2.01504975519703286596E-9,
+    -1.03457624656780970260E-8,5.74108412545004946722E-8,
+    -3.50196060308781257119E-7,2.40648494783721712015E-6,
+    -1.93619797416608296024E-5,1.95215518471351631108E-4,
+    -2.85781685962277938680E-3,1.03923736576817238437E-1,
+    2.72062619048444266945E0])
+
+""" Implementation of some special functions."""
+
+""" Evaluate Chebyshev polynomial at x/2 argument."""
+@dr.syntax
+def chebyshev(x , coeffs):
+    b0 = Float(coeffs[0])
+    b1 = Float(0) 
+    b2 = Float(0) 
+    i = 0
+    while dr.hint(i < dr.width(coeffs), mode = 'scalar'):
+        b2 = b1
+        b1 = b0
+        b0 = x * b1 - (b2 - coeffs[i])
+        i += 1
+    return (b0 - b2) * 0.5;
+
+@dr.syntax
+def Gσ(y : Float, z : Float) -> Float: # Multiplied with 2*pi version
+    result = Float(0)
+    #if dr.hint(use_special_form, mode = 'scalar'):
+    c_i0_yz_below8 = chebyshev(y * z/2.0 - 2.0, A_i0)
+    c_i0_z_above8 = chebyshev(32.0/z - 2.0, B_i0)
+    i0_div = Float(0)
+    c_i0_yz_above8 = Float(0)
+    c_i0_z_below8 = Float(0)
+    if (y * z > 8):
+        c_i0_yz_above8 = chebyshev(32.0/(y * z) - 2.0, B_i0)
+        i0_div = c_i0_yz_above8/c_i0_z_above8 / dr.sqrt(y)
+    elif (z <= 8):
+        c_i0_z_below8 = chebyshev(z/2.0 - 2.0, A_i0)
+        i0_div =  c_i0_yz_below8/c_i0_z_below8 
+    else:
+        i0_div = c_i0_yz_below8/c_i0_z_above8 / dr.sqrt(z)
+    result = (k0(y * z)  -  k0(z) * i0_div * dr.exp((y-1) * z))
+    #else:
+    #    result = k0(y * z) - k0(z) * i0(y * z) / i0(z)
+
+    valid_region = (y<1) & (y>0)
+    result = dr.select(valid_region, result, 0)
+    return result
+
+@dr.syntax
+def dGσ(y: Float, z: Float) -> Float: # Multiplied with 2*pi version
+    result = Float(0)
+    #if use_special_form:
+    c_i1_yz_below8 = chebyshev(y * z/2.0 - 2.0, A_i1)
+    c_i1_z_above8 = chebyshev(32.0/z - 2.0, B_i1)
+    i1_div = Float(0)
+    c_i1_yz_above8 = Float(0)
+    c_i1_z_below8 = Float(0)
+    if (y * z > 8):
+        c_i1_yz_above8 = chebyshev(32.0/(y * z) - 2.0, B_i1)
+        i1_div = c_i1_yz_above8/c_i1_z_above8  / dr.sqrt(y)
+    elif z <= 8:
+        c_i1_z_below8 = chebyshev(z/2.0 - 2.0, A_i1)
+        i1_div = c_i1_yz_below8/c_i1_z_below8 * y
+    else:
+        i1_div = c_i1_yz_below8/c_i1_z_above8 * y * z * dr.sqrt(z)
+    
+    result = k1(y * z) -  k1(z) * i1_div * dr.exp((y-1) * z)
+    #else:
+    #    result = k1(y * z)  -  k1(z) * i1(y * z) / i1(z)
+
+    valid_region = (y<1) & (y>=0)
+    result = dr.select(valid_region, result, 0)
+    return result
+
+@dr.syntax
+def Gσr_int(y : Float, z : Float) -> Float: # This returns sigma |G|.
+    #if use_special_form:
+    c_i1_yz_below8 = chebyshev(y * z/2.0 - 2.0, A_i1)
+    c_i0_z_above8 = chebyshev(32.0/z - 2.0, B_i0)
+    c_i1_yz_above8 = Float(0)
+    c_i0_z_below8 = Float(0)
+    i_div = Float(0)
+    if y * z > 8:
+        c_i1_yz_above8 = chebyshev(32.0/(y * z) - 2.0, B_i1)
+        i_div = c_i1_yz_above8/c_i0_z_above8 / dr.sqrt(y)
+    elif z <= 8:
+        c_i0_z_below8 = chebyshev(z/2.0 - 2.0, A_i0)
+        i_div = c_i1_yz_below8/c_i0_z_below8 * z * y
+    else:
+        i_div = c_i1_yz_below8/c_i0_z_above8 * z * y * dr.sqrt(z)
+    result = 1 - y * z * (i_div * k0(z) * dr.exp((y-1) * z) + k1(y * z))
+    #else:
+    #    result = 1 - y * z * (k0(z) * i1(y * z) / i0(z) + k1(y * z))
+    return result
+
+def Qσ(y,z):
+    return 1 - Gσr_int(y,z) * dr.square(z)
+
+@dr.syntax
+def i0(x_ : Float) -> Float:
+    x = dr.abs(x_)
+    x = dr.select(x == 0, dr.epsilon(Float), x)
+    if x<=8:
+        result = chebyshev(x/2.0 - 2.0, A_i0)
+    else:
+        result = chebyshev(32.0/x - 2.0, B_i0) / dr.sqrt(x)
+    
+    
+    if x_==0:
+        result =  Float(1)
+    else:
+        result *= dr.exp(x)
+    return result
+
+@dr.syntax
+def k0(x_):
+    x = dr.abs(x_)
+    
+    if x == Float(0):
+        x = Float(dr.epsilon(Float))
+    
+    if x <= 2:
+        result = chebyshev((dr.sqr(x) - 2), A_k0) - dr.log(0.5 * x) * i0(x)
+    else:
+        result = dr.exp(-x) * chebyshev(8.0 / x - 2, B_k0) / dr.sqrt(x)
+    if x_ == 0:
+        result = Float(dr.inf)
+    if x_ < 0:
+        result = Float(dr.nan)
+    return result
+
+@dr.syntax
+def i1(x_):
+    x = dr.abs(x_)
+    if x == 0:
+        x += dr.epsilon(Float)
+
+    if x<=8:
+        result = chebyshev(x/2.0 - 2.0, A_i1) * x
+    else:
+        result = chebyshev(32.0 / x - 2.0, B_i1) / dr.sqrt(x)
+    
+    if x_ == 0:
+        result = Float(0)
+    if x_ < 0:
+        result = -result
+    return result  * dr.exp(x)
+
+@dr.syntax
+def k1(x_):
+    x = dr.abs(x_)
+    
+    if x == 0:
+        x += dr.epsilon(Float)
+
+    if x <= 2:
+        result = dr.log(x * 0.5) * i1(x) + chebyshev(dr.sqr(x) - 2.0, A_k1) / x
+    else:
+        result = dr.exp(-x) * chebyshev(8.0 / x -2, B_k1) / dr.sqrt(x)
+    if x_ == 0:
+        result = Float(dr.inf)
+    if x_ < 0:
+        result = Float(dr.nan)
+    return result
+
+
+## Remove the exponential terms
+
+# divided by exp(x)
+@dr.syntax
+def i0_(x_):
+    x = dr.abs(x_)
+    x = dr.select(x == 0, dr.epsilon(Float), x)
+    if x<=8:
+        result = chebyshev(x/2.0 - 2.0, A_i0)
+    else:
+        result = chebyshev(32.0/x - 2.0, B_i0) / dr.sqrt(x)
+    
+    if x_==0:
+        result = Float(1)
+    return result
+
+# multiplied by exp(x)
+@dr.syntax
+def k0_(x_):
+    x = dr.abs(x_)
+    if x == 0:
+        x += dr.epsilon(Float)
+    if x <= 2:
+        result = dr.exp(x) (chebyshev((dr.sqr(x) - 2), A_k0) - dr.log(0.5 * x) * i0(x))
+    else:
+        result =  chebyshev(8.0 / x - 2, B_k0) / dr.sqrt(x),
+    if x_ == 0:
+        result = Float(dr.inf)
+    if x_ < 0:
+        result = Float(dr.nan)
+    return result
+
+# divided by exp(x)
+@dr.syntax
+def i1_(x_):
+    x = dr.abs(x_)
+    if x == 0:
+        x += dr.epsilon(Float)
+
+    if x<=8:
+        result = chebyshev(x/2.0 - 2.0, A_i1) * x
+    else:
+        result = chebyshev(32.0 / x - 2.0, B_i1) / dr.sqrt(x)
+    
+    if x_ == 0:
+        result = Float(0)
+    if x_ < 0:
+        result = -result
+    return result 
+
+# multiplied by exp(x)
+@dr.syntax
+def k1_(x_):
+    x = dr.abs(x_)
+    
+    if x == 0:
+        x += dr.epsilon(Float)
+
+    if x <= 2:
+        result = dr.exp(x) * (dr.log(x * 0.5) * i1(x) + chebyshev(dr.sqr(x) - 2.0, A_k1) / x)
+    else:
+        result =  chebyshev(8.0 / x -2, B_k1) / dr.sqrt(x)
+    if x_ == 0:
+        result = Float(inf)
+    if x_ < 0:
+        result = Float(nan)
+    return result
+
+
+    

data/PDE2D/Solver/__init__.py

@@ -0,0 +1,7 @@
+from .data_holder import DataHolder, RegularizationType
+from .constant.wos_constant import WosConstant
+from .constant.wost_constant import WostConstant
+from .constant.wos_constant_rejection import WosConstantRejection
+from .variable.wos_variable import WosVariable
+from .variable.wost_variable import WostVariable
+from .variable.wos_variable_rejection import WosVariableRejection

data/PDE2D/Solver/constant/wos_constant.py

@@ -0,0 +1,240 @@
+import numpy as np
+import sys
+import mitsuba as mi
+from mitsuba import Bool, Float, Point2f, PCG32, UInt64, UInt32
+from PDE2D import GreenSampling, DIM, ArrayXb, ArrayXf
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from PDE2D.BoundaryShape import *
+
+
+class Particle:
+    DRJIT_STRUCT = {
+        'points' : Point2f,
+        'w': Float,
+        'sampler' : PCG32,
+        'path_index' : UInt32,
+        'path_length' : UInt32,
+        'thrown' : Bool
+    }
+    def __init__(self, points=None, w=None, sampler = None, path_index = None, path_length = None):
+        self.points = points
+        self.w = w
+        self.sampler = sampler
+        self.path_index = path_index
+        self.path_length = path_length
+        self.thrown = dr.zeros(Bool, dr.width(self.points))
+
+
+class WosConstant(object):
+    def __init__(self, input : DataHolder, seed : int = 37, 
+                 max_z : float = 4, green_sampling : GreenSampling = 0, 
+                 newton_steps : int = 5, opt_params : list[str] = []) -> None:
+        self.input = input
+        if(type(self.input.α) is not ConstantCoefficient):
+            raise Exception("Diffusion parameter needs to be constant coefficient!")
+        if(type(self.input.σ) is not ConstantCoefficient):
+            raise Exception("Screening parameter needs to be constant coefficient!")
+        self.σ = Float(self.input.σ.get_value(Point2f(0)) / self.input.α.get_value(Point2f(0)))
+        self.seed = UInt64(seed)
+        dr.make_opaque(self.seed)
+        self.input = input
+        self.max_z = Float(max_z)
+        dr.make_opaque(self.max_z)
+        self.opt_params = {}
+        self.get_opt_params(self.opt_params, opt_params)
+
+        if green_sampling == GreenSampling.Polynomial:
+            self.green = GreensFunctionPolynomial(dim = DIM.Two, newton_steps = newton_steps)
+        else:
+            self.green = GreensFunctionAnalytic(dim = DIM.Two, newton_steps = newton_steps)
+
+    def change_seed(self, seed : int):
+        self.seed = dr.opaque(UInt64, seed, shape = (1))
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.input.get_opt_params(param_dict, opt_params)
+
+    def update(self, opt):
+        self.input.update(opt)
+        self.σ = Float(self.input.σ.get_value(Point2f(0)) / self.input.α.get_value(Point2f(0)))
+        self.input.shape.update_shape(opt)
+    
+    def zero_grad(self):
+        self.input.zero_grad()
+        
+    @dr.syntax(print_code = False)
+    def solve(self, points_in = None, active_conf_in : ArrayXb = None, L_in : ArrayXf = None, initial_w : Float = Float(1), 
+              mode : dr.ADMode = dr.ADMode.Primal, dL = ArrayXf(0), 
+              derivative_dir : Point2f = None, conf_numbers : list[UInt32] = [UInt32(0)], all_inside = False, 
+              max_step = dr.inf, normal_derivative_dist : float = None) -> list[Float, Particle]:
+        
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        
+        L_res = dr.zeros(ArrayXf, (num_conf, dr.width(points_in))) if (mode != dr.ADMode.Backward) else L_in
+
+        active_conf = dr.ones(ArrayXb, shape = L_res.shape) if active_conf_in is None else ArrayXb(active_conf_in)
+        assert L_res.shape == active_conf.shape
+
+        if (L_in is None) and (mode is dr.ADMode.Backward):
+            raise Exception("The primal solution needs to be specified in the backward gradient computation!")
+
+        if mode == dr.ADMode.Forward:
+            dL = ArrayXf(0)
+        
+        active = Bool(True)
+        if dr.hint(self.input.shape.single_closed and not all_inside, mode = "scalar"):
+            active, L_res = self.input.shape.inside_closed_surface(points_in, L_res, conf_numbers)
+        
+        particle = Particle(Point2f(points_in), Float(initial_w), PCG32(), dr.arange(UInt32, dr.width(points_in)), UInt32(0))
+        
+        initstate, initseq = tea(UInt64(particle.path_index), UInt64(self.seed))
+        particle.sampler.seed(initstate=UInt64(initstate), initseq=UInt64(initseq))
+
+        with dr.suspend_grad():
+            if dr.hint(derivative_dir is not None, mode = "scalar"):
+                particle = self.take_derivative_step(derivative_dir, L_res, particle, mode, dL, active, active_conf)
+            while active:
+                particle = self.take_step(L_res, particle, mode, dL, active, active_conf,
+                                          normal_derivative_dist, conf_numbers) 
+                active &= particle.path_length < max_step
+        return (dL, particle) if mode == dr.ADMode.Forward else (L_res, particle)
+    
+    @dr.syntax(print_code = False)
+    def take_step(self, L : Float, p : Particle, mode : dr.ADMode, dL : Float, active : Bool, active_conf : ArrayXb, 
+                  normal_derivative_dist : float, conf_numbers : list[UInt32] = None):
+        primal = (mode == dr.ADMode.Primal)
+
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+        z = bi.r * dr.sqrt(self.σ)
+        if z > self.max_z:
+            bi.r *= self.max_z / z
+            z = self.max_z
+        
+        self.green.initialize(z)
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+        
+        # Add the dirichlet boundary contribution in epsilon-shell!
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)
+        
+        # Add the result
+        L += added_near if dr.hint(primal, mode = 'scalar') else -added_near
+        
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+
+        
+        p.thrown |= bi.is_far
+        active &= ~bi.is_far
+    
+        # Volume Contribution
+        # Source Sampling (self.σ is detached! It is used for pdf calculations.)
+        
+        normG = Float(0)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            r, normG = self.green.sample(p.sampler.next_float32(), bi.r, self.σ)
+            dir_vol, _ = sample_uniform_direction(p.sampler.next_float32())
+            points_vol = p.points + r * dir_vol 
+
+            with dr.resume_grad(when=not primal):
+                α_vol = self.input.α.get_value(points_vol)
+                f_vol = self.input.f.get_value(points_vol) / α_vol
+                f_cont = dr.select(active, p.w * f_vol * normG, 0)
+                #if dr.isnan(f_cont):
+                #    f_cont = Float(0)
+                
+                if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                    dr.backward(dr.sum(f_cont * dL))
+                elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                    dL += dr.forward_to(dr.sum(f_cont))
+
+            L += f_cont if primal else -f_cont
+        else:
+            normG = self.green.eval_norm(bi.r, self.σ)
+
+        # Boundary Sampling
+        p.points, _ = sample_uniform_boundary(p.sampler.next_float32(), p.points, bi.r)   
+        
+        # Poisson Kernel computation
+        P = (1 - normG * self.σ) 
+        p.w *= P   
+        p.path_length += 1
+
+        # Boundary and Volume Contribution
+        return p
+    
+    @dr.syntax
+    def take_derivative_step(self, derivative_dir : Point2f, L : Float, p : Particle, mode : dr.ADMode, dL : Float, 
+                             active : Bool, active_conf : ArrayXb) -> Particle:
+        
+        primal = (mode == dr.ADMode.Primal)
+        # There is no way to sample Green's function analytically. Use polynomial.
+        greenGrad = GreensFunctionPolynomial(dim = DIM.Two, newton_steps=10, grad = True)
+        
+        # Create boundary interaction.
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False)
+        # We just create spheres.
+        bi.r = bi.d
+        # Decrease radius for max_z.
+        z = bi.r * dr.sqrt(self.σ)
+        if z > self.max_z:
+            bi.r *= self.max_z / z
+            z = self.max_z
+
+        greenGrad.initialize(z)
+        # Remove the channels in which the walk is finished. 
+        active &= ~(bi.is_d & bi.is_e)
+
+        # Get the contribution of the source term
+        f_cont = Float(0)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            # Sample norm of the Gradient with the Greens function.
+            r, norm_dG = greenGrad.sample(p.sampler.next_float32(), bi.r, self.σ)
+            dir_vol, _, sign_vol = sample_cosine_direction(p.sampler.next_float32(), derivative_dir)
+            points_vol = p.points + r * dir_vol 
+            α_vol = self.input.α.get_value(points_vol)
+            
+            with dr.resume_grad(when=not primal):
+                f_vol = self.input.f.get_value(points_vol) / α_vol
+                f_cont = dr.select(active, f_vol * norm_dG * sign_vol * 2 / dr.pi , 0.0)
+                #if dr.isnan(f_cont):
+                #    f_cont = Float(0)
+                if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                    dr.backward(f_cont * dL)
+                elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                    dL += dr.forward_to(f_cont)
+        
+            f_cont = dr.select(active_conf, f_cont, 0)
+
+        L += f_cont if primal else -f_cont
+        
+        p.points, _, boundary_sign = sample_cosine_boundary(p.sampler.next_float32(), p.points, bi.r, derivative_dir)
+
+        p.w *= eval_dP_norm(bi.r, self.σ) * 4 * bi.r * boundary_sign
+        p.path_length += 1
+        
+        return p
+    
+
+    def create_normal_derivative(self, res : int, spp : int, distance : float, conf_numbers : list[UInt32]):
+        shape = self.input.shape
+        assert isinstance(shape, BoundaryWithDirichlets)
+        assert len(shape.in_boundaries) == 1
+        in_shape = shape.in_boundaries[0]
+
+        points_, s_points, normal_dir = in_shape.create_boundary_points(distance = dr.epsilon(mi.Float) * 20, res = res, spp = spp, discrete_points = True)
+        bi = BoundaryInfo(points_)
+        ri = shape.ray_intersect(bi, dr.normalize(normal_dir))
+
+        distance = dr.minimum(distance, 0.3 * ri.t)
+        points = points_ + distance * dr.normalize(normal_dir)
+        normal_der, _ = self.solve(points, derivative_dir=normal_dir, conf_numbers=conf_numbers, all_inside = True)
+        _, result_mi = in_shape.create_boundary_result(normal_der, s_points, res)
+        dr.eval(result_mi)
+        normal_der = in_shape.set_normal_derivative(result_mi)
+        return result_mi, normal_der
+            

data/PDE2D/Solver/constant/wos_constant_rejection.py

@@ -0,0 +1,116 @@
+import numpy as np
+import sys
+import mitsuba as mi 
+from mitsuba import Bool, Float, Point2f, UInt32
+from PDE2D import  GreenSampling, ArrayXb
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from PDE2D.BoundaryShape import *
+from .wos_constant import WosConstant
+class Particle:
+    DRJIT_STRUCT = {
+        'points' : Point2f,
+        'w': Float,
+        'sampler' : PCG32,
+        'path_index' : UInt32,
+        'path_length' : UInt32,
+        'thrown' : Bool
+    }
+    def __init__(self, points=None, w=None, sampler = None, path_index = None, path_length = None):
+        self.points = points
+        self.w = w
+        self.sampler = sampler
+        self.path_index = path_index
+        self.path_length = path_length
+        self.thrown = dr.zeros(Bool, dr.width(self.points))
+
+
+class WosConstantRejection(WosConstant):
+    def __init__(self, input : DataHolder, seed : int = 37, 
+                 max_z : float = 4, green_sampling : GreenSampling = 0, 
+                 newton_steps : int = 5, opt_params : list[str] = []) -> None:
+        super().__init__(input, seed, max_z, green_sampling, newton_steps, opt_params)
+    
+    @dr.syntax(print_code = False)
+    def take_step(self, L : Float, p : Particle, mode : dr.ADMode, dL : Float, active : Bool, active_conf : ArrayXb, 
+                  normal_derivative_dist : float, conf_numbers : list[UInt32] = None):
+        primal = (mode == dr.ADMode.Primal)
+
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+        z = bi.r * dr.sqrt(self.σ)
+        if z > self.max_z:
+            bi.r *= self.max_z / z
+            z = self.max_z
+        
+        self.green.initialize(z)
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+        
+        # Add the dirichlet boundary contribution in epsilon-shell!
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)
+        
+        # Add the result
+        L += added_near if dr.hint(primal, mode = 'scalar') else -added_near
+        
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+
+        
+        p.thrown |= bi.is_far
+        active &= ~bi.is_far
+    
+        # Volume Contribution
+        # Source Sampling (self.σ is detached! It is used for pdf calculations.)
+        
+        normG = Float(0)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            #r, normG = self.green.sample(p.sampler.next_float32(), bi.r, self.σ)
+            r, normG = self.sampleGreenRejection(p, bi.r, self.σ)
+            dir_vol, _ = sample_uniform_direction(p.sampler.next_float32())
+            points_vol = p.points + r * dir_vol 
+
+            with dr.resume_grad(when=not primal):
+                α_vol = self.input.α.get_value(points_vol)
+                f_vol = self.input.f.get_value(points_vol) / α_vol
+                f_cont = dr.select(active, p.w * f_vol * normG, 0)
+                #if dr.isnan(f_cont):
+                #    f_cont = Float(0)
+                
+                if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                    dr.backward(dr.sum(f_cont * dL))
+                elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                    dL += dr.forward_to(dr.sum(f_cont))
+
+            L += f_cont if primal else -f_cont
+        else:
+            normG = self.green.eval_norm(bi.r, self.σ)
+
+        # Boundary Sampling
+        p.points, _ = sample_uniform_boundary(p.sampler.next_float32(), p.points, bi.r)   
+        
+        # Poisson Kernel computation
+        P = (1 - normG * self.σ) 
+        p.w *= P   
+        p.path_length += 1
+
+        # Boundary and Volume Contribution
+        return p
+    
+    
+    @dr.syntax
+    def sampleGreenRejection(self, p : Particle, R : Float, σ : Float):
+        # We apply rejection sampling based on WosVariable paper.
+        if R <= σ:
+            upper_bound = dr.maximum(2.2 * dr.maximum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.maximum(dr.sqrt(R), dr.sqrt(σ)))
+        else:
+            upper_bound = dr.maximum(2.2 * dr.minimum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.minimum(dr.sqrt(R), dr.sqrt(σ)))
+
+        sample1 = p.sampler.next_float32() * R
+        sample2 = p.sampler.next_float32() 
+        pdf = self.green.eval_pdf_only(sample1, R, σ)
+        while(sample2 * upper_bound > pdf):
+            sample1 = p.sampler.next_float32() * R
+            sample2 = p.sampler.next_float32()
+            pdf = self.green.eval_pdf_only(sample1, R, σ)
+        return sample1, self.green.eval_norm(R, σ)
+            

data/PDE2D/Solver/constant/wost_constant.py

@@ -0,0 +1,190 @@
+import numpy as np
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from ...BoundaryShape.interaction import BoundaryInfo
+from .wos_constant import *
+
+
+class WostConstant(WosConstant):
+    def __init__(self, input : DataHolder, seed : int = 37, 
+                 max_z : float = 4, green_sampling : GreenSampling = 0, newton_steps : int = 5, opt_params : list[str] = []) -> None:
+        super().__init__(input, seed, max_z, green_sampling, newton_steps, opt_params)
+    
+    @dr.syntax(print_code = False)
+    def take_step(self, L : ArrayXf, p : Particle, mode : dr.ADMode, dL : ArrayXf, active : Bool, 
+                  active_conf : ArrayXb, normal_derivative_dist : float = None, conf_numbers : list[UInt32] = None) -> Particle:
+        
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        
+        primal = (mode == dr.ADMode.Primal)
+        
+        # Apply boundary interaction.
+        with dr.resume_grad(when = (not primal) & (normal_derivative_dist is not None)):
+            bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+        
+        # Decrease radius to sample from a reasonable Green's function.
+        z = bi.r * dr.sqrt(self.σ)
+        if z > self.max_z:
+            bi.r *= self.max_z / z
+            z = self.max_z
+
+        self.green.initialize(z)
+        # Generate stars.
+        bi = self.input.shape.star_generation(bi)
+
+        # End the paths if we are in the epsilon shell of a dirichlet boundary.
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+
+        # Final contribution
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0.0)
+        #added_near = Float(0)
+        # Accumulate the throughput to the corresponding shape. (Only done if multiple shapes is defined.)
+        #dirichlet_grad = Float(0)
+        if dr.hint(primal, mode = 'scalar'):
+            L += added_near
+        else:
+            L -= added_near
+            # This part is for computing the derivative for discrete EIT experiments. Only 
+            # single shape optimization is supported.
+            if dr.hint((normal_derivative_dist is not None), mode = 'scalar'):
+                assert isinstance(self.input.shape, BoundaryWithDirichlets)
+                assert len(self.input.shape.in_boundaries) == 1
+                
+                jacobian = self.input.shape.get_jacobian_factor(bi, normal_derivative_dist)
+                with dr.resume_grad(when = not primal): # This is for optimizing the shape of the dirichlet boundaries. 
+                    normalder = dr.select(dirichlet_ending & active_conf,
+                                            p.w * self.input.shape.get_normal_derivative(dr.detach(bi.bpoint)),
+                                            0)    
+                    #dirichlet_grad = bi.d 
+                    distance_correction = self.input.shape.in_boundaries[0].get_distance_correction(p.points)
+                    bi2 = self.input.shape.in_boundaries[0].boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+                    dirichlet_grad = dr.select(dirichlet_ending, bi2.d * jacobian * normalder / distance_correction, 0)
+                    #dr.backward(dirichlet_grad * dL)
+
+        
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+        
+        active &= ~bi.is_far
+        p.thrown |= bi.is_far
+        
+        # Source Contribution
+        # Source Sampling (self.σ is detached! It is used for pdf calculations.)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            r_vol, normG = self.green.sample(p.sampler.next_float32(), bi.r, self.σ)
+            dir_vol, _ = sample_star_direction(p.sampler.next_float32(), bi.on_boundary & bi.is_star, bi.bn)
+            points_vol = mi.Point2f(p.points + r_vol * dir_vol)
+            
+            # If we are on a star, The sampled point might be outside of the boundary.
+            # We need to check this with a ray intersection.
+            ri_f = self.input.shape.ray_intersect(bi, dir_vol)
+
+            with dr.resume_grad(when=not primal):
+                α_vol = self.input.α.get_value(points_vol)
+                f_vol = self.input.f.get_value(points_vol) / α_vol
+                f_cont = dr.select(active & (r_vol <= ri_f.t), p.w * f_vol * normG, 0)
+                if dr.isnan(f_cont):
+                    f_cont = Float(0)
+                f_cont = dr.select(active_conf, f_cont, 0)
+            L += f_cont if primal else -f_cont
+
+        # Now compute the Neumann Contribution. (NEE Contribution.)
+        # If we have a continous Neumann on the boundary, we need to sample it.
+        n_cont_cont = dr.zeros(ArrayXf, shape = L.shape)
+        
+        if dr.hint(self.input.has_continuous_neumann, mode = 'scalar'):
+            # If we have a special sampling scheme then we need to sample for each configuration.
+            
+            if dr.hint(self.input.NEE == NEE.Special, mode = 'scalar'):
+                for i in range(num_conf):
+                    conf_number = None if conf_numbers is None else conf_numbers[i]
+                    # Here n_val is a Float.
+                    dist_n, n_val, pdf_n_r, _ = self.input.sampleNEE_special(bi, p.sampler.next_float32(), conf_number)
+                    G_n_r = self.green.eval(dist_n, bi.r, self.σ)
+                    if ((pdf_n_r > 0) & (dist_n < bi.r) & (dist_n > 0)):
+                        n_cont_cont[i] =  -p.w * n_val * G_n_r / pdf_n_r
+                    if dr.isnan(n_cont_cont[i]):
+                        n_cont_cont[i] = Float(0)
+            else: # If not then, we only call the sample function once. The neumann values will be different.
+                # Here n_val is an ArrayXf.
+                dist_n, n_val, pdf_n_r, _ = self.input.sampleNEE(bi, p.sampler.next_float32(), conf_numbers)
+                G_n_r = self.green.eval(dist_n, bi.r, self.σ)
+                
+                n_cont_cont_ = Float(0)
+                if ((pdf_n_r > 0) & (dist_n < bi.r) & (dist_n > 0)):
+                    n_cont_cont_ = -p.w * G_n_r / pdf_n_r
+                
+                if dr.isnan(n_cont_cont_):
+                    n_cont_cont_ = Float(0)
+                n_cont_cont = n_val * n_cont_cont_
+
+
+                
+        # Now, we get the all necessary delta distributions on the boundary (a.k.a. point current injections).
+        n_cont_delta = dr.zeros(ArrayXf, shape = L.shape)
+        if dr.hint(self.input.has_delta, mode = 'scalar'):
+            for i in range(num_conf):
+                conf_number = None if conf_numbers is None else conf_numbers[i]
+                dist_n, n_val, pdf_n_r, _ = self.input.get_point_neumann(bi, conf_number)
+                # We can have multiple relevant electrodes, add all the contribution.
+                for d, n, pdf_r in zip(dist_n, n_val, pdf_n_r):
+                    G_n_r = self.green.eval(d, bi.r, self.σ)
+                    if pdf_r > 0:
+                        n_cont_delta[i] += -p.w * n * G_n_r / pdf_r
+                if dr.isnan(n_cont_delta[i]):
+                    n_cont_delta[i] = Float(0)
+        # Compute the total neumann contribution, we need to multiply by two if we are on the boundary. (Check WoSt paper.)
+        
+        n_cont = n_cont_cont + n_cont_delta 
+        if bi.on_boundary:
+            n_cont *= 2
+
+        n_cont = dr.select(active_conf, n_cont, 0)
+
+        # One last step is to correct neumann value if the given Neumann is a current value.
+        if self.input.shape.measured_current:
+            with dr.resume_grad(when = not primal):
+                n_cont /= self.input.α.get_value(Point2f(0)) # Constant Conductance
+
+        L += n_cont if primal else -n_cont
+
+        # Now, we can accumulate the gradients as all necessary info is collected.
+        with dr.resume_grad(when = not primal):
+            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+        #        dr.backward(dr.sum((f_cont + n_cont + dirichlet_grad) * dL))
+                dr.backward(dirichlet_grad * dL)
+            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+        #        dL += dr.forward_to(dr.sum(f_cont + n_cont + dirichlet_grad))
+                dL += dr.forward_to(dr.sum(dirichlet_grad))
+
+        # Recursive step
+        # Sample direction to get the next point.
+        dir_next, sphere_p, _ = bi.sample_recursive(p.sampler.next_float32())
+        # Check if we hit to the boundary before sphere.
+        ri = self.input.shape.ray_intersect(bi, dir_next)
+        on_boundary_next = bi.is_star & (ri.t < bi.r)
+        next_points = dr.select(bi.is_star & on_boundary_next, ri.intersected, sphere_p)
+        distance_rec = dr.select(on_boundary_next & bi.is_star, ri.t, bi.r)
+
+        first_mask = ~self.input.shape.inside_closed_surface_mask(next_points)
+        if first_mask:
+            p.bad_mask = Bool(True)
+            p.on_boundary1 = Bool(bi.on_boundary)
+            p.on_boundary2 = Bool(on_boundary_next)
+            p.loc1 = Point2f(p.points)
+            p.loc2 = Point2f(next_points)
+            p.intersected = Point2f(ri.intersected)
+            p.direction = Point2f(dir_next)
+            p.dist = Float(ri.t)
+            p.boundary_normal = Point2f(bi.bn)
+             
+        # Poisson Kernel computation  
+        p.points = Point2f(next_points)
+        p.w *= self.green.eval_poisson_kernel(distance_rec, bi.r, self.σ)
+        p.path_length += 1
+
+        return p

data/PDE2D/Solver/data_holder.py

@@ -0,0 +1,643 @@
+import drjit as dr
+import mitsuba as mi
+import numpy as np
+from PDE2D.Coefficient import *
+from PDE2D.BoundaryShape import *
+from PDE2D.utils import *
+from PDE2D.Sampling import *
+from mitsuba import Float, Point2f, TensorXf, Texture2f,Bool, UInt
+from PDE2D import  DIM
+from enum import IntEnum
+
+class RegularizationType(IntEnum):
+    none = 0,
+    L2 = 1,
+    tensorL2 = 2,
+    L1 = 3,
+    tensorL1 = 4,
+    TV = 5,
+    gradL1 = 6,
+    gradL2 = 7,
+    screeningL1 = 8,
+    screeningL2 = 9
+
+
+class DataHolder(object):
+    def __init__(self, shape: Shape = Shape(), bbox_center: list = [0,0],
+                 bbox_length = 2.1, max_window_grid = 8, 
+                 max_mipmap_res = 1024, min_mipmap_res = 1,
+                 max_z = 4, dist_texture_res = 512,
+                 α : Coefficient = ConstantCoefficient("diffusion", 1), 
+                 σ : Coefficient = ConstantCoefficient("screening", 0), 
+                 f : Coefficient = ConstantCoefficient("source", 0), 
+                 α_split : Coefficient = None,
+                 σ_split : Coefficient = None, 
+                 opt_param_shape: list = [], opt_param_α: list = [], 
+                 opt_param_σ: list = [], opt_param_f: list = [], 
+                 majorant_safety_low: float = 1.02, 
+                 majorant_safety_high : float = 1.02,
+                 default_majorant : float = None, 
+                 verbose = False):
+        self.shape = shape
+        self.bbox_center = Point2f(bbox_center)
+        self.bbox_length = Float(bbox_length)
+        self.bbox = [[bbox_center[0] - bbox_length/2, bbox_center[1] - bbox_length/2],
+                     [bbox_center[0] + bbox_length/2, bbox_center[1] + bbox_length/2]]
+        self.max_mipmap_res = max_mipmap_res
+        self.min_mipmap_res = min_mipmap_res
+        self.max_window_grid = UInt32(max_window_grid)
+        self.max_radius = bbox_length / min_mipmap_res * (max_window_grid - 1)
+        self.verbose = verbose
+        self.α = α
+        self.σ = σ
+        self.f = f
+        # These are defined for fd computations.
+        # When we deviate the coefficients, path splitting weights change 
+        # We want fd forward computations to follow the same exact path.
+        self.α_split = α_split if (α_split is not None) else α
+        self.σ_split = σ_split if (σ_split is not None) else σ
+        self.params_shape = opt_param_shape
+        self.params_f = opt_param_f
+        self.params_σ = opt_param_σ
+        self.params_α = opt_param_α
+        self.majorant_safety_high = majorant_safety_high
+        self.majorant_safety_low = majorant_safety_low
+        self.default_majorant = default_majorant
+        self.has_continuous_neumann = self.shape.has_continuous_neumann
+        self.has_delta = self.shape.has_delta
+        self.NEE = self.shape.NEE
+        self.Rscale = [Float(0), self.shape.max_distance]
+        self.σscale = [Float(0.01), Float(10000)]
+        self.meanfree_res = [256, 256] 
+        self.dist_tex_res = dist_texture_res
+        self.max_z = Float(max_z)
+        self.effective_σ = self.calculate_effective_screening(res = self.max_mipmap_res)
+        # We are multiplying the negative part with a safety factor as it might increase the througput too much.
+        self.majorant = dr.maximum(self.effective_σ * self.majorant_safety_high, -self.effective_σ * self.majorant_safety_low) 
+        self.σ_bar =dr.max(self.majorant.array) if self.default_majorant is None else Float(self.default_majorant)
+        self.σ_bar = dr.maximum(1e-3, self.σ_bar)
+        #self.create_opt_parameters()
+            
+    def σ_(self, σ, α, grad_α, laplacian_α):   # Equation 21 (2nd paper)
+        return σ / α + 1/2 * (laplacian_α / α - dr.squared_norm(grad_α)/(2 * (α ** 2)))
+            
+    #def create_opt_parameters(self):
+    #    self.opt_params = {}
+    #    self.shape.get_opt_params(self.opt_params, self.params_shape)
+    #    self.α.get_opt_params(self.opt_params, self.params_α)
+    #    self.σ.get_opt_params(self.opt_params, self.params_σ)
+    #    self.f.get_opt_params(self.opt_params, self.params_f)
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.shape.get_opt_params_shape(param_dict, opt_params)
+        self.α.get_opt_params(param_dict, opt_params)
+        self.σ.get_opt_params(param_dict, opt_params)
+        self.f.get_opt_params(param_dict, opt_params)
+
+    def update(self, opt):
+        self.shape.update(opt)
+        self.f.update(opt)
+        self.σ.update(opt)
+        self.α.update(opt)
+        self.α_split = self.α
+        self.σ_split = self.σ
+        #self.create_accelaration()
+                
+    def create_accelaration(self):
+        self.effective_σ = self.calculate_effective_screening(res = self.max_mipmap_res)
+        self.majorant = dr.maximum(self.effective_σ * self.majorant_safety_high, -self.effective_σ * self.majorant_safety_low) 
+        self.σ_bar =dr.max(self.majorant.array) if self.default_majorant is None else self.default_majorant
+        self.σ_bar = dr.maximum(1e-3, self.σ_bar)
+        self.majorant = (dr.maximum(1e-3, self.majorant))
+        self.majorant_tex = TextureCoefficient("effective_screening", self.bbox, self.majorant.numpy(), interpolation = "linear")
+        self.σ_mipmap = self.create_mipmap(self.majorant, min_res = self.min_mipmap_res, type = "max") 
+
+        self.meanfree_tex = self.get_mean_free_image()
+        self.r_best_tex, self.σ_best_tex, self.σ_begin_tex = self.get_Rσ_domain(res = self.dist_tex_res, n_bisection=5, n_grid_search=10)
+
+    def get_mean_free_image(self, spp = 2**8, resolution = [256, 256]):
+        R = self.Rscale[0] + (self.Rscale[1] - self.Rscale[0]) * dr.arange(Float, resolution[0]) / (resolution[0] - 1) 
+        σ = self.σscale[0] * 2 ** (dr.arange(Float, resolution[1]) / (resolution[1] - 1) * dr.log2(self.σscale[1] / self.σscale[0]))
+        RR, σσ = dr.meshgrid(R, σ, indexing = 'ij')
+        RR = dr.repeat(RR, spp)
+        σσ = dr.repeat(σσ, spp)
+        
+        z = Float(RR * dr.sqrt(σσ))
+        sample = dr.arange(Float, spp) / spp + 1/(2 * spp)
+        sample = dr.tile(sample, (resolution[0]) * resolution[1]) 
+        green = GreensFunctionAnalytic(dim = DIM.Two, newton_steps = 8, grad = False)
+        r, normG = green.sample(sample, RR, σσ)
+        prob_boundary = 1 - σσ * normG
+        result = r * (1-prob_boundary) + RR * prob_boundary
+        result = dr.select(RR == 0, 0, result)
+        result = TensorXf(dr.block_sum(result, spp) / spp)
+        result = dr.reshape(TensorXf, result, shape = [resolution[0], resolution[1], 1])
+        result_tex = Texture2f(result)
+        return result_tex
+    
+    def get_mean_free_path(self, R, σ):
+        Rgrid = 1 / self.meanfree_res[0]
+        σgrid = 1 / self.meanfree_res[1]
+        ind_R =  Rgrid / 2 + (R - self.Rscale[0]) / (self.Rscale[1] - self.Rscale[0]) * (1.0-Rgrid) 
+        ind_σ = σgrid/2 + dr.log2(σ / self.σscale[0]) / dr.log2(self.σscale[1] / self.σscale[0]) * (1.0 - σgrid)
+        return self.meanfree_tex.eval(Point2f(ind_σ, ind_R))[0]
+        
+    def calculate_effective_screening(self, res = 1024):
+        with dr.suspend_grad():
+            resolution  = [res, res]
+            points = create_image_points(self.bbox, resolution, 1,  centered = True)
+            active = Bool(True)
+            if (self.shape.single_closed):
+                active = self.shape.inside_closed_surface_mask(points)
+            # Calculate the textures
+            α_vals = self.α_split.get_value(points)
+            grad_α, laplacian_α = self.α_split.get_grad_laplacian(points)
+            σ_vals = self.σ_split.get_value(points)
+            # Equation 21 (2nd paper)
+            σ_new = self.σ_(σ_vals, α_vals, grad_α, laplacian_α)
+            # Eliminate the calculations outside the boundary (if the given shape 
+            # is single closed boundary)
+            σ_new = dr.select(active, σ_new, 0)
+            numpy_σ, tensor_σ  = create_image_from_result(σ_new, resolution)
+            self.eff_screening_tex = TextureCoefficient("effective_screening", self.bbox, numpy_σ[0], interpolation = "linear")
+            return tensor_σ[0]
+            
+    def create_mipmap(self, tensor, min_res, type = "max"):
+        # Now create the mipmap hierarchy
+        res = tensor.shape[0]
+        num_iter = int(dr.floor(dr.log2(res // min_res)))
+        n = res * res
+        array = dr.zeros(Float, n * (num_iter + 1))
+        current_res = res
+        current_array = Float(tensor.array)
+        dr.eval(current_array)
+        dr.scatter(array, current_array, dr.arange(UInt, n))
+
+        for k in range(num_iter):
+            current_res //= 2
+            i = dr.arange(UInt, current_res) * 2
+            j = dr.arange(UInt, current_res) * 2
+            ii, jj = dr.meshgrid(i, j, indexing = "ij")
+            
+            index00 = ii * current_res * 2 + jj
+            index01 = ii * current_res * 2 + jj + 1
+            index10 = (ii + 1) * current_res * 2 + jj
+            index11 = (ii + 1) * current_res * 2 + jj + 1
+    
+            dr.eval(index00, index01, index10, index11)
+            val00 = dr.gather(Float, current_array, index00)
+            val01 = dr.gather(Float, current_array, index01)
+            val10 = dr.gather(Float, current_array, index10)
+            val11 = dr.gather(Float, current_array, index11)
+            if type == "max":
+                max0 = dr.maximum(val00, val01)
+                max1 = dr.maximum(val10, val11)
+                current_array = dr.maximum(max0, max1)
+            elif type == "min":
+                min0 = dr.minimum(val00, val01)
+                min1 = dr.minimum(val10, val11)
+                current_array = dr.minimum(min0, min1)
+            elif type == "mean":
+                current_array = (val00 + val01 + val10 + val11) / 4
+            else:
+                raise Exception("There is no such mipmap creation type.")
+            current_tensor = TensorXf(current_array)
+            current_tensor = dr.reshape(TensorXf, value = current_tensor, shape = [current_res, current_res])
+            u_factor = res // current_res
+            current_upsampled = upsample(current_tensor, scale_factor = [u_factor, u_factor])
+            #current_upsampled = dr.upsample(current_tensor, scale_factor=[res//current_res, res//current_res])
+            dr.scatter(array, current_upsampled.array, dr.arange(UInt, n) + (k+1) * n)
+        tensor = TensorXf(array)
+        tensor = dr.reshape(TensorXf, value = tensor, shape = [num_iter + 1, res, res])
+        #return TensorXf(array, shape = [num_iter + 1, res, res])
+        return tensor
+    @dr.syntax
+    def get_sphere_screening(self, points, radius):
+        x = (points[0] - self.bbox[0][0]) / self.bbox_length
+        y = 1.0 - (points[1] - self.bbox[0][1]) / self.bbox_length
+        k_max, res_all,_ = self.σ_mipmap.shape
+        #mask = mi.TensorXf(mi.Float(0) ,shape = [res_all, res_all])
+        
+        k_max -= 1
+        # which mipmap level to select
+        k =   UInt32(dr.ceil(dr.log2(2 * radius * res_all / ((self.max_window_grid - 1) * self.bbox_length))))
+        
+        k = dr.select(k > k_max, k_max, k)
+        if k < 0:
+            k = UInt32(0)
+        #dr.select(k < 0, 0, k)
+        # resolution of the selected grid
+        res_decrease = UInt32(dr.round(Float(2)**Float(k)))
+        
+        #res_decrease = mi.UInt32(4)
+        res = res_all // res_decrease
+        
+        n1_point = UInt32(dr.floor(y * res))
+        n2_point = UInt32(dr.floor(x * res))
+        
+        # get the center grid val of sphere
+        if self.max_window_grid % 2 == 0:
+            n1 = UInt32(dr.round(y * res))
+            n2 = UInt32(dr.round(x * res))
+        else:
+            n1 = n1_point
+            n2 = n2_point
+        
+        # get the index of the window 
+        n1_start = n1 - self.max_window_grid//2
+        n2_start = n2 - self.max_window_grid//2
+        #v = 0
+        v = UInt32(0)
+        # We start the majorant with the correspoinding grid where the point is inside
+        index_point = k * res_all * res_all + n1_point * res_decrease * res_all + n2_point * res_decrease
+        majorant = dr.gather(Float, self.σ_mipmap.array, index_point)
+        
+        #i = dr.arange(mi.UInt, res_decrease[0])
+        #j = dr.arange(mi.UInt, res_decrease[0])
+        #ii, jj = dr.meshgrid(i, j, indexing = "ij")
+        #mask_indices = (ii + n1_point * res_decrease)  * res_all + jj + n2_point * res_decrease
+        #dr.scatter(mask.array, mi.Float(1), mask_indices)
+        grid_length = self.bbox_length / res
+        
+        #loop = mi.Loop("Iterate over grids and get the max majorant if it touches the sphere!", state= lambda : (v, majorant))
+        while (v < self.max_window_grid**2):
+            n1_iter = v // self.max_window_grid + n1_start
+            n2_iter = v % self.max_window_grid + n2_start
+            
+            n1_iter = dr.select(n1_iter<0, 0, n1_iter)
+            n1_iter = dr.select(n1_iter>=res, res-1, n1_iter)
+            n2_iter = dr.select(n2_iter<0, 0, n2_iter)
+            n2_iter = dr.select(n2_iter>=res, res-1, n2_iter)
+  
+            square_corner_x = self.bbox[0][0] + n2_iter * grid_length
+            square_corner_y = self.bbox[0][1] + (res - n1_iter - 1) * grid_length
+            corner = Point2f(square_corner_x, square_corner_y)
+            dist = self.get_distance_to_square(points, corner, grid_length)
+            
+            #if dist[0] < radius:
+            #    i = dr.arange(mi.UInt, res_decrease[0])
+            #    j = dr.arange(mi.UInt, res_decrease[0])
+            #    ii, jj = dr.meshgrid(i, j, indexing = "ij")
+            #    mask_indices = (ii + n1_iter * res_decrease)  * res_all + jj + n2_iter * res_decrease
+            #    dr.scatter(mask.array, mi.Float(1), mask_indices)
+            index_point = k * res_all * res_all + n1_iter * res_decrease * res_all + n2_iter * res_decrease
+            majorant_iter = dr.gather(Float, self.σ_mipmap.array, index_point)
+            majorant = dr.select(dist < radius, dr.maximum(majorant_iter, majorant), majorant)
+            v += 1
+        #mask_tex = TextureCoefficient("mask", self.bbox, mask.numpy(), interpolation = "nearest")   
+        return majorant
+    
+    def compute_regularization(self, λ : float, type : RegularizationType, 
+                                resolution = [256, 256], spp = 1, coeff_str = "diffusion"):
+        out_val = 0
+        coeff = self.get_coefficient(coeff_str)
+        if coeff.out_val is not None:
+            out_val = coeff.out_val
+        with dr.suspend_grad():
+            points = self.shape.create_volume_points(resolution, spp)
+            dL = dr.ones(Float, dr.width(points)) * dr.rcp(dr.width(points))
+        if type == RegularizationType.none:
+            reg = Float(0)
+
+        elif type == RegularizationType.L2:
+            vals = coeff.get_value(points)
+            reg = dr.square(vals - out_val)
+
+        elif type == RegularizationType.tensorL2:
+            resolution = coeff.tensor.shape[0:2]
+            reg = Float(0)
+            dL = Float(1)
+            for i in range(resolution[0]):
+                for j in range(resolution[1]):
+                    index = i * resolution[1] + j 
+                    val = dr.gather(Float, self.α.tensor.array, index)
+                    reg += dr.square(val - out_val)
+        elif (type == RegularizationType.L1):
+            vals = coeff.get_value(points) 
+            reg = dr.abs(vals - out_val) 
+
+        elif (type == RegularizationType.tensorL1):
+            resolution = coeff.tensor.shape[0:2]
+            reg = Float(0)
+            dL = Float(1)
+            for i in range(resolution[0]):
+                for j in range(resolution[1]):
+                    index = i * resolution[1] + j 
+                    val = dr.gather(Float, self.α.tensor.array, index)
+                    reg += dr.abs(val - out_val)
+            reg /= ((resolution[0]) * resolution[1])
+
+        elif (type == RegularizationType.TV):
+            resolution = coeff.tensor.shape[0:2]
+            reg = Float(0)
+            dL = Float(1)
+            for i in range(resolution[0]-1):
+                for j in range(resolution[1]-1):
+                    index = i * resolution[1] + j 
+                    val = dr.gather(Float, self.α.tensor.array, index)
+                    val1 = dr.gather(Float, self.α.tensor.array, index+1)
+                    val2 = dr.gather(Float, self.α.tensor.array, index+resolution[1])
+                    reg += dr.abs(val1 - val)
+                    reg += dr.abs(val2 - val)
+            reg /= ((resolution[0]-1) * resolution[1]-1)
+
+        elif (type == RegularizationType.gradL1):
+            grad = coeff.get_grad_laplacian(points)[0]
+            reg =   dr.abs(grad[0]) + dr.abs(grad[1])
+
+        elif(type == RegularizationType.gradL2):
+            grad = coeff.get_grad_laplacian(points)[0]
+            reg =   dr.squared_norm(grad)
+
+        elif (type == RegularizationType.screeningL2) or (type == RegularizationType.screeningL1):
+            σ = self.σ.get_value(points)
+            α = self.α.get_value(points)
+            grad_α, laplacian_α = self.α.get_grad_laplacian(points)
+            σ_ = self.σ_(σ, α, grad_α, laplacian_α)
+            reg = dr.square(σ_) if type == RegularizationType.screening_squared else dr.abs(σ_)
+
+        else:
+            raise Exception("There is no such regularization type.")
+        return dL * reg * λ
+    
+    @dr.syntax
+    def get_Rσ(self, points, radius, n_bisection = 10, n_grid_search = 10, screening_offset = Float(0)):
+        σ_begin = self.get_sphere_screening(points, radius + 2 * screening_offset)
+        σ = self.get_sphere_screening(points, radius + screening_offset)
+        z = radius * dr.sqrt(σ)
+        
+        # We will shrink these radii for g
+        r = Float(radius)
+        # Here we shrink the radii of the spheres where z is high by bisection.
+        # At each iter we shrink to the middle value of max and min z, and compute 
+        # the corresponding z value by also querying the correct majorant value.
+        # If we found something close enough to z_high, we end the iteration.
+        if z > self.max_z:
+            r_high = Float(radius)
+            r_low  = self.max_z / dr.sqrt(σ)
+            i = UInt32(0)
+            while i < n_bisection:
+                r_sep = (r_high + r_low) / 2
+                σ_sep = self.get_sphere_screening(points, r_sep + screening_offset)
+                z_sep = r_sep * dr.sqrt(σ_sep)
+                if z_sep < self.max_z:
+                    r_low = Float(r_sep)
+                else:
+                    r_high = Float(r_sep)
+                i += 1
+            r = Float(r_low)
+            σ = self.get_sphere_screening(points, r + screening_offset)
+            z = r * dr.sqrt(σ)
+        
+        # Now all z vals should be in the correct range that we can sample from.
+        # We will compute the best radius value in terms of the mean free path 
+        # by grid search.
+        i = UInt32(0)
+        meanfree_best = Float(0) 
+        r_best = Float(0)
+        while i < n_grid_search:
+            r_iter = r * Float(i + 1) / n_grid_search
+            σ_iter = self.get_sphere_screening(points, r_iter + screening_offset)
+            meanfree_iter = self.get_mean_free_path(r_iter, σ_iter)
+            if meanfree_iter > meanfree_best:
+                meanfree_best = meanfree_iter
+                r_best = r_iter
+                σ = σ_iter
+            i += 1
+        
+        return r_best, σ, σ_begin
+        
+    def get_coefficient(self, name : str = "diffusion"):
+        if name == "diffusion":
+            return self.α
+        elif name == "screening":
+            return self.σ
+        elif name == "source":
+            return self.f
+        else:
+            raise Exception("There is no such coefficient.")
+
+    def get_Rσ_domain(self, res, n_bisection = 10, n_grid_search = 10):
+        points = create_image_points(self.bbox, resolution = [res, res], spp = 1, centered = True)
+        bi = self.shape.boundary_interaction(points, star_generation=False)
+        # We will always add these small offset value while computing the majorant to 
+        # account for the grid size. 
+        s_offset = self.bbox_length / res / dr.sqrt(2) * 1.01
+        self.radius_threshold = s_offset * 5
+        
+        r_best, σ_best, σ_begin = self.get_Rσ(points, bi.r, n_bisection = n_bisection, n_grid_search=n_grid_search,
+                                     screening_offset=s_offset)
+        # We need to be careful while using the corresponding radii as it does not represent 
+        # exactly the correct radius values.
+        r_image, _ = create_image_from_result(r_best, resolution = [res, res])
+        σ_image, _ = create_image_from_result(σ_best, resolution = [res, res])
+        σ_begin_image, _ = create_image_from_result(σ_begin, resolution = [res, res])
+        r_best_tex = TextureCoefficient("Best-radius", self.bbox, r_image[0], interpolation = "nearest")
+        σ_best_tex = TextureCoefficient("Best-majorant", self.bbox, σ_image[0], interpolation = "nearest")
+        σ_begin_tex = TextureCoefficient("Beginning-majorant", self.bbox, σ_begin_image[0], interpolation = "nearest")
+        return r_best_tex, σ_best_tex, σ_begin_tex
+    
+    @dr.syntax
+    def get_Rσz(self, points, radius):
+        r = self.r_best_tex.get_value(points)
+        σ = self.σ_best_tex.get_value(points)
+        σ_begin = self.σ_begin_tex.get_value(points)
+
+        # If we chose a greater best radius due to discretization of the domain or 
+        # if the distance is too small, then select the original distance for taking a step!
+        if (radius < r) | (radius < 20 * self.shape.epsilon) | (radius < self.radius_threshold):
+            r = radius
+            σ = σ_begin 
+
+        σ = dr.maximum(1e-3, σ)
+        z = r * dr.sqrt(σ)
+        # For rare cases, now the z value might be larger than the max z. Especially if the majorant 
+        # is super high near the boundary.
+        if z >= self.max_z:
+            r *= (self.max_z / z)
+            z = self.max_z
+        # return the selected parameters for sampling the next step.
+        return r, σ, z
+        
+    @dr.syntax
+    def get_distance_to_square(self, point, corner, length):
+        i = UInt32(0)
+        min1 = Float(dr.inf)
+        min2 = Float(dr.inf)
+        p1 = Point2f(dr.nan)
+        p2 = Point2f(dr.nan)
+        while i < 4:
+            n1 = Float(i // 2)
+            n2 = Float(i %  2)
+            corner_ = corner + length * (Point2f(0,1) * n1 + 
+                                         Point2f(1,0) * n2)
+            dist = dr.norm(corner_ - point)
+            mask1 = dist < min1
+            mask2 = dist < min2
+            min2 = dr.select(mask1, min1, min2)
+            min1 = dr.select(mask1, dist, min1)
+            min2 = dr.select(~mask1 & mask2, dist, min2)
+            p2 = Point2f(dr.select(mask1, p1, p2))
+            p1 = Point2f(dr.select(mask1, corner_, p1))
+            p2 = Point2f(dr.select(~mask1 & mask2, corner_, p2))
+            i += 1
+        vec1 = dr.normalize(p2 - p1)
+        vec2 = point - p1
+        d = dr.dot(vec1,vec2)
+        d = dr.select(d<0, 0, d)
+        d = dr.select(d>length, length, d)
+        closest_point = p1 + d * vec1
+        return dr.norm(point - closest_point)
+        
+    def zero_grad(self):
+        self.α.zero_grad()
+        self.σ.zero_grad()
+        self.f.zero_grad()
+        self.shape.zero_grad()
+        
+    def visualize(self, ax1, ax2, ax3, ax4, resolution = [512, 512], spp = 4):
+        self.f.visualize(ax1, self.bbox, resolution, spp)
+        self.σ.visualize(ax2, self.bbox, resolution, spp)
+        self.α.visualize(ax3, self.bbox, resolution, spp)
+        image, tensor = self.get_effective_screening(resolution, spp)
+        plot_image(image[0], ax4)
+        ax1.set_title("Source (f)")
+        ax2.set_title("Screening (σ)")
+        ax3.set_title("Diffusion (α)")
+        ax4.set_title("Effective Screening (σ)")
+        
+    def get_effective_screening(self, resolution = [512, 512], spp = 4):
+        points = create_image_points(self.bbox, resolution, spp)
+        σ = self.σ.get_value(points)
+        α = self.α.get_value(points)
+        grad_α, laplacian_α = self.α.get_grad_laplacian(points)
+        effective_σ = σ / α + 1/2 * (laplacian_α / α - dr.squared_norm(grad_α)/(2 * (α ** 2)))
+        return create_image_from_result(effective_σ, resolution)
+    
+    def get_point_neumann(self, bi : BoundaryInfo, conf_number : UInt32) -> tuple[list[Float], list[Float], list[Float], list[Point2f]]:
+        return self.shape.get_point_neumann(bi, conf_number)
+    
+    def sampleNEE_special(self, bi:BoundaryInfo, sample : Float, conf_number : UInt32):
+         # If we have a special sampling routine for getting NEE. (sampling only electrodes.)
+        return self.shape.sampleNEE(bi, sample, conf_number)
+    
+    @dr.syntax
+    def sampleNEE(self, bi : BoundaryInfo, sample : Float, conf_numbers : list[UInt32]) -> tuple[Float, Float, Float, Point2f]:
+        d, pdf_n_r, sampled_p = (Float(0), Float(1), Point2f(0))
+        n_val = dr.zeros(ArrayXf, shape = (len(conf_numbers), dr.width(bi.origin)))
+        if dr.hint(self.NEE == NEE.Normal, mode = 'scalar'): # Sample uniformly to the star part of the sphere.
+            # Sampled direction for getting the Neumann contribution.
+            dir_n, pdf_n = bi.sample_neumann(sample, bi.on_boundary)
+            # Check the selected sample hits to the boundary shape with neumann value.
+            #d, sampled_p, normals_n = self.shape.ray_intersect(bi.origin, dir_n, bi.on_boundary)
+            ri = self.shape.ray_intersect(bi, dir_n, conf_numbers =conf_numbers)
+            d = ri.t
+            sampled_p = ri.intersected
+            # If we hit to the boundary, add the contribution.
+            if bi.is_star & (ri.t < bi.r) & ~ri.is_dirichlet:
+                for i in range(len(conf_numbers)):
+                    n_val[i] = Float(ri.neumann[i])
+                pdf_n_r = pdf_n * dr.abs(dr.dot(dir_n, ri.normal)) * 2 * dr.pi # pdf multiplied with 2 * pi * bi.r
+        
+        elif dr.hint(self.NEE == NEE.BruteForce, mode = 'scalar'):
+            dir_n, pdf_n = bi.sample_brute_force(sample)
+            ri = self.shape.ray_intersect(bi, dir_n, conf_numbers =conf_numbers)
+            d = ri.t
+            sampled_p = ri.intersected
+
+            if bi.is_star & (ri.t < bi.r) & ~ri.is_dirichlet:
+                for i in range(len(conf_numbers)):
+                    n_val[i] = Float(ri.neumann[i])
+                pdf_n_r = pdf_n * dr.abs(dr.dot(dir_n, ri.normal)) * 2 * dr.pi # pdf multiplied with 2 * pi * bi.r
+        return d, n_val, pdf_n_r, sampled_p
+    
+
+    def compute_high_conductance_points(self, max_num_points = 3, cond_threshold = 2, grad_threshold = 1, merge_distance = 0.2):
+        bbox = self.shape.bbox
+        bbox_center = Point2f(bbox[0][0] + bbox[1][0],
+                              bbox[0][1] + bbox[1][1])
+        bbox_length = max(bbox[1][0] - bbox[0][0], bbox[1][1] - bbox[0][1])
+
+        if isinstance(self.shape, BoundaryWithDirichlets):
+            points = self.shape.out_boundary.create_volume_points(resolution = [1024, 1024])
+        else:
+            points = self.shape.create_volume_points(resolution = [1024, 1024])
+
+        val = self.α.get_value(points)
+        grad, laplacian = self.α.get_grad_laplacian(points)
+        mask = (dr.norm(grad) < grad_threshold) & (val > cond_threshold) & (laplacian < 0)
+        indices = dr.compress(mask)
+        points = dr.gather(Point2f, points, indices)
+        if np.size(points.numpy()) == 0:
+            return bbox_center.numpy().T
+
+        #means = create_circle_points(origin=bbox_center, radius = bbox_length, 
+        #                             resolution = 20, spp = 1, discrete_points= True)
+        means = self.shape.create_volume_points(resolution = [16,16])
+
+        means, groups = k_means(points, means, num_iter = 3)
+        mask = ~dr.isnan(means[0] + means[1])
+        indices = dr.compress(mask)
+        means = dr.gather(Point2f, means, indices)
+
+        """
+        # Merge close points
+        nmeans = dr.width(means)
+        ind = dr.arange(UInt32, nmeans)
+        for i in range(nmeans):
+            if ind[i] == i:
+                for j in range(i + 1, nmeans):
+                    means_i = dr.gather(Point2f, means, i)
+                    means_j = dr.gather(Point2f, means, j)
+                    if dr.norm(means_i - means_j)[0] < merge_distance * bbox_length:
+                        dr.scatter(means, Point2f(dr.nan), j)
+                        ind[j] = i
+        """
+        # Recompute the means once more.
+        #mask = ~dr.isnan(means[0] + means[1])
+        #indices = dr.compress(mask)
+        #means = dr.gather(Point2f, means, indices)
+        means, groups = k_means(points, means, num_iter = 1)
+
+        # Get the highest conduction region.∂
+        val = self.α.get_value(points)
+        cond_sum = dr.zeros(Float, dr.width(means))
+        counter_sum = dr.zeros(Float, dr.width(means))
+        dr.scatter_add(cond_sum, val, groups)
+        dr.scatter_add(counter_sum, Float(1), groups)
+        mean_cond = (cond_sum / counter_sum)
+        
+        # Now we sort with numpy to get the biggest mean conductance regions.
+        mean_cond_np = mean_cond.numpy()
+        
+        #sort_index = mean_cond_np.argsort()[::-1][:num_points]
+        sort_index = mean_cond_np.argsort()[::-1]
+        
+        # means
+        means = means.numpy()[:, sort_index].T
+
+        # Now we eliminate the points that are very close to the region 
+        # we are interested in.
+        n = means.shape[0]
+        i = 0
+        while(i < n):
+            deleted_indices = []
+            for k in range(i+1, n):
+                dist = np.linalg.norm(means[i] - means[k])
+                if dist < merge_distance * bbox_length:
+                    deleted_indices.append(k)
+            means = np.delete(means, deleted_indices, axis = 0)
+            n = means.shape[0]
+            i += 1
+        num_points = min(means.shape[0], max_num_points)
+        means =  means[:num_points]
+        # Apply one last k-means
+        #means = k_means(points, Point2f(means.T), num_iter = 2)[0].numpy()
+        #return means.T
+        if means.shape[0] == 0:
+            means = np.zeros([1,2])
+        return means
+    
+    def upsample2(self, coefficient = "diffusion"):
+        coeff = self.get_coefficient(coefficient)
+        coeff.upsample2()

data/PDE2D/Solver/variable/wos_variable.py

@@ -0,0 +1,736 @@
+import mitsuba as mi
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from ...BoundaryShape.interaction import BoundaryInfo
+from PDE2D.BoundaryShape import *
+from mitsuba import Bool, Float, Point2f, UInt, PCG32, UInt64, UInt32, UInt
+from PDE2D import (Array4u64, ArrayXf,  ArrayXb, GreenSampling, Split, DIM)
+
+class Particle:
+    DRJIT_STRUCT = {
+        'points' : Point2f,
+        'w': Float,
+        'w_split' : Float,
+        'sampler' : PCG32,
+        'path_index' : UInt32,
+        'path_length' : UInt32,
+        'traverse_h' : Array4u64,
+        'thrown' : Bool
+    }
+    def __init__(self, points=None, w=None, w_split = None, 
+                 sampler = None, path_index = None, path_length = None, 
+                 traverse_h = None):
+        self.points = points
+        self.w = w
+        self.w_split = w_split
+        self.sampler = sampler
+        self.path_index = path_index
+        self.path_length = path_length
+        self.traverse_h = traverse_h
+        self.thrown = Bool(False)
+
+class WosVariable(object):
+    def __init__(self, input : DataHolder, seed : int = 37, weight_window = [0.5, 2],  max_z : float = 4, 
+                 green_sampling : GreenSampling = 0, newton_steps : int = 5, use_accelaration : bool = True,
+                 opt_params : list[str] = []):
+        self.input = input
+        self.seed = UInt64(seed)
+        dr.make_opaque(self.seed)
+        self.input = input
+        self.w_window = weight_window
+        self.max_z = Float(max_z)
+        self.use_accel = use_accelaration
+        self.input.max_z = self.max_z
+    
+        if self.use_accel:
+            self.input.create_accelaration()
+
+        self.opt_params = {}
+        self.get_opt_params(self.opt_params, opt_params)
+
+        if green_sampling == GreenSampling.Polynomial:
+            self.green = GreensFunctionPolynomial(dim = DIM.Two, newton_steps = newton_steps)
+        else:
+            self.green = GreensFunctionAnalytic(dim = DIM.Two, newton_steps = newton_steps)
+
+    def change_seed(self, seed : int):
+        self.seed = dr.opaque(UInt64, seed, shape = (1))
+
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.input.get_opt_params(param_dict, opt_params)
+        
+    def update(self, opt):
+        self.input.update(opt)
+    
+    def zero_grad(self):
+        self.input.zero_grad()
+
+    def get_opt_params(self, param_dict: dict, opt_params: list):
+        self.input.get_opt_params(param_dict, opt_params)
+    
+    
+    def σ_(self, σ, α, grad_α, laplacian_α):   # Equation 21 (2nd paper)
+        return σ / α  + 1/2 * (laplacian_α / α - dr.squared_norm(grad_α)/(2 * (α ** 2)))
+        
+        
+    @dr.syntax(print_code = False)
+    def solve(self, points_in = None, active_conf_in : ArrayXb = None, split : Split = Split.Normal, derivative_dir : Point2f = None, initial_w = Float(1),
+                   conf_numbers : list[UInt32] = [UInt32(0)], max_length : UInt32 = None, tput_kill : Float = Float(0.8), all_inside = False, 
+                   fd_forward = False, max_depth_split = 100, verbose : bool = True):
+        size = dr.width(points_in)
+
+        # The channel size of the rendering.
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        
+        #L_res = dr.zeros(Float, size)
+        L_res = dr.zeros(ArrayXf, (num_conf, size))
+        
+        active_conf_begin = dr.ones(ArrayXb, shape = L_res.shape) if active_conf_in is None else active_conf_in
+        assert L_res.shape == active_conf_begin.shape
+
+        active_conf = ArrayXb(active_conf_begin)
+
+        active = Bool(True)
+        if dr.hint(self.input.shape.single_closed and (not all_inside), mode = 'scalar'):
+            active, L_res = self.input.shape.inside_closed_surface(points_in, L_res, conf_numbers)
+
+        seq = dr.arange(UInt64, size)
+        initstate, initseq = tea(UInt64(seq), UInt64(self.seed))
+        pcg = PCG32()
+        pcg.seed(initstate, initseq)
+
+        particle = Particle(points = Point2f(points_in), w = Float(initial_w), w_split = Float(1.0), 
+                            sampler = PCG32(pcg), path_index = dr.arange(UInt32, size),
+                            path_length = UInt32(0), traverse_h = Array4u64(1,0,0,0))
+        
+        
+        with dr.suspend_grad():
+            # If we apply no path splitting.    
+            if dr.hint(split == Split.Naive, mode = 'scalar'):
+                # Primal phase.
+                # We take a derivative step in the beginning if the direction is specified.
+                if dr.hint(derivative_dir is not None, mode = 'scalar'):
+                    particle = self.take_derivative_step(derivative_dir, L_res, particle, dr.ADMode.Primal, ArrayXf(0), active, active_conf = active_conf)
+                
+                # Take other steps.
+                while active:
+                    particle = self.take_step(L_res, particle, dr.ADMode.Primal, split, ArrayXf(0), active, active_conf, 
+                                              conf_numbers, max_length, tput_kill, fd_forward)
+                    # Russian roulette
+                    if (particle.w_split < self.w_window[0]) & active:
+                        if particle.sampler.next_float32() >= particle.w:
+                            active = Bool(False)
+                        else:
+                            particle.w = Float(1)
+                return L_res, particle
+            
+            # Otherwise do the path splitting scheme.
+            iter_num = 0
+            while (size > 0) and (iter_num < (max_depth_split + 1)):
+                queue_index = UInt32(0)
+
+                is_split = iter_num < max_depth_split 
+                if dr.hint(is_split, mode = 'scalar'):
+                    # Preallocate memory for the queue. The necessary amount of memory is
+                    # task-dependent (how many splits there are)
+                    queue_size = dr.maximum(50, int(2 * size))
+                    queue_size_opaque = dr.opaque(UInt32, queue_size)
+                    queue = dr.empty(dtype=Particle, shape=queue_size)
+
+                # Get the primal result of each iteration in the gradient computation for prb.
+                L_iter = dr.zeros(ArrayXf, shape = (num_conf, size))
+
+                # We again first take the derivative direction if it is specified.
+                if dr.hint((derivative_dir is not None) & (iter_num == 0), mode = 'scalar'):
+                    particle = self.take_derivative_step(derivative_dir, L_iter, particle, dr.ADMode.Primal, Float(0), active, active_conf)
+                
+                while active:
+                    # This is the main part of the algorithm (WoS).
+                    particle = self.take_step(L_iter, particle, dr.ADMode.Primal, split, Float(0), active, active_conf,
+                                              conf_numbers, max_length, tput_kill, fd_forward = fd_forward)
+
+                    # Russian roulette
+                    if (particle.w_split < self.w_window[0]) & active:
+                        if particle.sampler.next_float32() >= particle.w_split:
+                            active = Bool(False)
+                        else:
+                            particle.w /= particle.w_split
+                            particle.w_split = Float(1)
+                    
+                    
+                    # Splitting begins. #################################################
+                    if (particle.w_split >= self.w_window[1]) & active:
+                        particle, new_particle = split_particle(particle)
+
+                        if dr.hint(is_split, mode = 'scalar'):
+                            slot = dr.scatter_inc(queue_index, index=0)
+                            
+                            # Be careful not to write beyond the end of the queue
+                            valid =  (slot < queue_size_opaque)
+
+                            # Write 'new_state' into the reserved slot
+                            dr.scatter(target=queue, value=new_particle, index=slot, active=valid)
+                        
+                dr.scatter_add(L_res, L_iter, particle.path_index)
+                next_size = queue_index[0]
+                if verbose:
+                    print('%u : %u -> %u' % (iter_num, size, next_size))
+                iter_num += 1 
+
+                if dr.hint(is_split, mode = "scalar"):
+                    if next_size > queue_size:
+                        print('Warning: Preallocated queue was too small: tried to store '
+                            f'{next_size} elements in a queue of size {queue_size}')
+                        size = queue_size
+                
+                if dr.hint(iter_num == max_depth_split, mode = "scalar"):
+                    print(f'Warning : The split tree depth exceeds the specified value {max_depth_split}. '
+                          f'The rest of the particles ({size}, {size / dr.width(points_in) * 100 :.1f} %) will be'
+                          'simulated without splitting.')
+                
+                size = next_size
+
+                    
+                # Generate the varibles for the next step.
+                if size > 0:
+                    # Get the values from the queue for the next iter.
+                    particle = dr.reshape(type(particle), value=queue, shape=next_size, shrink=True)
+                    # Initially, all particles are active in the next iter.
+                    active = dr.full(Bool, True, size)
+
+                    active_conf = dr.gather(ArrayXb, active_conf_begin, particle.path_index)
+        return L_res, particle
+        
+    
+    @dr.syntax(print_code = False)
+    def solve_grad(self, points_in : Point2f = None, active_conf_in : ArrayXb = None, split : Split = Split.Normal, 
+                   mode : dr.ADMode = dr.ADMode.Backward, dL : ArrayXf = ArrayXf(0), 
+                   derivative_dir : Point2f = None, conf_numbers : list[UInt32] = [UInt32(0)], 
+                   max_length : UInt32 = None, tput_kill : Float = Float(0.8), all_inside = False, fd_forward = False, 
+                   max_depth_split = 100, verbose = False):
+        
+        size = dr.width(points_in)
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        #L_res = dr.zeros(Float, size)
+        L_res = dr.zeros(ArrayXf, (num_conf, size))
+        
+        # Loss grad value splatted to the paths.
+        dL_begin = ArrayXf(dL)
+
+        if mode == dr.ADMode.Forward:
+            dL = ArrayXf(0) 
+        
+        active = Bool(True)
+        active_conf_begin = dr.ones(ArrayXb, shape = L_res.shape) if active_conf_in is None else active_conf_in
+        active_conf = ArrayXb(active_conf_begin)
+        assert L_res.shape == active_conf.shape
+
+        if dr.hint(self.input.shape.single_closed and (not all_inside), mode = 'scalar'):
+            active, L_res = self.input.shape.inside_closed_surface(points_in, L_res, conf_numbers)
+
+        seq = dr.arange(UInt64, size)
+        initstate, initseq = tea(UInt64(seq), UInt64(self.seed))
+        pcg = PCG32()
+        pcg.seed(initstate, initseq)
+
+        particle = Particle(points = Point2f(points_in), w = Float(1.0), w_split = Float(1.0), 
+                            sampler = PCG32(pcg), path_index = dr.arange(UInt32, size),
+                            path_length = UInt32(0), traverse_h = Array4u64(1,0,0,0))
+        
+        particle_prb = Particle(points = Point2f(points_in), w = Float(1.0), w_split = Float(1.0), 
+                                sampler = PCG32(pcg), path_index = dr.arange(UInt32, size),
+                                path_length = UInt32(0), traverse_h = Array4u64(1,0,0,0))
+        active_prb = Bool(active)
+
+        with dr.suspend_grad():
+            # If we apply no path splitting.    
+            if dr.hint(split == Split.Naive, mode = 'scalar'):
+                # Primal phase.
+                # We take a derivative step in the beginning if the direction is specified.
+                if dr.hint(derivative_dir is not None , mode = 'scalar'):
+                    particle = self.take_derivative_step(derivative_dir, L_res, particle, dr.ADMode.Primal, Float(0), active, active_conf)
+                
+                # Take other steps.
+                while active:
+                    particle = self.take_step(L_res, particle, dr.ADMode.Primal, split, Float(0), active, active_conf, 
+                                              conf_numbers, max_length, tput_kill, fd_forward)
+                    # Russian roulette
+                    if active & (particle.w_split < self.w_window[0]):
+                        if particle.sampler.next_float32() >= particle.w:
+                            active = Bool(False)
+                        else:
+                            particle.w = Float(1)
+                
+                # Replay phase.
+                L_replay = ArrayXf(L_res)
+                # We do the same exact thing with different compuation mode. 
+                if dr.hint(derivative_dir is not None, mode = 'scalar'):
+                    particle_prb = self.take_derivative_step(derivative_dir, L_replay, particle_prb, mode, dL, active_prb, active_conf)
+                # Take other steps.
+                while active_prb:
+                    particle_prb = self.take_step(L_replay, particle_prb, mode, split, dL, active_prb, active_conf, 
+                                                  conf_numbers, max_length, tput_kill, fd_forward)
+                    # Russian roulette
+                    if active_prb & (particle_prb.w_split < self.w_window[0]):
+                        if particle_prb.sampler.next_float32() >= particle_prb.w:
+                            active_prb = Bool(False)
+                        else:
+                            particle_prb.w = Float(1)
+                return L_res, particle
+            
+            # Otherwise do the path splitting scheme.
+            iter_num = 0
+            traverse_index = dr.zeros(Array4u64, size) # We start with the traverse index of the last splitted particle.
+            traverse_index_prb = dr.zeros(Array4u64, size)
+            traverse_index[0] = UInt64(1)
+            traverse_index_prb[0] = UInt64(1) 
+
+            while (size > 0) & (iter_num < (max_depth_split + 1)):
+                queue_index = UInt32(0)
+                is_split = iter_num < max_depth_split 
+
+                if dr.hint(is_split, mode = 'scalar'):
+                    # Preallocate memory for the queue. The necessary amount of memory is
+                    # task-dependent (how many splits there are)
+                    queue_size = dr.maximum(50, int(2 * size))
+                    queue_size_opaque = dr.opaque(UInt32, queue_size)
+                    queue = dr.empty(dtype=Particle, shape=queue_size)
+
+                # Get the primal result of each iteration in the gradient computation for prb.
+                L_iter = dr.zeros(ArrayXf, shape = (num_conf, size))
+                # We again first take the derivative step if it is specified.
+                if dr.hint((derivative_dir is not None) & (iter_num == 0), mode = 'scalar'):
+                    first_traverse = is_one(traverse_index)
+                    particle = self.take_derivative_step(derivative_dir, L_iter, particle, dr.ADMode.Primal, ArrayXf(0), 
+                                                         active, active_conf, illumination_mask= first_traverse)
+                
+                while active:
+                    # This is the main part of the algorithm (WoS).
+                    first_traverse = is_one(traverse_index)
+                    particle = self.take_step(L_iter, particle, dr.ADMode.Primal, split, ArrayXf(0), active, active_conf,
+                                              conf_numbers, max_length, tput_kill, fd_forward = fd_forward,
+                                              illumination_mask= first_traverse)
+                    # Russian roulette
+                    if active & (particle.w_split < self.w_window[0]):
+                        if particle.sampler.next_float32() >= particle.w_split:
+                            active = Bool(False)
+                        else:
+                            particle.w /= particle.w_split
+                            particle.w_split = Float(1)
+                    
+                    
+                    # Splitting begins. #################################################
+                    if ((particle.w_split >= self.w_window[1]) & active):
+                        particle, new_particle = split_particle(particle)
+                        
+                        if dr.hint(is_split, mode = 'scalar'):
+                            slot = dr.scatter_inc(queue_index, index=0, active = first_traverse)
+                        
+                            # Be careful not to write beyond the end of the queue
+                            valid = first_traverse & (slot < queue_size_opaque)
+
+                            # Write 'new_state' into the reserved slot
+                            dr.scatter(target=queue, value=new_particle, index=slot, active=valid)
+
+                        if ~first_traverse:
+                            msb2, traverse_index = MSB2(traverse_index)
+                            if msb2 == 1:
+                                particle = new_particle
+
+                if dr.hint(mode != dr.ADMode.Primal, mode = 'scalar'):
+                    # Start the replay phase.
+                    L_replay = ArrayXf(L_iter)
+                    # We again first take the derivative step if the direction is specified.
+                    if dr.hint((derivative_dir is not None) & (iter_num == 0), mode = 'scalar'):
+                        first_traverse_prb = is_one(traverse_index_prb)
+                        particle_prb = self.take_derivative_step(derivative_dir, L_replay, particle_prb, mode, dL, 
+                                                                active_prb, active_conf, illumination_mask=first_traverse_prb)
+                    
+                    while active_prb:
+                        # This is the main part of the algorithm (WoS).
+                        first_traverse_prb = is_one(traverse_index_prb)
+                        particle_prb = self.take_step(L_replay, particle_prb, mode, split, dL, active_prb, active_conf,
+                                                      conf_numbers, max_length, tput_kill, fd_forward = fd_forward,
+                                                      illumination_mask=first_traverse_prb)
+
+                        # Russian roulette
+                        if ((particle_prb.w_split < self.w_window[0]) & active_prb):
+                            if particle_prb.sampler.next_float32() >= particle_prb.w_split:
+                                active_prb = Bool(False)
+                            else:
+                                particle_prb.w /= particle_prb.w_split
+                                particle_prb.w_split = Float(1)
+                    
+
+                        
+                        if ((particle_prb.w_split >= self.w_window[1]) & active_prb):
+                            # Split the particle in the same way.
+                            particle_prb, new_particle_prb = split_particle(particle_prb)
+
+                            if ~first_traverse_prb:
+                                msb2_prb, traverse_index_prb = MSB2(traverse_index_prb)
+                                if msb2_prb == 1:
+                                    particle_prb = new_particle_prb
+                        
+                dr.scatter_add(L_res, L_iter, particle.path_index)
+                next_size = queue_index[0]
+                
+            
+                if verbose:
+                    print('%u : %u -> %u' % (iter_num, size, next_size))
+                iter_num += 1 
+
+                if dr.hint(is_split, mode = "scalar"):
+                    if next_size > queue_size:
+                        print('Warning: Preallocated queue was too small: tried to store '
+                            f'{next_size} elements in a queue of size {queue_size}')
+                        size = queue_size
+                
+                if dr.hint(iter_num == max_depth_split, mode = "scalar"):
+                    print(f'Warning : The split tree depth exceeds the specified value f{max_depth_split}. '
+                          f'The rest of the particles ({size}, {size / dr.width(points_in) * 100 :.1f} %) will be'
+                          'simulated without splitting.')
+                
+                size = next_size
+                # Generate the varibles for the next step.
+                if size > 0: 
+                    # Get the values from the queue. 
+                    particle_f = dr.reshape(type(particle), value=queue, shape=size, shrink=True) 
+                    
+                    # Initially, all particles are active in the next iter.
+                    active = dr.full(Bool, True, size)
+                
+                    # Set the traverse index to be the last traverse history.
+                    traverse_index = Array4u64(particle_f.traverse_h)
+                
+                    # Get the initial points for the next run.
+                    next_points = dr.gather(Point2f, points_in, particle_f.path_index)
+
+                    # Get the active configurations.
+                    active_conf = dr.gather(ArrayXb, active_conf_begin, particle_f.path_index)
+
+                    # Get the loss grad value splatted to the paths.
+                    if mode == dr.ADMode.Backward:
+                        dL = dr.gather(ArrayXf, dL_begin, particle_f.path_index)
+
+                    initseq, initstate = tea(UInt64(particle_f.path_index), UInt64(self.seed))
+                    pcg_iter = PCG32()
+                    pcg_iter.seed(initseq, initstate)
+
+                    particle = Particle(points=Point2f(next_points),
+                                        w = Float(1),
+                                        w_split = Float(1),
+                                        sampler = PCG32(pcg_iter),
+                                        path_index = UInt32(particle_f.path_index),
+                                        path_length = UInt32(0),
+                                        traverse_h= Array4u64(1,0,0,0))
+                
+                    # Generate the same for the replay stage.
+                    active_prb = Bool(active)
+                    traverse_index_prb = Array4u64(traverse_index)
+
+                    particle_prb = Particle(points=Point2f(next_points),
+                                            w = Float(1.),
+                                            w_split = Float(1.),
+                                            sampler = PCG32(pcg_iter),
+                                            path_index = UInt32(particle_f.path_index),
+                                            path_length = UInt32(0),
+                                            traverse_h= Array4u64(1,0,0,0))
+        return L_res, particle
+    
+    
+    @dr.syntax(print_code = False)
+    def take_step(self, L : ArrayXf, p : Particle, mode : dr.ADMode, split : Split, dL : ArrayXf, active : Bool, active_conf : ArrayXb = ArrayXb(True),
+                  conf_numbers : list[UInt32] = None, max_length : UInt32 = None, tput_kill : Float = Float(0.8), 
+                  fd_forward : bool = False, illumination_mask : Bool = Bool(True)):
+        
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        
+        primal = (mode == dr.ADMode.Primal)
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+        
+        if bi.is_far:
+            p.thrown = Bool(True)
+            active &= Bool(False)
+        
+        # Decrease radius if it is big. 
+        σ_bar = self.input.σ_bar
+        z = Float(0)
+        if self.use_accel:
+            bi.r, σ_bar, z = self.input.get_Rσz(p.points, bi.r)
+        else:
+            z = bi.r * dr.sqrt(σ_bar)
+            if z > self.max_z:
+                bi.r *= self.max_z / z
+                z = self.max_z
+        
+        self.green.initialize(z)
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+        
+        # Add the dirichlet boundary contribution in epsilon-shell!
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)
+
+        L += added_near if primal else -added_near
+
+        with dr.resume_grad(when=not primal):
+            α = self.input.α.get_value(p.points)
+            
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+
+        f_cont = Float(0)        
+        # Add the source contribution.
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            sample_source = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+            #if illumination_mask:
+            r_vol, normG = self.green.sample(sample_source[0], bi.r, σ_bar)
+            dir_vol, _ = sample_uniform_direction(sample_source[1])
+            points_vol = p.points + r_vol * dir_vol 
+            with dr.resume_grad(when=not primal):
+                α_vol = self.input.α.get_value(points_vol)
+                f_vol = self.input.f.get_value(points_vol) 
+                f_cont = p.w * f_vol * normG / dr.sqrt(α * α_vol)
+                if dr.isnan(f_cont) | ~illumination_mask:
+                    f_cont = Float(0)
+
+        f_cont = dr.select(active_conf, f_cont, 0)
+        L += f_cont if primal else -f_cont
+
+        # Now select between boundary or volume sampling (2nd paper, eqn 28)
+        normG = self.green.eval_norm(bi.r, σ_bar)
+        prob_vol =  σ_bar * normG
+        sample_rec = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+        sample_vol = active & (sample_rec[0] < prob_vol)
+        sample_rec[0] = dr.select(sample_vol, sample_rec[0] / prob_vol, (sample_rec[0] - prob_vol) / (1-prob_vol))
+
+        r_next = Float(bi.r)
+        if sample_vol:
+            r_next = self.green.sample(sample_rec[0], bi.r, σ_bar)[0]
+            
+        dir_next, _ = sample_uniform_direction(sample_rec[1])
+        points_next = p.points + r_next * dir_next
+        
+
+        with dr.resume_grad(when=not primal):
+            α_next = self.input.α.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α.get_grad_laplacian(points_next)
+            σ_next = self.input.σ.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            w_update = w_ * w_s
+            # Boundary and Volume Contribution
+            prb_cont = dr.select(dr.isfinite(w_update), L * w_update / dr.detach(w_update), 0.0)
+
+            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                dr.backward(dr.sum((prb_cont + f_cont) * dL)) 
+            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                dL += dr.forward_to(dr.sum(prb_cont + f_cont))
+            
+        p.w *= w_update
+        # If we are not doing fd computation, then just use the original coefficient.
+        if dr.hint((not fd_forward), mode = 'scalar'):
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= w_update
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+        else:
+            α = self.input.α_split.get_value(p.points) # We did not get this before if f is zero!
+            α_next = self.input.α_split.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α_split.get_grad_laplacian(points_next)
+            σ_next = self.input.σ_split.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= (w_ * w_s)
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+
+        if dr.hint(max_length is not None, mode = 'scalar'):
+            if p.path_length > max_length:
+                p.w *= tput_kill
+                p.w_split *= tput_kill
+
+        active &= dr.isfinite(w_update)
+        p.points = points_next
+        p.path_length += 1
+        return p
+
+    
+    @dr.syntax
+    def take_derivative_step(self, derivative_dir : Point2f, L : ArrayXf, p : Particle, mode : dr.ADMode, dL : ArrayXf, 
+                             active : Bool, active_conf : ArrayXb = ArrayXb(True), illumination_mask : Bool = Bool(True)) -> Particle:
+        "Computes the directional derivative of the computation!"
+        # There is no way to sample Green's function analytically. Use polynomial.
+        primal = (mode == dr.ADMode.Primal)
+        greenGrad = GreensFunctionPolynomial(dim = DIM.Two, newton_steps=10, grad = True)
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False)
+        bi.r = bi.d
+        # Decrease radius if it is big. 
+        σ_bar = self.input.σ_bar
+        z = Float(0)
+        if self.use_accel:
+            bi.r, σ_bar, z = self.input.get_Rσz(p.points, bi.r)
+        else:
+            z = bi.r * dr.sqrt(σ_bar)
+            if z > self.max_z:
+                bi.r *= self.max_z / z
+                z = self.max_z
+        
+        greenGrad.initialize(z)
+        active &= ~(bi.is_d & bi.is_e)
+
+        # This value is used pretty often.
+        with dr.resume_grad(when = not primal):
+            α = self.input.α.get_value(p.points)
+
+        # Get the contribution of the source term
+        f_cont = Float(0)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            sample_source = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+            #if illumination_mask:
+            # Sample norm of the Gradient with the Greens function.
+            r_f, normdG_f = greenGrad.sample(sample_source[0], bi.r, σ_bar)
+            dir_f, _, sign_f = sample_cosine_direction(sample_source[1], derivative_dir)
+            points_f = p.points + r_f * dir_f 
+            with dr.resume_grad(when=not primal):
+                    f_f = self.input.f.get_value(points_f)
+                    α_f = self.input.α.get_value(points_f)
+                    f_cont =  f_f * normdG_f * dr.rcp(dr.sqrt(α_f * α)) * sign_f * 2 / dr.pi
+                    if dr.isnan(f_cont) | ~illumination_mask:
+                        f_cont = Float(0)
+        f_cont = dr.select(active_conf, f_cont, 0) 
+        L += f_cont if primal else -f_cont
+
+        # If diffusion is not constant, we need to split the path into 3, otherwise 2.
+        is_alpha_c = isinstance(self.input.α, ConstantCoefficient)
+        prob_paths = Float(0.5) if is_alpha_c else Float(1/3)
+        w_update = 1 / prob_paths
+        selected_path = UInt(0)
+        sign_next = Float(1)
+        points_next = Point2f(0)
+        _ = Float(0)
+        sample_rec = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+        if sample_rec[0] < prob_paths:
+            sample_rec[0] /= prob_paths
+            r_next, normdG = greenGrad.sample(sample_rec[0], bi.r, σ_bar)
+            dir, _, sign_next = sample_cosine_direction(sample_rec[1], derivative_dir)
+            points_next = p.points +  r_next * dir
+            w_update *= normdG * sign_next * 2 / dr.pi
+            selected_path = UInt32(0)
+        elif sample_rec[0] < 2 * prob_paths:
+            sample_rec[0] = (sample_rec[0] - prob_paths) / prob_paths
+            points_next, _, sign_next = sample_cosine_boundary(sample_rec[1], p.points, bi.r, derivative_dir)
+            w_update *= 4 * sign_next * bi.r * eval_dP_norm(bi.r, σ_bar)
+            selected_path = UInt32(1)
+        else:
+            points_next = p.points
+            selected_path = UInt32(2)
+
+        # Compute the throughput updates that needs to be diffrentiated.
+        with dr.resume_grad(when=not primal):
+            # The first path (Volume sampling)
+            σ_next = self.input.σ.get_value(points_next)
+            α_next = self.input.α.get_value(points_next)
+
+            if dr.hint(is_alpha_c, mode = 'scalar'):
+                if selected_path == 0:
+                    w_update *= (σ_bar - σ_next / α_next) 
+            else:
+                if dr.hint(self.input.f.is_zero, mode = 'scalar'): 
+                    α = self.input.α.get_value(p.points) # We did not get this before if f is zero!
+                grad_α, _ = self.input.α.get_grad_laplacian(p.points)
+                grad_α_next, laplacian_α_next = self.input.α.get_grad_laplacian(points_next)
+                σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+
+                w_update *= dr.select(selected_path == 0, dr.sqrt(α_next / α) * (σ_bar - σ_new), 1)
+                w_update *= dr.select(selected_path == 1, dr.sqrt(α_next / α), 1)
+                w_update *= dr.select(selected_path == 2, -dr.rcp(2 * α) * dr.dot(grad_α, derivative_dir), 1)
+
+            # Apply path replay gradient contribution.
+            prb_cont = dr.select(active, L * w_update / dr.detach(w_update), 0)
+            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                dr.backward(dr.sum((prb_cont + f_cont) * dL))
+            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                dL += dr.forward_to(dr.sum(prb_cont + f_cont))
+
+        # Update throughput and next points.    
+        p.points = points_next
+        p.w *= w_update
+        return p 
+    
+
+def is_one(index : Array4u64) -> Bool:
+    return (index[0] == UInt64(1)) & (index[1] == UInt64(0)) & (index[2] == UInt64(0)) & (index[3] == UInt64(0))
+
+@dr.syntax
+def shift_left(index : Array4u64):
+    index_new = Array4u64(index)
+    for i in range(3, 0, -1):
+        index_new[i]  = index[i] << 1
+        if dr.lzcnt(index[i-1]) == 0:
+            index_new[i] += 1
+    index_new[0] = index[0] << 1
+    return index_new
+
+@dr.syntax
+def MSB2(index : Array4u64):
+    "Find the 2nd MSB and throw it out"
+    index_residual = UInt32(0)
+    index_full = UInt32(0)
+    for i in range(3, -1, -1):
+        if index_residual == 0:
+            index_residual += (64 - UInt32(dr.lzcnt(index[i])))
+            index_full = UInt32(i)
+
+    if (index_residual == 0) & (index_full > 0):
+        index_full -= 1
+        index_residual = UInt32(64)
+    
+    msb2 = UInt64(0)
+    thrown = Array4u64(index)
+    for i in range(4):
+        if index_full == i:
+            if index_residual > 1:
+                shift_num = (index_residual - 2)
+                msb2 = (index[i] >> shift_num) & 1
+                msb2e = UInt64(1) << shift_num
+                thrown[i]  = index[i] % msb2e + msb2e
+            elif index_residual == 1:
+                if i > 0:
+                    msb2 = (index[i-1] >> 63) & 1
+                    thrown[i] = UInt64(0)
+                    msb2e  = UInt64(1)<<63
+                    thrown[i-1] = index[i-1] % msb2e + msb2e
+    return msb2, thrown
+
+
+def split_particle(particle : Particle):
+    new_particle_state = particle.sampler.next_uint64()
+    shifted = shift_left(particle.traverse_h)
+    new_particle = Particle(points = particle.points,
+                            w=particle.w/2,
+                            w_split = particle.w_split/2,
+                            sampler = PCG32(particle.sampler),
+                            path_index = particle.path_index,
+                            path_length = particle.path_length,
+                            traverse_h = Array4u64(shifted))
+    new_particle.traverse_h[0] += UInt64(1)
+
+    new_particle.sampler.state = new_particle_state
+    particle.w /= 2
+    particle.w_split /= 2
+    particle.traverse_h = Array4u64(shifted) 
+    return particle, new_particle

data/PDE2D/Solver/variable/wos_variable_rejection.py

@@ -0,0 +1,153 @@
+import numpy as np
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from ...BoundaryShape.interaction import BoundaryInfo
+from PDE2D.BoundaryShape import *
+from .wos_variable import *
+
+class WosVariableRejection(WosVariable):
+    def __init__(self, input : DataHolder, seed : int = 37, weight_window = [0.5, 2],  max_z : float = 4, 
+                 green_sampling : GreenSampling = 0, newton_steps : int = 5, use_accelaration : bool = True,
+                 opt_params : list[str] = []):
+        super().__init__(input, seed,  weight_window, max_z, 
+                         green_sampling, newton_steps, use_accelaration, opt_params)
+        
+    @dr.syntax(print_code = False)
+    def take_step(self, L : ArrayXf, p : Particle, mode : dr.ADMode, split : Split, dL : ArrayXf, active : Bool, active_conf : ArrayXb = ArrayXb(True),
+                  conf_numbers : list[UInt32] = None, max_length : UInt32 = None, tput_kill : Float = Float(0.8), 
+                  fd_forward : bool = False, illumination_mask : Bool = Bool(True)):
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+        
+        primal = (mode == dr.ADMode.Primal)
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+        
+        if bi.is_far:
+            p.thrown = Bool(True)
+            active &= Bool(False)
+        
+        # Decrease radius if it is big. 
+        σ_bar = self.input.σ_bar
+        z = Float(0)
+        if self.use_accel:
+            bi.r, σ_bar, z = self.input.get_Rσz(p.points, bi.r)
+        else:
+            z = bi.r * dr.sqrt(σ_bar)
+            if z > self.max_z:
+                bi.r *= self.max_z / z
+                z = self.max_z
+        
+        self.green.initialize(z)
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+        
+        # Add the dirichlet boundary contribution in epsilon-shell!
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)
+
+        L += added_near if primal else -added_near
+
+        with dr.resume_grad(when=not primal):
+            α = self.input.α.get_value(p.points)
+            
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+
+        f_cont = Float(0)        
+        # Add the source contribution.
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            sample_source = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+            #if illumination_mask:
+            #r_vol, normG = self.green.sample(sample_source[0], bi.r, σ_bar)
+            r_vol, normG = self.sampleGreenRejection(p, bi.r, σ_bar)
+            dir_vol, _ = sample_uniform_direction(sample_source[1])
+            points_vol = p.points + r_vol * dir_vol 
+            with dr.resume_grad(when=not primal):
+                α_vol = self.input.α.get_value(points_vol)
+                f_vol = self.input.f.get_value(points_vol) 
+                f_cont = p.w * f_vol * normG / dr.sqrt(α * α_vol)
+                if dr.isnan(f_cont) | ~illumination_mask:
+                    f_cont = Float(0)
+
+        f_cont = dr.select(active_conf, f_cont, 0)
+        L += f_cont if primal else -f_cont
+
+        # Now select between boundary or volume sampling (2nd paper, eqn 28)
+        normG = self.green.eval_norm(bi.r, σ_bar)
+        prob_vol =  σ_bar * normG
+        sample_rec = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+        sample_vol = active & (sample_rec[0] < prob_vol)
+        sample_rec[0] = dr.select(sample_vol, sample_rec[0] / prob_vol, (sample_rec[0] - prob_vol) / (1-prob_vol))
+
+        r_next = Float(bi.r)
+        if sample_vol:
+            #r_next = self.green.sample(sample_rec[0], bi.r, σ_bar)[0]
+            r_next = self.sampleGreenRejection(p, bi.r, σ_bar)[0]
+            
+        dir_next, _ = sample_uniform_direction(sample_rec[1])
+        points_next = p.points + r_next * dir_next
+        
+
+        with dr.resume_grad(when=not primal):
+            α_next = self.input.α.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α.get_grad_laplacian(points_next)
+            σ_next = self.input.σ.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            w_update = w_ * w_s
+            # Boundary and Volume Contribution
+            prb_cont = dr.select(dr.isfinite(w_update), L * w_update / dr.detach(w_update), 0.0)
+
+            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                dr.backward(dr.sum((prb_cont + f_cont) * dL)) 
+            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                dL += dr.forward_to(dr.sum(prb_cont + f_cont))
+            
+        p.w *= w_update
+        # If we are not doing fd computation, then just use the original coefficient.
+        if dr.hint((not fd_forward), mode = 'scalar'):
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= w_update
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+        else:
+            α = self.input.α_split.get_value(p.points) # We did not get this before if f is zero!
+            α_next = self.input.α_split.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α_split.get_grad_laplacian(points_next)
+            σ_next = self.input.σ_split.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= (w_ * w_s)
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+
+        if dr.hint(max_length is not None, mode = 'scalar'):
+            if p.path_length > max_length:
+                p.w *= tput_kill
+                p.w_split *= tput_kill
+
+        active &= dr.isfinite(w_update)
+        p.points = points_next
+        p.path_length += 1
+        return p
+    
+    @dr.syntax
+    def sampleGreenRejection(self, p : Particle, R : Float, σ : Float):
+        # We apply rejection sampling based on WosVariable paper.
+        if R <= σ:
+            upper_bound = dr.maximum(2.2 * dr.maximum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.maximum(dr.sqrt(R), dr.sqrt(σ)))
+        else:
+            upper_bound = dr.maximum(2.2 * dr.minimum(dr.rcp(R), dr.rcp(σ)), 0.6 * dr.minimum(dr.sqrt(R), dr.sqrt(σ)))
+
+        sample1 = p.sampler.next_float32() * R
+        sample2 = p.sampler.next_float32() 
+        pdf = self.green.eval_pdf_only(sample1, R, σ)
+        while(sample2 * upper_bound > pdf):
+            sample1 = p.sampler.next_float32() * R
+            sample2 = p.sampler.next_float32()
+            pdf = self.green.eval_pdf_only(sample1, R, σ)
+        return sample1, self.green.eval_norm(R, σ)

data/PDE2D/Solver/variable/wost_variable.py

@@ -0,0 +1,232 @@
+import numpy as np
+import sys
+from ..data_holder import DataHolder
+from ...Coefficient import *
+from ...Sampling import *
+from .wos_variable import *
+
+class WostVariable(WosVariable):
+    def __init__(self, input : DataHolder, seed : int = 37, weight_window = [0.5, 2], 
+                 max_z : float = 4, green_sampling : GreenSampling = 0,
+                 newton_steps : int = 5, use_accelaration : Bool = True, opt_params : list[str] = []):
+        super().__init__(input, seed,  weight_window, max_z, 
+                         green_sampling, newton_steps, use_accelaration, opt_params)
+    
+    @dr.syntax
+    def take_step(self, L : ArrayXf, p : Particle, mode : dr.ADMode, split : Split, dL : ArrayXf, active : Bool, active_conf : ArrayXb = ArrayXb(True),
+                  conf_numbers : list[UInt32] = None, max_length : UInt32 = None, tput_kill : Float = Float(0.8), fd_forward : bool = False, 
+                  illumination_mask: Bool = Bool(True)) -> Particle:
+        primal = (mode == dr.ADMode.Primal)
+
+        if conf_numbers is not None:
+            num_conf = len(conf_numbers)
+        else:
+            num_conf = 1
+    
+        # Apply boundary interaction.
+        bi = self.input.shape.boundary_interaction(p.points, star_generation = False, conf_numbers = conf_numbers)
+
+        if bi.is_far:
+            p.thrown = Bool(True)
+            active &= Bool(False)
+        
+        # Decrease radius to sample from a reasonable Green's function.
+        σ_bar = self.input.σ_bar
+        z = Float(0)
+        if self.use_accel:
+            bi.r, σ_bar, z = self.input.get_Rσz(p.points, bi.r)
+        else:
+            z = bi.r * dr.sqrt(σ_bar)
+            if z > self.max_z:
+                bi.r *= self.max_z / z
+                z = self.max_z
+        
+        self.green.initialize(z)
+        # Generate stars.
+        bi = self.input.shape.star_generation(bi)
+
+        # End the paths if we are in the epsilon shell of a dirichlet boundary.
+        dirichlet_ending = (active & bi.is_e & bi.is_d) 
+        
+        # Add the dirichlet boundary contribution in epsilon-shell!
+        added_near = dr.select(dirichlet_ending & active_conf, p.w * bi.dval, 0)
+        
+        L += added_near if primal else -added_near
+        
+        # Remove the channels in which the walk is finished. 
+        active &= ~dirichlet_ending
+
+        #This is used throughout the integrator. So we compute it in the beginning.
+        with dr.resume_grad(when = not primal):
+            α = self.input.α.get_value(p.points)
+        
+        # Source term contribution.
+        f_cont = Float(0)
+        if dr.hint(not self.input.f.is_zero, mode = 'scalar'):
+            sample_source = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+            #if illumination_mask:
+            r_f, normG = self.green.sample(sample_source[0], bi.r, σ_bar)
+            dir_f, _ = sample_star_direction(sample_source[1], bi.is_star & bi.on_boundary, bi.bn)
+            points_f = mi.Point2f(p.points + r_f * dir_f)
+            # If we are on a star, The sampled point might be outside of the boundary.
+            # We need to check this with a ray intersection.
+            ri_f = self.input.shape.ray_intersect(bi, dir_f)
+            with dr.resume_grad(when=not primal):
+                α_f = self.input.α.get_value(points_f)
+                f_f = self.input.f.get_value(points_f) 
+                f_cont = p.w * f_f * normG / dr.sqrt(α * α_f)
+                #if dr.isnan(f_cont) | (r_f > ri_f.t) | ~illumination_mask:
+                #    f_cont = Float(0)
+                f_cont = dr.select(active_conf, f_cont, 0)
+        
+        L += f_cont if primal else -f_cont
+
+        
+        # Neumann boundary contribution.
+        # If we have a continous Neumann on the boundary, we need to sample it.
+        n_cont_cont = dr.zeros(ArrayXf, shape = L.shape)
+
+        if dr.hint(self.input.has_continuous_neumann, mode = 'scalar'):
+            # If we have a special sampling scheme based on boundary values, then we need to get all of the values.
+            if dr.hint(self.input.NEE == NEE.Special, mode = 'scalar'):
+                for i in range(num_conf):
+                    conf_number = None if conf_numbers is None else conf_numbers[i]
+                    #==if illumination_mask:
+                    sample_neumann = p.sampler.next_float32()
+                    dist_n, n_val, pdf_n_r, p_n = self.input.sampleNEE_special(bi, sample_neumann, conf_number)
+                    G_n_r = self.green.eval(dist_n, bi.r, σ_bar)
+                    
+                    if ((pdf_n_r > 0) & (dist_n < bi.r) & (dist_n > 0)):
+                        n_cont_cont[i] =  -p.w * n_val * G_n_r / pdf_n_r
+
+                    with dr.resume_grad(when = not primal):
+                        α_n = self.input.α.get_value(p_n)
+                        n_cont_cont[i] *= dr.sqrt(dr.rcp( α * α_n)) if dr.hint(self.input.shape.measured_current, mode = 'scalar') else dr.sqrt(α_n / α)
+                    
+                    if dr.isnan(n_cont_cont[i]) | ~illumination_mask:
+                        n_cont_cont[i] = Float(0)
+            else:
+                # Here n_val is an ArrayXf.
+                dist_n, n_val, pdf_n_r, p_n = self.input.sampleNEE(bi, p.sampler.next_float32(), conf_numbers)
+                G_n_r = self.green.eval(dist_n, bi.r, σ_bar)
+                
+                n_cont_cont_ = Float(0)
+                if ((pdf_n_r > 0) & (dist_n < bi.r) & (dist_n > 0)):
+                    n_cont_cont_ = -p.w * G_n_r / pdf_n_r
+
+                with dr.resume_grad(when = not primal):
+                    α_n = self.input.α.get_value(p_n)
+                    n_cont_cont_ *= dr.sqrt(dr.rcp( α * α_n)) if dr.hint(self.input.shape.measured_current, mode = 'scalar') else dr.sqrt(α_n / α)
+                
+                if dr.isnan(n_cont_cont_) | ~illumination_mask:
+                    n_cont_cont_ = Float(0)
+                n_cont_cont = n_val * n_cont_cont_
+        
+        
+        # Now, we get the all necessary delta distributions on the boundary (a.k.a. point current injections).
+        n_cont_delta =dr.zeros(ArrayXf, shape = L.shape)
+    
+        if dr.hint(self.input.has_delta, mode = 'scalar'):
+            for i in range(num_conf):
+                conf_number = None if conf_numbers is None else conf_numbers[i]
+                #if dr.hint(illumination_mask, mode="evaluated"):
+                dist_n, n_val, pdf_n_r, sampled_n = self.input.get_point_neumann(bi, conf_number)
+                # We can have multiple relevant electrodes, add all the contribution.
+                for d, n, pdf_r, p_n in zip(dist_n, n_val, pdf_n_r, sampled_n):
+                    n_cont_delta_iter = Float(0)
+                    G_n_r = self.green.eval(d, bi.r, σ_bar)
+                    with dr.resume_grad(when = not primal):
+                        α_n = self.input.α.get_value(p_n)
+                        if (pdf_r > 0) & (d <= bi.r):
+                            n_cont_delta_iter = -p.w * n * G_n_r / pdf_r
+                        # Here, we need to apply a correction term if the given neumann boundary is a current value.
+                        n_cont_delta_iter *= dr.sqrt(dr.rcp(α * α_n)) if dr.hint(self.input.shape.measured_current, mode = 'scalar') else dr.sqrt(α_n / α)
+                        n_cont_delta[i] += n_cont_delta_iter
+            
+                if dr.isnan(n_cont_delta[i]) | ~illumination_mask:
+                    n_cont_delta[i] = Float(0)
+        
+        # Compute the total neumann contribution.
+        with dr.resume_grad(when = not primal):
+            n_cont = n_cont_cont + n_cont_delta 
+            # There is a factor of 2 for smooth neumann boundaries if we are exactly on the boundary. (Check WoSt paper.)
+            if bi.on_boundary:
+                n_cont *= 2
+            n_cont = dr.select(active_conf, n_cont, 0)
+            
+        L += n_cont if primal else -n_cont
+        
+        # Sampling the recursive term.
+        # Now select between boundary or volume sampling (2nd paper, eqn 28)
+        sample_rec = Point2f(p.sampler.next_float32(), p.sampler.next_float32())
+        normG = self.green.eval_norm(bi.r, σ_bar)
+        prob_vol =  σ_bar * normG
+        sample_vol = active & (sample_rec[0] < prob_vol)
+        sample_rec[0] = dr.select(sample_vol, sample_rec[0] / prob_vol, (sample_rec[0] - prob_vol) / (1-prob_vol))
+        # Sample direction
+        dir_next, _, _ = bi.sample_recursive(sample_rec[1])
+        # We will stamp the next sampled point in case it is sampled outside of the star.
+        ri_next = self.input.shape.ray_intersect(bi, dir_next)
+        # Radius sampling with the Green's function.
+        r_next = Float(bi.r)
+        if sample_vol:
+            r_next = self.green.sample(sample_rec[0], bi.r, σ_bar)[0]
+        
+        # Stamping. Also we need to update the sample vol term for correct throughput update.
+        on_boundary_next = (ri_next.t < r_next)
+        sample_vol &= ~on_boundary_next
+        if on_boundary_next:
+            r_next = ri_next.t
+
+        # Next iteration points.
+        points_next = mi.Point2f(ri_next.origin + r_next * dir_next)
+
+        with dr.resume_grad(when=not primal):
+            α_next = self.input.α.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α.get_grad_laplacian(points_next)
+            σ_next = self.input.σ.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ =  dr.sqrt(α_next / α)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            w_update = w_ * w_s
+            # Path replay gradient contribution.
+            prb_cont = dr.select(dr.isfinite(w_update), L * w_update / dr.detach(w_update), 0.0)
+            
+            # Here, all the gradients from different contributions computed in single backward pass.
+            grad_cont = prb_cont + f_cont + n_cont
+            if dr.hint(mode == dr.ADMode.Backward, mode = 'scalar'):
+                dr.backward(dr.sum(grad_cont * dL))
+            elif dr.hint(mode == dr.ADMode.Forward, mode = 'scalar'):
+                dL += dr.forward_to(dr.sum(grad_cont))
+        
+        active &= dr.isfinite(w_update)
+        
+        # If we are not doing fd computation, then just use the original coefficient.
+        if dr.hint((not fd_forward), mode = 'scalar'):
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= w_update
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+        else: # Otherwise use the non-deviated coefficients for throughput update.
+            α = self.input.α_split.get_value(p.points) # We did not get this before if f is zero!
+            α_next = self.input.α_split.get_value(points_next)
+            grad_α_next, laplacian_α_next = self.input.α_split.get_grad_laplacian(points_next)
+            σ_next = self.input.σ_split.get_value(points_next)
+            σ_new = self.σ_(σ_next, α_next, grad_α_next, laplacian_α_next)
+            w_ = dr.select(active, dr.sqrt(α_next / α), 1.0)
+            w_s = dr.select(sample_vol, (1.0 - σ_new / σ_bar), 1.0)
+            if dr.hint(split == Split.Agressive, mode = 'scalar'):
+                p.w_split *= (w_ * w_s)
+            elif dr.hint(split == Split.Normal, mode = 'scalar'):
+                p.w_split *= w_s
+        
+        if dr.hint(max_length is not None, mode = 'scalar'):
+            if p.path_length > max_length:
+                p.w *= tput_kill
+                p.w_split *= tput_kill
+
+        # Update the points for the next iteration.
+        p.w *= w_update
+        p.points = points_next
+        p.path_length += 1
+        return p

data/PDE2D/__init__.py

@@ -0,0 +1,49 @@
+
+import drjit as dr
+import mitsuba as mi
+from enum import IntEnum
+
+
+import os
+PATH = os.path.dirname((os.path.dirname(__file__)))
+
+#from  drjit.cuda.ad import (ArrayXu, ArrayXu64, ArrayXf, ArrayXf64, ArrayXb, Array4u64)
+
+#double_precision = True
+#source = dr.cuda.ad
+
+#vars = ["ArrayXu", "ArrayXu64", "ArrayXf", "ArrayXf64", "ArrayXb", "Array4u64"]
+
+#if double_precision:
+#    vars_precision = ["ArrayXu", "ArrayXu64", "ArrayXf64", "ArrayXf64", "ArrayXb", "Array4u64"]
+#else:
+#    vars_precision = ["ArrayXu64", "ArrayXu64", "ArrayXf", "ArrayXf64", "ArrayXb", "Array4u64"]
+
+#for name, name_precision in zip(vars, vars_precision):
+#    globals()[name] = getattr(source, name_precision)
+ArrayXf = None
+ArrayXu = None
+if "double" in mi.variant():
+    ArrayXf = dr.cuda.ad.ArrayXf64 if "cuda" in mi.variant() else dr.llvm.ad.ArrayXf64
+    ArrayXu = dr.cuda.ad.ArrayXu64 if "cuda" in mi.variant() else dr.llvm.ad.ArrayXu64
+else:
+    ArrayXf = dr.cuda.ad.ArrayXf if "cuda" in mi.variant() else dr.llvm.ad.ArrayXf
+    ArrayXu = dr.cuda.ad.ArrayXu if "cuda" in mi.variant() else dr.llvm.ad.ArrayXu
+
+ArrayXu64 =  dr.cuda.ad.ArrayXu64 if "cuda" in mi.variant() else dr.llvm.ad.ArrayXu64
+ArrayXf64 =  dr.cuda.ad.ArrayXf64 if "cuda" in mi.variant() else dr.llvm.ad.ArrayXf64
+Array4u64 =  dr.cuda.ad.Array4u64 if "cuda" in mi.variant() else dr.llvm.ad.Array4u64
+ArrayXb =  dr.cuda.ad.ArrayXb if "cuda" in mi.variant() else dr.llvm.ad.ArrayXb
+
+class DIM(IntEnum):
+    Two = 0,
+    Three = 1
+
+class GreenSampling(IntEnum):
+    Polynomial = 0,
+    Analytic = 1
+
+class Split(IntEnum):
+    Naive = 0,
+    Normal = 1,
+    Agressive = 2

data/PDE2D/utils/__init__.py

@@ -0,0 +1,7 @@
+from .helpers import *
+from .sketch import *
+from .imageUtils import *
+from .optimization import *
+from .sketch import *
+from .common import *
+from .optimizer import Optimizer, SGD, Adam

data/PDE2D/utils/animation.py

@@ -0,0 +1,127 @@
+import numpy as np
+from PDE2D import PATH
+from PDE2D.utils.imageUtils import create_image_points, create_image_from_result
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec 
+import matplotlib.animation as animation
+import os
+'''
+def create_animation(record, path, iternum, bbox, wos, max_range = None, wos_obj = None, resolution = [512, 512], 
+                     opt_param = "diffusion.texture.tensor", fileset = None, out_val = None, 
+                     optimize_electrode = True, primal_range = ):
+
+    name = "reconstruction" if max_range is None else "reconstruction-scaled"
+    if (wos_obj is None) and (fileset is None):
+        fig , ((ax1, ax2), (ax3, ax4)) = plt.subplots(1,2, figsize = (10, 10))
+    else:
+        fig = plt.figure(figsize=(8, 6))
+        g = gridspec.GridSpec(16, 20, figure = fig, wspace = 0.5, hspace=0.1)
+        ax0 = fig.add_subplot(g[0:9,0:9])
+        ax1 = fig.add_subplot(g[0:9,10:19])
+        ax2 = fig.add_subplot(g[10:,:19])
+
+    coeff_name = opt_param.split(".")[0]
+
+    coeff = wos.input.get_coefficient(coeff_name)
+    
+    if fileset is not None:
+        image_file = os.path.join(PATH ,f"eit-data/target_photos/fantom_{fileset}.jpg")
+        image = plt.imread(image_file)
+        ax0.imshow(image)
+        ax0.set_axis_off()
+        ax0.set_title("Objective")
+
+    elif wos_obj is not None:
+        coeff_obj = wos_obj.input.get_coefficient(coeff_name)
+
+        points = create_image_points(bbox, resolution, spp=1, centered = True)
+        vals = coeff_obj.get_value(points)
+        if out_val is not None:
+            mask = wos_obj.input.shape.inside_closed_surface_mask(points)
+            vals = dr.select(mask, vals, out_val)
+        obj_image, _ = create_image_from_result(vals, resolution)
+        if max_range is None:
+            plot_image(obj_image[0], ax0)
+        else:
+            plot_image(obj_image[0], ax0, input_range = max_range)
+        ax0.set_title("Objective")
+        wos_obj.input.shape.sketch(ax0, bbox, resolution, sketch_center = True)
+
+    if max_range is None:
+        maxval  = -np.inf
+        minval = np.inf 
+        for i in range(iternum):
+            tensor = TensorXf(record[f"{opt_param}-{i}"]).numpy()
+            maxval = max(maxval, np.max(tensor))
+            minval = min(minval, np.min(tensor))
+        max_range = [minval, maxval]
+    coeff.tensor = TensorXf(record[f"{opt_param}-0"])
+    coeff.update_texture()
+
+    dirichlet_str = "dirichletpoints-0"
+    dirichlet_points = None
+    if dirichlet_str in record:
+        dirichlet_points_ = record[f"dirichletpoints-0"]
+        if dirichlet_points_.shape[0] > 0:
+            dirichlet_points = Point2f(dirichlet_points_.T)
+            dirichlet_points = point2sketch(dirichlet_points, bbox, resolution).numpy()
+    
+    im, s, line = start_animation(ax1, ax2, record, bbox, wos, dirichlet_points, coeff, resolution, max_range, out_val = out_val)
+    update = lambda iteration : update_animation(wos, iteration, record, coeff, resolution, im, s, line, bbox, opt_param, out_val = out_val)
+
+    ani = animation.FuncAnimation(fig=fig, func=update, frames=iternum+1, interval=30)
+    writervideo = animation.FFMpegWriter(fps=25) 
+    ani.save(filename=f"{path}/{name}.gif", writer="pillow")
+    ani.save(f"{path}/{name}.mp4", writer=writervideo)
+
+def start_animation(ax1, ax2, record, bbox, wos, in_boundary_points, coeff, resolution, max_range, out_val : float = None):
+    points = create_image_points(bbox, resolution, spp = 4, centered = False)
+    vals = coeff.get_value(points)
+    if out_val is not None:
+        mask = wos.input.shape.inside_closed_surface_mask(points)
+        vals = dr.select(mask, vals, out_val)
+    image, _ = create_image_from_result(vals, resolution)
+    im = plot_image(image[0], ax1, input_range = max_range)
+    wos.input.shape.sketch(ax1, bbox, resolution, sketch_center = True, sketch_in_boundaries = False)
+    s = None
+    if in_boundary_points is not None:
+        s = ax1.scatter(in_boundary_points[0], in_boundary_points[1], s = 5, color = "red")
+    
+    ax1.set_title("Reconstruction")
+
+    loss = record["loss"].sum(axis = 1).squeeze()
+    loss_reg = record["loss-reg"]
+    iters = np.arange(0, len(loss))
+    ax2.plot(iters, loss + loss_reg, color = "grey", ls = "-.")
+    line = ax2.plot(iters[0], loss[0], color = "red")[0]
+    ax2.yaxis.tick_right()
+    ax2.set_yscale("log")
+    ax2.set_yscale("log")
+    ax2.grid()
+    ax2.set_ylabel("Loss")
+    return im, s, line
+    
+def update_animation(wos, iteration, record, coeff, resolution, im, s, line, bbox, opt_param, out_val : float = None):
+    coeff.tensor = TensorXf(record[f"{opt_param}-{iteration}"])
+    coeff.update_texture()
+    points = create_image_points(bbox, resolution, spp = 4, centered = False)
+    vals = coeff.get_value(points)
+    if out_val is not None:
+        mask = wos.input.shape.inside_closed_surface_mask(points)
+        vals = dr.select(mask, vals, out_val)
+    image, _ = create_image_from_result(vals, resolution)
+    im.set_data(image[0])
+    if s is not None:
+        dirichlet_points = record[f"dirichletpoints-{iteration}"]
+        if dirichlet_points.shape[0] > 0:
+            dirichlet_points = Point2f(dirichlet_points.T)
+            dirichlet_points = point2sketch(dirichlet_points, bbox, resolution).numpy()
+            s.set_offsets(dirichlet_points.T)
+
+    loss = record["loss"].sum(axis = 1)[:iteration].squeeze()
+    loss_reg = record["loss-reg"][:iteration]
+    iters = np.arange(0, iteration)
+    line.set_xdata(iters)
+    line.set_ydata(loss + loss_reg)
+
+'''

data/PDE2D/utils/common.py

@@ -0,0 +1,173 @@
+import os
+from os.path import join
+import subprocess
+
+import sys
+__SCRIPT_DIR = os.path.realpath(os.path.dirname(__file__))
+sys.path.insert(0, join(__SCRIPT_DIR, '../../mitsuba3/build/python/'))
+FIGURE_DIR = os.path.realpath(join(__SCRIPT_DIR, '..', 'outputs', 'figures'))
+SCENE_DIR = os.path.realpath(join(__SCRIPT_DIR, '..', 'scenes'))
+PAPER_FIG_OUTPUT_DIR = os.path.realpath(join(__SCRIPT_DIR, '..', '..', 'phd-thesis', 'chapters'))
+del __SCRIPT_DIR
+
+import numpy as np
+from string import ascii_lowercase
+
+import drjit as dr
+
+import matplotlib
+
+# Override any style changes by VSCode
+if hasattr(matplotlib, "style"):
+    matplotlib.style.use('default')
+
+# Use double the true size for figures, as this leads to nicer, thinner plot lines
+COLUMN_WIDTH = 3.37704722222
+TEXT_WIDTH = 7.08743055556
+DEFAULT_FONTSIZE = 8  # Font size used by captions in ACM format
+DEFAULT_FONTSIZE_SMALL = 6.5
+
+MPL_STYLE = {
+    "text.usetex": True,
+    "text.color": 'black',
+    "font.size": DEFAULT_FONTSIZE,
+    "axes.titlesize": DEFAULT_FONTSIZE,
+    "axes.labelsize": DEFAULT_FONTSIZE_SMALL,
+    "xtick.labelsize": DEFAULT_FONTSIZE_SMALL,
+    "ytick.labelsize": DEFAULT_FONTSIZE_SMALL,
+    "legend.fontsize": DEFAULT_FONTSIZE_SMALL,
+    "figure.titlesize": DEFAULT_FONTSIZE,
+    "text.latex.preamble": r"""\usepackage{libertine}
+                               \usepackage[libertine]{newtxmath}
+                               \usepackage{amsmath}
+                               \usepackage{amsfonts}
+                               \usepackage{bm}
+                               \usepackage{bbm}""",
+    "pdf.fonttype": 42,
+    "ps.fonttype": 42,
+    'axes.edgecolor':'black',
+    'axes.linewidth': 0.4,
+    'xtick.major.size': 0.5,
+    'xtick.major.width': 0.5,
+    'xtick.minor.size': 0.25,
+    'xtick.minor.width': 0.5,
+
+    'ytick.major.size': 0.5,
+    'ytick.major.width': 0.5,
+    'ytick.minor.size': 0.25,
+    'ytick.minor.width': 0.5,
+
+    'lines.linewidth': 0.75,
+    'patch.linewidth': 0.5,
+
+    'grid.linewidth': 0.5,
+}
+
+# MPL_STYLE['savefig.facecolor'] = "0.8"
+
+matplotlib.rcParams.update(MPL_STYLE)
+
+
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+
+#import seaborn as sns
+#sns.set()
+matplotlib.rcParams.update(MPL_STYLE)
+
+"""
+def read_img(fn, exposure=0, tonemap=True, background_color=None,
+            handle_inexistant_file=False):
+    if handle_inexistant_file and not os.path.isfile(fn):
+        return np.ones((256, 256, 3)) * 0.3
+    bmp = mi.Bitmap(fn)
+    if tonemap:
+        if background_color is not None:
+            img = np.array(bmp.convert(mi.Bitmap.PixelFormat.RGBA, mi.Struct.Type.Float32, False))
+            background_color = np.array(background_color).ravel()[None, None, :]
+            # img = img[:, :, :3] * img[..., -1][..., None] + (1.0 - img[..., -1][..., None]) * background_color
+            img = img[:, :, :3] + (1.0 - img[..., -1][..., None]) * background_color
+        else:
+            img = np.array(bmp.convert(mi.Bitmap.PixelFormat.RGB, mi.Struct.Type.Float32, False))
+        img = img * 2 ** exposure
+
+        return np.clip(np.array(mi.Bitmap(img).convert(mi.Bitmap.PixelFormat.RGB, mi.Struct.Type.Float32, True)), 0, 1)
+    else:
+        return np.array(bmp)
+
+def tonemap(img):
+    return np.clip(np.array(mi.Bitmap(img).convert(mi.Bitmap.PixelFormat.RGB, mi.Struct.Type.Float32, True)), 0, 1)
+"""
+
+def save_fig(fig_name, fig_sub_dir, dpi=300, pad_inches=0.005, bbox_inches='tight', compress=True):
+    output_dir = os.path.join(PAPER_FIG_OUTPUT_DIR, fig_sub_dir, fig_name)
+    os.makedirs(output_dir, exist_ok=True)
+    fn = join(output_dir, fig_name + '.pdf')
+    orig_fn = fn
+    if compress:
+        fn = fn.replace('.pdf', '_uc.pdf')
+    plt.savefig(fn, format='pdf', dpi=dpi, bbox_inches=bbox_inches, pad_inches=pad_inches)
+    # plt.savefig(fn, format='pdf', dpi=dpi)
+
+    if compress:
+        gs = f"gs -o {orig_fn} -dQUIET -f -dNOPAUSE -dBATCH "
+        gs += "-sDEVICE=pdfwrite -dPDFSETTINGS=/prepress -dCompatibilityLevel=1.6 "
+        gs += f"-dDownsampleColorImages=false -DownsampleGrayImages=false {fn}"
+        subprocess.call(gs, shell=True)
+    return  orig_fn
+
+def disable_ticks(ax):
+    ax.axes.get_xaxis().set_ticklabels([])
+    ax.axes.get_yaxis().set_ticklabels([])
+    ax.axes.get_xaxis().set_ticks([])
+    ax.axes.get_yaxis().set_ticks([])
+
+def disable_border(ax):
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    ax.spines['bottom'].set_visible(False)
+    ax.spines['left'].set_visible(False)
+
+def apply_color_map(data, cmap='coolwarm', vmin=None, vmax=None):
+    from matplotlib import cm
+
+    data = np.array(data)
+    if vmin is None:
+        vmin = np.min(data)
+    if vmax is None:
+        vmax = np.max(data)
+    return getattr(cm, cmap)(plt.Normalize(vmin, vmax)(data))[..., :3]
+
+def time_to_string(duration):
+    duration = round(duration)
+    m, s = divmod(duration, 60)
+    h, m = divmod(m, 60)
+    d, h = divmod(h, 24)
+    result = ''
+    if d > 0:
+        result += f'{d}d '
+    if h > 0:
+        result += f'{h}h '
+    if m > 0:
+        result += f'{m}m '
+    result += f'{s}s'
+    return result
+
+
+def set_aspect(ax, aspect):
+    x_left, x_right = ax.get_xlim()
+    y_low, y_high = ax.get_ylim()
+    ax.set_aspect(abs((x_right - x_left) / (y_low - y_high)) * aspect)
+
+def merge_pdfs(fn1, fn2, out_fn):
+    """Merges two PDF files"""
+    from PyPDF2 import PdfReader, PdfWriter
+    reader_base = PdfReader(fn1)
+    page_base = reader_base.pages[0]
+    reader = PdfReader(fn2)
+    page_box = reader.pages[0]
+    page_base.merge_page(page_box)
+    writer = PdfWriter()
+    writer.add_page(page_base)
+    with open(out_fn, 'wb') as fp:
+        writer.write(fp)

data/PDE2D/utils/helpers.py

@@ -0,0 +1,237 @@
+import numpy as np
+import drjit as dr
+import mitsuba as mi
+from math import sqrt
+from mitsuba import Point2f, Float, UInt32
+from collections.abc import Sequence
+
+#def deviate_points(points, max = 0.1, repeat= 5, seed = 37):
+#    sampler = mi.load_dict({'type': 'stratified'})
+#    sampler.seed(seed, dr.width(points) * repeat)
+#    return dr.repeat(points, repeat) + max * (sampler.next_2d() - 1/2)
+
+def get_position_bbox(points : Float, bbox):
+    "Get the new positions of the points normalized for the bbox."
+    x = (points[0] - bbox[0][0]) / (bbox[1][0] - bbox[0][0])
+    y = 1.0 - (points[1] - bbox[0][1]) / (bbox[1][1] - bbox[0][1])
+    return x, y
+
+def to_world_direction(direction : Point2f, normal : Point2f):
+    return direction[1] * normal + direction[0] * Point2f(normal[1], -normal[0]) 
+
+def to_normal_direction(direction : Point2f, normal: Point2f):
+    normal_comp = dr.dot(direction, normal)
+    other_comp = dr.dot(Point2f(normal[1], normal[0]), direction)
+    return Point2f(other_comp, normal_comp)
+
+@dr.syntax
+def correct_angle(angle : Float):
+    if angle<0:
+        angle += 2 * dr.pi
+    elif angle >= 2 * dr.pi:
+        angle -= 2 * dr.pi
+    return angle
+
+"""
+def upsample(tensor = TensorXf, upsample = [2,2]):
+    n1, n2 = tensor.shape
+    array = tensor.array
+    array_new = dr.zeros(Float, n1 * n2 * upsample[0] * upsample[1])
+    rows = dr.arange(UInt, n1 * upsample[0])
+    cols = dr.arange(UInt, n2 * upsample[1])
+    indices = dr.meshgrid(rows, cols)
+    indices_low = Array2i(indices[0] // upsample[0], indices[1] // upsample[1])
+    ind = indices[0] * n2 * upsample[1] + indices[1]
+    ind_low = indices_low[0] * n2 + indices_low[1]
+    low_vals = dr.gather(Float, array, ind_low)
+    dr.scatter(array_new, low_vals, ind)
+    tensor_new = TensorXf(array_new)
+    tensor_new = dr.reshape(TensorXf, tensor_new, shape = [n1 * upsample[0], n2 * upsample[1]])
+    return tensor_new
+"""
+
+def tea(v0: UInt32, v1: UInt32, rounds=4):
+        sum = UInt32(0)
+        for i in range(rounds):
+            sum += 0x9e3779b9
+            v0 += ((v1 << 4) + 0xa341316c) ^ (v1 + sum) ^ ((v1>>5) + 0xc8013ea4)
+            v1 += ((v0 << 4) + 0xad90777d) ^ (v0 + sum) ^ ((v0>>5) + 0x7e95761e)
+        return v0, v1
+
+@dr.syntax
+def k_means(points : Point2f, initial_means : Point2f, num_iter = 2):
+    # Set initial vals.
+    means = Point2f(initial_means)
+    npoints = dr.width(points)
+    nmeans = dr.width(means)
+    groups = dr.zeros(UInt32, npoints)
+    dist = dr.full(Float, dr.inf, npoints)
+    # Start K-means.
+    for i in range(num_iter):
+        # Assign to the groups.
+        for j in range(nmeans):
+            mean = dr.gather(Point2f, means, j)
+            dist_iter = dr.squared_norm(points - mean)
+            if dist_iter < dist:
+                groups = UInt32(j)
+                dist = dist_iter
+        # Recompute the means.
+        next_means = dr.zeros(Point2f, nmeans)
+        counter_sum = dr.zeros(Float, nmeans)
+        dr.scatter_add(next_means, points, groups)
+        dr.scatter_add(counter_sum, Float(1), groups)
+        means = next_means / counter_sum
+    return means, groups
+
+
+def upsample(t, shape=None, scale_factor=None, align_corners=False):
+    '''
+    upsample(source, shape=None, scale_factor=None, align_corners=False)
+    Up-sample the input tensor or texture according to the provided shape.
+
+    Alternatively to specifying the target shape, a scale factor can be
+    provided.
+
+    The behavior of this function depends on the type of ``source``:
+
+    1. When ``source`` is a Dr.Jit tensor, nearest neighbor up-sampling will use
+    hence the target ``shape`` values must be multiples of the source shape
+    values. When `scale_factor` is used, its values must be integers.
+
+    2. When ``source`` is a Dr.Jit texture type, the up-sampling will be
+    performed according to the filter mode set on the input texture. Target
+    ``shape`` values are not required to be multiples of the source shape
+    values. When `scale_factor` is used, its values must be integers.
+
+    Args:
+        source (object): A Dr.Jit tensor or texture type.
+
+        shape (list): The target shape (optional)
+
+        scale_factor (list): The scale factor to apply to the current shape
+        (optional)
+
+        align_corners (bool): Defines whether or not the corner pixels of the
+        input and output should be aligned. This allows the values at the
+        corners to be preserved. This flag is only relevant when ``source`` is
+        a Dr.Jit texture type performing linear interpolation. The default is
+        `False`.
+
+    Returns:
+        object: the up-sampled tensor or texture object. The type of the output
+        will be the same as the type of the source.
+    '''
+    if  not getattr(t, 'IsTexture', False) and not dr.is_tensor_v(t):
+        raise TypeError("upsample(): unsupported input type, expected Dr.Jit "
+                        "tensor or texture type!")
+
+    if shape is not None and scale_factor is not None:
+        raise TypeError("upsample(): shape and scale_factor arguments cannot "
+                        "be defined at the same time!")
+
+    if shape is not None:
+        if not isinstance(shape, Sequence):
+            raise TypeError("upsample(): unsupported shape type, expected a list!")
+
+        if len(shape) > len(t.shape):
+            raise TypeError("upsample(): invalid shape size!")
+
+        shape = list(shape) + list(t.shape[len(shape):])
+
+        scale_factor = []
+        for i, s in enumerate(shape):
+            if type(s) is not int:
+                raise TypeError("upsample(): target shape must contain integer values!")
+
+            if s < t.shape[i]:
+                raise TypeError("upsample(): target shape values must be larger "
+                                "or equal to input shape! (%i vs %i)" % (s, t.shape[i]))
+
+            if dr.is_tensor_v(t):
+                factor = s / float(t.shape[i])
+                if factor != int(factor):
+                    raise TypeError("upsample(): target shape must be multiples of "
+                                    "the input shape! (%i vs %i)" % (s, t.shape[i]))
+    else:
+        if not isinstance(scale_factor, Sequence):
+            raise TypeError("upsample(): unsupported scale_factor type, expected a list!")
+
+        if len(scale_factor) > len(t.shape):
+            raise TypeError("upsample(): invalid scale_factor size!")
+
+        scale_factor = list(scale_factor)
+        for i in range(len(t.shape) - len(scale_factor)):
+            scale_factor.append(1)
+
+        shape = []
+        for i, factor in enumerate(scale_factor):
+            if type(factor) is not int:
+                raise TypeError("upsample(): scale_factor must contain integer values!")
+
+            if factor < 1:
+                raise TypeError("upsample(): scale_factor values must be greater "
+                                "than 0!")
+
+            shape.append(factor * t.shape[i])
+
+    if getattr(t, 'IsTexture', False):
+        value_type = type(t.value())
+        dim = len(t.shape) - 1
+
+        if t.shape[dim] != shape[dim]:
+            raise TypeError("upsample(): channel counts doesn't match input texture!")
+
+        # Create the query coordinates
+        coords = list(dr.meshgrid(*[
+                dr.linspace(value_type, 0.0, 1.0, shape[i], endpoint=align_corners)
+                for i in range(dim)
+            ],
+            indexing='ij'
+        ))
+
+        # Offset coordinates by half a voxel to hit the center of the new voxels
+        if align_corners:
+            for i in range(dim):
+                coords[i] *= (1 - 1 / t.shape[i])
+                coords[i] += 0.5 / t.shape[i]
+        else:
+            for i in range(dim):
+                coords[i] += 0.5 / shape[i]
+
+        # Reverse coordinates order according to dr.Texture convention
+        coords.reverse()
+
+        # Evaluate the texture at all voxel coordinates with interpolation
+        values = t.eval(coords)
+
+        # Concatenate output values to a flatten buffer
+        channels = len(values)
+        width = dr.width(values[0])
+        index = dr.arange(dr.uint32_array_t(value_type), width)
+        data = dr.zeros(value_type, width * channels)
+        for c in range(channels):
+            dr.scatter(data, values[c], channels * index + c)
+
+        # Create the up-sampled texture
+        texture = type(t)(shape[:-1], channels,
+                          use_accel=t.use_accel(),
+                          filter_mode=t.filter_mode(),
+                          wrap_mode=t.wrap_mode())
+        texture.set_value(data)
+
+        return texture
+    else:
+        dim = len(shape)
+        size = dr.prod(shape[:dim])
+        base = dr.arange(dr.uint32_array_t(type(t.array)), size)
+
+        index = 0
+        stride = 1
+        for i in reversed(range(dim)):
+            ratio = shape[i] // t.shape[i]
+            index += (base // ratio % t.shape[i]) * stride
+            base //= shape[i]
+            stride *= t.shape[i]
+
+        return type(t)(dr.gather(type(t.array), t.array, index), tuple(shape))
+

data/PDE2D/utils/imageUtils.py

@@ -0,0 +1,123 @@
+import numpy as np
+import drjit as dr
+import mitsuba as mi
+from mitsuba import PCG32, Float, Point2f, TensorXf
+from PDE2D import ArrayXu, ArrayXf
+import sys
+
+def create_image_points(bbox : list, resolution : list[int], spp : int, seed : int = 64, centered = False) -> Point2f:
+    # Generate the first points
+    
+    x, y = dr.meshgrid(dr.arange(Float, resolution[1]), 
+                       dr.arange(Float, resolution[0]), indexing='xy')
+    x = dr.repeat(x, spp)
+    y = dr.repeat(y, spp)
+    if not centered:
+        npoints = resolution[0] * resolution[1] * spp
+        np.random.seed(seed)
+        init_state = np.random.randint(sys.maxsize, size = npoints)
+        init_seq = np.random.randint(sys.maxsize, size = npoints)
+        sampler = PCG32(npoints, initstate = init_state, initseq = init_seq)
+        film_points =  Point2f(x,y) + Point2f(sampler.next_float32(), sampler.next_float32())
+    else:
+        film_points =  Point2f(x,y) + Point2f(0.5, 0.5)
+    # The bounding box is defined as (bottom-left,up-right)
+    points = (Point2f(bbox[0][0], bbox[1][1]) +  
+              film_points / Point2f(resolution[1], resolution[0]) *  
+              (Point2f(bbox[1][0], bbox[0][1]) - Point2f(bbox[0][0], bbox[1][1])))
+    return points
+
+
+def create_image_from_result(result, resolution = [256, 256], compute_std = False):
+    if isinstance(result, Float):
+        num_conf = 1
+    else:
+        if result.ndim == 1:
+            num_conf = 1
+        else:
+            num_conf = result.shape[0]
+    # Splat to film
+    spp = int(dr.width(result) / (resolution[0] * resolution[1]))
+    #active_lanes = dr.select(result != 0, 1, 0)
+    #active_sum = dr.block_sum(active_lanes, spp)
+    result_sum = dr.block_sum(result, spp) / spp
+    #image_res = TensorXf(dr.select(active_sum > 0, result_sum / active_sum, 0))
+    image_res = TensorXf(result_sum)
+
+    shape = [num_conf, resolution[0], resolution[1]]
+    tensor = dr.reshape(TensorXf, value = image_res, shape = shape)
+
+    if not compute_std:
+        return tensor.numpy(), tensor
+
+    else:
+        variance = TensorXf(dr.block_sum(dr.square(result), spp) / spp)
+        variance = dr.reshape(TensorXf, value = variance, shape = shape) - dr.square(tensor)
+        variance /= spp
+    return tensor.numpy(), tensor, np.abs(variance.numpy()), variance
+
+def create_circle_points(origin : list = [0,0], radius : float = 1.0, resolution = 1024,
+                         spp = 256, seed : int = 14, centered = False, discrete_points = False, shift : float = 0):
+    if not discrete_points:
+        npoints = spp * resolution
+        np.random.seed(seed)
+        init_state = np.random.randint(sys.maxsize, size = npoints)
+        init_seq = np.random.randint(sys.maxsize, size = npoints)
+        sampler = PCG32(npoints, initstate = init_state, initseq = init_seq)
+        film_points = dr.arange(Float, resolution)
+        film_points = dr.repeat(film_points, spp) + sampler.next_float32()
+        film_points -= 1/2 if centered else 0
+        angles = film_points / resolution * 2 * dr.pi + shift
+        points = Point2f(origin) + radius * Point2f(dr.sin(angles), dr.cos(angles))
+    else:
+        film_points = dr.arange(Float, resolution)
+        film_points = dr.repeat(film_points, spp)
+        film_points += 1/2 if centered else 0
+        angles = film_points / resolution * 2 * dr.pi + shift
+        points = Point2f(origin) + radius * Point2f(dr.sin(angles), dr.cos(angles))
+    return points
+
+def create_circle_from_result(result, resolution = 1024):
+    # Splat to film
+    spp = int(dr.width(result) / resolution)
+    res_image = TensorXf(dr.block_sum(result, spp)) / spp
+    return res_image.numpy(), res_image
+
+def create_electrode_result(L, spe, electrode_nums : ArrayXu, apply_normalization = True, compute_std = False):
+        #unnormalized =  dr.block_sum(L, spe) / spe
+        unnormalized = dr.block_sum(L, spe) / spe
+        num_active_electrodes = dr.width(electrode_nums)
+        
+        if apply_normalization:
+            bias = dr.block_sum(unnormalized, dr.width(unnormalized)) / num_active_electrodes
+            result = unnormalized - dr.select(unnormalized != 0, bias, 0)
+        else:
+            result = unnormalized
+        
+        if not compute_std:
+            return result
+        
+        variance = dr.block_sum(dr.square(L), spe) / spe - dr.square(unnormalized)
+        variance /= spe
+
+        return result, dr.sqrt(variance)
+    
+'''
+def block_sum(L : Float, spp : int) -> Float: #spe needs to be power of 2
+    iternum = int(dr.log2(spp))
+    sum = ArrayXf(L)
+    for i in range(iternum):
+        sum = dr.block_sum(sum, 2)
+    return sum
+
+def block_sum_(L : Float, spp : int) -> Float: # Kahan-compensated blocksum.
+    num_bins = dr.width(L)//spp
+    index = dr.arange(UInt32, num_bins)
+    index = dr.repeat(index, spp)
+    target1 = dr.zeros(Float, num_bins)
+    target2 = dr.zeros(Float, num_bins)
+    dr.scatter_add_kahan(target1, target2, L, index)
+    return target1 + target2
+
+'''
+

data/PDE2D/utils/optimization.py

@@ -0,0 +1,63 @@
+import drjit as dr
+import mitsuba as mi
+from PDE2D import ArrayXf
+from mitsuba import TensorXf
+import numpy as np
+
+def MSE(img , img_ref = 0):
+    val = img
+    val_ref = img_ref
+    if isinstance(val, TensorXf):
+        val = val.array
+    if isinstance(val_ref, TensorXf):
+        val_ref = val_ref.array
+    return dr.block_sum(dr.square(val - val_ref), dr.width(val)) / dr.width(val)
+
+
+def MSE_image(img , img_ref = 0):
+    return dr.sum(dr.square(img - img_ref).array) / (img.shape[1] * img.shape[2])
+
+def MSE_numpy(val :np.array , val_ref : np.array = 0):
+    return np.sum(np.square(val - val_ref), axis = tuple(range(1, val.ndim))) / (np.size(val) / val.shape[0])
+
+
+def compute_loss_grad(result, result_ref=0):
+    return (2 * (result - result_ref)) / dr.width(result)
+
+def compute_dL(L, loss_grad, spe, electrode_nums = None, apply_normalization = False):
+    if not apply_normalization:
+        # The commented lines show that there is no difference between 
+        # applying normalization to the primal computation.
+        #normalization = dr.sum(L) / dr.width(L)
+        #L = L - normalization
+        #dr.enable_grad(L)
+        #result = dr.block_sum(L, spe) / spe
+        #dr.set_grad(result, adjoint_result)
+        #dr.backward(result)
+        dL = dr.repeat(loss_grad, spe) / spe
+    else:
+        num_active_electrodes = dr.width(electrode_nums)
+        unnormalized =  dr.block_sum(L, spe) / spe
+        #unnormalized =  self.block_sum(L, spe) / spe
+        dr.enable_grad(unnormalized)
+        bias = dr.block_sum(unnormalized, dr.width(unnormalized)) / num_active_electrodes
+        result = unnormalized - dr.select(unnormalized != 0, bias, 0)
+        #result = unnormalized - dr.sum(unnormalized) / dr.width(unnormalized)
+        dr.enable_grad(result)
+        dr.set_grad(result, loss_grad)
+        dr.enqueue(dr.ADMode.Backward, result)
+        dr.traverse(dr.ADMode.Backward)
+        grad = dr.grad(unnormalized)
+        dL = dr.repeat(grad, spe) / spe    
+    return dL
+
+def compute_loss_grad_image(result, result_ref = 0):
+    return (2 * (result - result_ref)) / (result.shape[1] * result.shape[2])
+
+
+def compute_dL_image(loss_grad, spp):
+    size = loss_grad.shape[1] * loss_grad.shape[2] * spp
+    dL = dr.zeros(ArrayXf, shape = (loss_grad.shape[0], size))
+    for i in range(loss_grad.shape[0]):
+        dL[i] = dr.repeat(loss_grad[i].array, spp) / spp
+    return dL