data/PDE2D/BoundaryShape/circlewithelectrodes.py

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)