level-with-4-classes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import skfmm\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import KTCFwd\n",
    "import KTCMeshing\n",
    "import KTCScoring\n",
    "import KTCRegularization\n",
    "import KTCAux\n",
    "import matplotlib.pyplot as plt\n",
    "import glob\n",
    "import dolfin as df\n",
    "from skimage.segmentation import chan_vese"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Folders and difficulty level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.set_log_level(40)\n",
    "\n",
    "folder = 'app/'\n",
    "inputFolder = folder + 'TrainingData'\n",
    "truthFolder = folder + 'GroundTruths'\n",
    "\n",
    "# Set difficulty\n",
    "categoryNbr = 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "Nel = 32  # number of electrodes\n",
    "z = (1e-6) * np.ones((Nel, 1))  # contact impedances\n",
    "mat_dict = sp.io.loadmat(inputFolder + '/ref.mat') #load the reference data\n",
    "Injref = mat_dict[\"Injref\"] #current injections\n",
    "Uelref = mat_dict[\"Uelref\"] #measured voltages from water chamber\n",
    "Mpat = mat_dict[\"Mpat\"] #voltage measurement pattern\n",
    "vincl = np.ones(((Nel - 1),76), dtype=bool) #which measurements to include in the inversion\n",
    "rmind = np.arange(0,2 * (categoryNbr - 1),1) #electrodes whose data is removed\n",
    "\n",
    "#remove measurements according to the difficulty level\n",
    "for ii in range(0,75):\n",
    "    for jj in rmind:\n",
    "        if Injref[jj,ii]:\n",
    "            vincl[:,ii] = 0\n",
    "        vincl[jj,:] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load mesh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load premade finite element mesh (made using Gmsh, exported to Matlab and saved into a .mat file)\n",
    "mat_dict_mesh = sp.io.loadmat(folder + 'Mesh_sparse.mat')\n",
    "g = mat_dict_mesh['g'] #node coordinates\n",
    "H = mat_dict_mesh['H'] #indices of nodes making up the triangular elements\n",
    "elfaces = mat_dict_mesh['elfaces'][0].tolist() #indices of nodes making up the boundary electrodes\n",
    "\n",
    "#Element structure\n",
    "ElementT = mat_dict_mesh['Element']['Topology'].tolist()\n",
    "for k in range(len(ElementT)):\n",
    "    ElementT[k] = ElementT[k][0].flatten()\n",
    "ElementE = mat_dict_mesh['ElementE'].tolist() #marks elements which are next to boundary electrodes\n",
    "for k in range(len(ElementE)):\n",
    "    if len(ElementE[k][0]) > 0:\n",
    "        ElementE[k] = [ElementE[k][0][0][0], ElementE[k][0][0][1:len(ElementE[k][0][0])]]\n",
    "    else:\n",
    "        ElementE[k] = []\n",
    "\n",
    "#Node structure\n",
    "NodeC = mat_dict_mesh['Node']['Coordinate']\n",
    "NodeE = mat_dict_mesh['Node']['ElementConnection'] #marks which elements a node belongs to\n",
    "nodes = [KTCMeshing.NODE(coord[0].flatten(), []) for coord in NodeC]\n",
    "for k in range(NodeC.shape[0]):\n",
    "    nodes[k].ElementConnection = NodeE[k][0].flatten()\n",
    "elements = [KTCMeshing.ELEMENT(ind, []) for ind in ElementT]\n",
    "for k in range(len(ElementT)):\n",
    "    elements[k].Electrode = ElementE[k]\n",
    "\n",
    "#2nd order mesh data\n",
    "H2 = mat_dict_mesh['H2']\n",
    "g2 = mat_dict_mesh['g2']\n",
    "elfaces2 = mat_dict_mesh['elfaces2'][0].tolist()\n",
    "ElementT2 = mat_dict_mesh['Element2']['Topology']\n",
    "ElementT2 = ElementT2.tolist()\n",
    "for k in range(len(ElementT2)):\n",
    "    ElementT2[k] = ElementT2[k][0].flatten()\n",
    "ElementE2 = mat_dict_mesh['Element2E']\n",
    "ElementE2 = ElementE2.tolist()\n",
    "for k in range(len(ElementE2)):\n",
    "    if len(ElementE2[k][0]) > 0:\n",
    "        ElementE2[k] = [ElementE2[k][0][0][0], ElementE2[k][0][0][1:len(ElementE2[k][0][0])]]\n",
    "    else:\n",
    "        ElementE2[k] = []\n",
    "\n",
    "NodeC2 = mat_dict_mesh['Node2']['Coordinate']  # ok\n",
    "NodeE2 = mat_dict_mesh['Node2']['ElementConnection']  # ok\n",
    "nodes2 = [KTCMeshing.NODE(coord[0].flatten(), []) for coord in NodeC2]\n",
    "for k in range(NodeC2.shape[0]):\n",
    "    nodes2[k].ElementConnection = NodeE2[k][0].flatten()\n",
    "elements2 = [KTCMeshing.ELEMENT(ind, []) for ind in ElementT2]\n",
    "for k in range(len(ElementT2)):\n",
    "    elements2[k].Electrode = ElementE2[k]\n",
    "\n",
    "Mesh = KTCMeshing.Mesh(H,g,elfaces,nodes,elements)\n",
    "Mesh2 = KTCMeshing.Mesh(H2,g2,elfaces2,nodes2,elements2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make Fenics mesh out of provided mesh\n",
    "\n",
    "def make_Mesh(g,H):\n",
    "    topological_dim = 2\n",
    "    geometrical_dim = 2\n",
    "    num_local_vertices = g.shape[0]\n",
    "    num_global_vertices = num_local_vertices  # True if run in serial\n",
    "    num_local_cells = H.shape[0]\n",
    "    num_global_cells = num_local_cells\n",
    "\n",
    "    # Create mesh object and open editor\n",
    "    mesh = df.Mesh()\n",
    "    editor = df.MeshEditor()\n",
    "    editor.open(mesh, \"triangle\", topological_dim, geometrical_dim)\n",
    "    editor.init_vertices_global(num_local_vertices, num_global_vertices)\n",
    "    editor.init_cells_global(num_local_cells, num_global_cells)\n",
    "\n",
    "    # Add verticess\n",
    "    for i, coord in enumerate(g):\n",
    "        editor.add_vertex(i, coord)\n",
    "\n",
    "    # Add cells\n",
    "    for i, cell in enumerate(H):\n",
    "        editor.add_cell(i, cell)\n",
    "\n",
    "    # Close editor\n",
    "    editor.close(order = True)\n",
    "    return mesh\n",
    "\n",
    "mesh = make_Mesh(g,H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define solver\n",
    "Here we use the provided solver with some alterations. We use an inverse gamma noise model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make starting guess:\n",
    "# 1. Starting guess consists of three inclusions: design piecewise phi1 and phi2 such that this is possible\n",
    "# 2. Make piecewise phi1 and phi2 to signed distance function with skfmm.distance\n",
    "# 3. Make q = q1*((phi1>0)*(phi2>0)) + q2*((phi1>0)*(phi2<0)) + q3*((phi1<0)*(phi2>0)) + q4*((phi1<0)*(phi2<0))\n",
    "pixwidth = 0.23 / 256\n",
    "pixcenter_x = np.linspace(-0.115 + pixwidth / 2, 0.115 - pixwidth / 2 + pixwidth, 256)\n",
    "pixcenter_y = pixcenter_x\n",
    "X, Y = np.meshgrid(pixcenter_x, pixcenter_y)\n",
    "\n",
    "size = 0.15\n",
    "center1 = (-0.3*size,-0.3*size)\n",
    "center2 = (0.3*size,-0.3*size)\n",
    "center3 = (0*size,0.3*size)\n",
    "r = 0.15*size\n",
    "\n",
    "inclusion1 = (X-center1[0])**2 + (Y-center1[1])**2 < r**2\n",
    "inclusion2 = (X-center2[0])**2 + (Y-center2[1])**2 < r**2\n",
    "inclusion3 = (X-center3[0])**2 + (Y-center3[1])**2 < r**2\n",
    "\n",
    "phi1_seg = -2.0*(inclusion1) - 2.0*(inclusion2) + 1.0\n",
    "phi2_seg = -2.0*(inclusion2) - 2.0*(inclusion3) + 1.0\n",
    "\n",
    "phi10 = skfmm.distance(phi1_seg, dx = 0.001).reshape((256**2,1))\n",
    "phi20 = skfmm.distance(phi2_seg, dx = 0.001).reshape((256**2,1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define solver\n",
    "Here we use the provided solver with some alterations. We use an inverse gamma noise model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up the forward solver for inversion\n",
    "solver = KTCFwd.EITFEM(Mesh2,Mesh, Injref, Mpat, vincl)\n",
    "# vincl needs to be flat\n",
    "vincl = vincl.T.flatten()\n",
    "# set up the noise model for inversion\n",
    "noise_std1 = 0.05;  # standard deviation for first noise component (relative to each voltage measurement)\n",
    "noise_std2 = 0.01;  # standard deviation for second noise component (relative to the largest voltage measurement)\n",
    "solver.SetInvGamma(noise_std1, noise_std2, Uelref)\n",
    "mask = np.array(vincl, bool)\n",
    "noisematrix = 1e-7*solver.InvGamma_n[np.ix_(mask,mask)]\n",
    "solver.noisematrix = noisematrix\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fenics classes and spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We primarily consider the Lagrange first order\n",
    "V1 = df.FunctionSpace(mesh,'CG',1)\n",
    "V02 = df.VectorFunctionSpace(mesh,'DG',0)\n",
    "\n",
    "idx = df.dof_to_vertex_map(V1)\n",
    "idx2 = df.vertex_to_dof_map(V1)\n",
    "\n",
    "\n",
    "class qFunction(df.UserExpression):\n",
    "\n",
    "    def __init__(self,phi,q1,q2,**kwargs):\n",
    "        super().__init__(self,**kwargs)\n",
    "        self.phi = phi\n",
    "        self.q1 = q1\n",
    "        self.q2 = q2\n",
    "\n",
    "    def value_shape(self):\n",
    "        return ()\n",
    "    \n",
    "    def eval(self,values,x):\n",
    "        if self.phi(x) > 0:\n",
    "            values[0] = self.q1\n",
    "        else:\n",
    "            values[0] = self.q2\n",
    "\n",
    "class Denom(df.UserExpression):\n",
    "\n",
    "    def __init__(self,gradf,delta,**kwargs):\n",
    "        super().__init__(self,**kwargs)\n",
    "        self.phigrad = gradf\n",
    "        self.delta = delta\n",
    "\n",
    "    def value_shape(self):\n",
    "        return ()\n",
    "\n",
    "    def eval(self,values,x):\n",
    "        values[0] = 1/(((self.phigrad(x)[0])**2 + (self.phigrad(x)[1])**2+self.delta)**(1/2))\n",
    "        #values[0] = self.phigrad(x)[0]\n",
    "\n",
    "class MyTV:\n",
    "    def __init__(self,q0fun,delta,**kwargs):\n",
    "        #self.qfun = df.project(qFunction(phi,q1,q2),V1)\n",
    "\n",
    "        self.q0fun = q0fun\n",
    "        self.q0grad = df.project(df.grad(self.q0fun),V02)\n",
    "        self.q0_denom = Denom(self.q0grad,delta)\n",
    "\n",
    "        # operator\n",
    "        self.p_trial = df.TrialFunction(V1)\n",
    "        self.p_test = df.TestFunction(V1)\n",
    "\n",
    "        #self.L_op = dl.assemble(ufl.inner(self.p_trial, self.p_test)*dx)\n",
    "        #self.TV_op = df.assemble(self.q_denom*ufl.inner(df.grad(self.p_trial),df.grad(self.p_test))*dx)\n",
    "        self.TV_op = df.assemble((self.q0_denom*df.inner(df.grad(self.p_trial),df.grad(self.p_test)))*df.dx)\n",
    "\n",
    "    def eval_TV(self,qfun):\n",
    "        return np.dot(self.TV_op * qfun.vector(),qfun.vector())\n",
    "\n",
    "    def eval_grad(self,qfun):\n",
    "        return 2*(self.TV_op * qfun.vector())[idx2]\n",
    "    \n",
    "    def update_op(self,q0fun):\n",
    "        self.q0fun = q0fun\n",
    "        self.q0grad = df.project(df.grad(self.q0fun),V02)\n",
    "        self.q0_denom = Denom(self.q0grad,delta)\n",
    "        self.TV_op = df.assemble((self.q0_denom*df.inner(df.grad(self.p_trial),df.grad(self.p_test)))*df.dx) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimization problem\n",
    "We try tro minimize the functional of $q=q(\\phi_1,\\phi_2,q_1,q_2,q_3,q_4)$\n",
    "$$F(\\phi,q_1,q_2)=\\frac{1}{2}\\|U-\\mathcal{G}(q)\\|^2 + \\beta \\int_{\\Omega} |\\nabla q| \\, dx.$$\n",
    "\n",
    "The gradient takes the form\n",
    "$$\\frac{dF}{dq}=- \\nabla_q \\mathcal{G}(q)^T(U-\\mathcal{G}(q)) - \\beta \\nabla \\cdot (\\frac{\\nabla q}{|\\nabla q|})$$\n",
    "In case we use a weighted 2-norm (here I mean $q^T C q$ - this is the matrix Kuopio generate with inverse gamma distribution) and use \"difference\" data, we have\n",
    "$$F(\\phi,q_1,q_2)=\\frac{1}{2}\\|U-U_{\\mathrm{ref}}-(\\mathcal{G}(q)-\\mathcal{G}(0.8))\\|_{C}^2 + \\beta \\int_{\\Omega} |\\nabla q| \\, dx.$$ \n",
    "Here we look at a $q$ with 4 classes $q=q(\\phi_1,\\phi_2,q_1,q_2,q_3,q_4)$ constructed by:\n",
    "$$q = q_1(\\phi_1>0, \\phi_2>0) + q_2(\\phi_1>0,\\phi_2<0) + q_3(\\phi_1<0,\\phi_2>0) + q_4(\\phi_1<0,\\phi_2<0)$$\n",
    "$$\\frac{dF}{dq}=- \\nabla_q \\mathcal{G}(q)^TC[U-U_{\\mathrm{ref}}-(\\mathcal{G}(q)-\\mathcal{G}(0.8))] - \\beta \\nabla \\cdot (\\frac{\\nabla q}{|\\nabla q|})$$ \n",
    "We assume $q_1=0.8$, $q_2=10^{-3}$, $q_3=10$, $q_4=10^3$. Note\n",
    "$$\\frac{dq}{d\\phi_1} = \\delta(\\phi_1)[q_1H(\\phi_2)+q_2(1-H(\\phi_2))-q_3H(\\phi_2)-q_4(1-H(\\phi_2))]$$\n",
    "$$\\frac{dq}{d\\phi_2} = \\delta(\\phi_2)[q_1H(\\phi_1)-q_2H(\\phi_1)+q_3(1-H(\\phi_1))-q_4(1-H(\\phi_1))]$$\n",
    "\n",
    "We then perform a gradient descent updating in the directions\n",
    "$$\\frac{dF}{d\\phi_1}=\\frac{dF}{dq} \\frac{dq}{d\\phi_1}.$$\n",
    "$$\\frac{dF}{d\\phi_2}=\\frac{dF}{dq} \\frac{dq}{d\\phi_2}.$$\n",
    "We approximate $\\delta(\\phi)$ with \n",
    "$$\\delta_\\epsilon(\\phi)=\\frac{\\epsilon}{\\pi(\\phi^2+\\epsilon^2)},$$\n",
    "and $H(\\phi)$ with\n",
    "$$H_\\delta(\\phi) = \\frac{1}{\\pi}\\mathrm{tan}^{-1}(\\frac{\\phi}{\\delta})+1/2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Jasper regularization\n",
    "radius = np.max(np.linalg.norm(Mesh.g, axis = 1))\n",
    "m = Mesh.g.shape[0]\n",
    "num_el =  32 - (2*categoryNbr - 1)\n",
    "electrodes = np.zeros((num_el, 2))\n",
    "angle = 2*np.pi/Nel\n",
    "for i in range(num_el):\n",
    "    electrodes[i] = radius*np.array([np.sin(i*angle), np.cos(i*angle)])\n",
    "\n",
    "\n",
    "D = np.zeros(m)\n",
    "for i in range(m):\n",
    "    v = Mesh.g[i]\n",
    "    dist = np.zeros(num_el)\n",
    "    for k, e in enumerate(electrodes):\n",
    "        dist[k] = np.linalg.norm(v - e)\n",
    "    D[i] = (np.linalg.norm(dist, ord = 3)**3)*np.linalg.norm(v)**4\n",
    "\n",
    "D = np.diag(D)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_functional2(q,solver,Umeas,Umeas_ref,z,beta,idx,TV):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Solve forward problem\n",
    "    Usim = solver.SolveForward2(q, z)\n",
    "\n",
    "    # Compute TV\n",
    "    R = TV.eval_TV(qfun)\n",
    "\n",
    "    disp = np.array((Umeas-Umeas_ref)-(Usim-solver.Uref))\n",
    "\n",
    "    #return solver.noisematrix @ disp\n",
    "    #print(disp.T)\n",
    "    #print((solver.noisematrix@disp).T)\n",
    "    F = 0.5 * disp.T * solver.noisematrix @ disp + beta*R\n",
    "    return F[0][0]\n",
    "    #return 0.5*np.inner(disp.T,(solver.noisematrix@disp).T) + beta*R\n",
    "    #return 0.5*np.dot(disp.T,solver.noisematrix@disp)+ beta*R\n",
    "\n",
    "def compute_functional3(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,zeta,D):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Solve forward problem\n",
    "    Usim = solver.SolveForward2(q, z)\n",
    "\n",
    "    # Compute TV\n",
    "    R = TV.eval_TV(qfun)\n",
    "\n",
    "    disp = np.array((Umeas-Umeas_ref)-(Usim-solver.Uref))\n",
    "\n",
    "    #return solver.noisematrix @ disp\n",
    "    #print(disp.T)\n",
    "    #print((solver.noisematrix@disp).T)\n",
    "    F = 0.5 * disp.T * solver.noisematrix @ disp + beta*R + zeta*q.T*D@q\n",
    "    return F[0][0]\n",
    "    #return 0.5*np.inner(disp.T,(solver.noisematrix@disp).T) + beta*R\n",
    "    #return 0.5*np.dot(disp.T,solver.noisematrix@disp)+ beta*R\n",
    "\n",
    "def compute_functional2_given_disp(disp,q,solver,Umeas,Umeas_ref,beta,idx,TV):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Compute TV\n",
    "    R = TV.eval_TV(qfun)\n",
    "\n",
    "    #return solver.noisematrix @ disp\n",
    "    #print(disp.T)\n",
    "    #print((solver.noisematrix@disp).T)\n",
    "    F = 0.5 * np.array(disp).T * solver.noisematrix @ disp + beta*R\n",
    "    return F[0][0]\n",
    "\n",
    "def compute_functional3_given_disp(disp,q,solver,Umeas,Umeas_ref,beta,idx,TV,zeta,D):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Compute TV\n",
    "    R = TV.eval_TV(qfun)\n",
    "\n",
    "    #return solver.noisematrix @ disp\n",
    "    #print(disp.T)\n",
    "    #print((solver.noisematrix@disp).T)\n",
    "    F = 0.5 * np.array(disp).T * solver.noisematrix @ disp + beta*R + zeta*q.T@D@q\n",
    "    return F[0][0]\n",
    "\n",
    "\n",
    "def find_direction2_dFdq(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,eps):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Forward map\n",
    "    Usim = solver.SolveForward2(q, z)\n",
    "\n",
    "    # Jacobian\n",
    "    J = solver.Jacobian(q, z)\n",
    "\n",
    "    # TV regularization direction\n",
    "    tvdir = TV.eval_grad(qfun)\n",
    "\n",
    "    disp = (Umeas-Umeas_ref)-(Usim-solver.Uref)\n",
    "    dataterm = np.array(- J.T @ solver.noisematrix @ (disp)).reshape(-1)\n",
    "\n",
    "    # Approximate delta function\n",
    "    #delta_eps = eps/(3.14159*(phi**2+eps**2))\n",
    "\n",
    "    # dFdq\n",
    "    dFdq = dataterm + beta*tvdir\n",
    "\n",
    "    # Full direction\n",
    "    #dF = (q2-q1)*dFdq * delta_eps\n",
    "\n",
    "    return dFdq, disp\n",
    "\n",
    "def find_direction3_dFdq(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,eps,zeta,D):\n",
    "    qfun = df.Function(V1)\n",
    "    qfun.vector().set_local(q[idx])\n",
    "\n",
    "    # Forward map\n",
    "    Usim = solver.SolveForward2(q, z)\n",
    "\n",
    "    # Jacobian\n",
    "    J = solver.Jacobian(q, z)\n",
    "\n",
    "    # TV regularization direction\n",
    "    tvdir = TV.eval_grad(qfun)\n",
    "    Ddir = 2*D@q\n",
    "\n",
    "    disp = (Umeas-Umeas_ref)-(Usim-solver.Uref)\n",
    "    dataterm = np.array(- J.T @ solver.noisematrix @ (disp)).reshape(-1)\n",
    "\n",
    "    # Approximate delta function\n",
    "    #delta_eps = eps/(3.14159*(phi**2+eps**2))\n",
    "\n",
    "    # dFdq\n",
    "    dFdq = dataterm + beta*tvdir + zeta*Ddir\n",
    "\n",
    "    # Full direction\n",
    "    #dF = (q2-q1)*dFdq * delta_eps\n",
    "\n",
    "    return dFdq, disp\n",
    "\n",
    "def find_direction_dqdphi(phi1,phi2,q1,q2,q3,q4,eps):\n",
    "    # Approximate delta function\n",
    "    delta_phi1 = eps/(3.14159*(phi1**2+eps**2))\n",
    "    delta_phi2 = eps/(3.14159*(phi2**2+eps**2))\n",
    "    H_phi1 = 1/3.141592 * np.arctan(phi1/eps)+1/2\n",
    "    H_phi2 = 1/3.141592 * np.arctan(phi2/eps)+1/2\n",
    "\n",
    "    dqdphi1 = q1*H_phi2 + q2*(1-H_phi2) - q3*H_phi2 - q4*(1-H_phi2)\n",
    "    dqdphi2 = q1*H_phi1 - q2*H_phi1 + q3*(1-H_phi1) - q4*(1-H_phi1)\n",
    "\n",
    "    dqdphi1 = delta_phi1*dqdphi1\n",
    "    dqdphi2 = delta_phi2*dqdphi2\n",
    "\n",
    "    return dqdphi1, dqdphi2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reinitialization of distance function\n",
    "We need a stable way of reinitializing the level set function so that it is close to a distance function. This is crucial for the numerical stability of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reinitialization algorithm based on Runge-Kutta4 discretization in time direction\n",
    "\n",
    "def reinitRK(l,idx,Niter,dt,eps,alpha):\n",
    "    #phifun.vector().set_local(l[idx])\n",
    "\n",
    "    # Set the initial value\n",
    "    phi = df.TrialFunction(V1)\n",
    "    phi0 = df.Function(V1)\n",
    "    w = df.TestFunction(V1)\n",
    "    phi1 = df.Function(V1)\n",
    "    phi2 = df.Function(V1)\n",
    "    phi3 = df.Function(V1)\n",
    "    phi4 = df.Function(V1)\n",
    "    phi_new = df.Function(V1)\n",
    "\n",
    "    k = df.Constant(dt) # Time step Python\n",
    "    phi0.vector().set_local(l[idx]) # Initial value\n",
    "\n",
    "    epsdf = df.Constant(eps) # Interface thickness\n",
    "    alphadf = df.Constant (alpha) # Numerical diffusion parameter\n",
    "    sixth = df.Constant(dt/6.0)\n",
    "\n",
    "    sign_term = phi0/ df.sqrt(phi0**2 + df.inner(df.grad(phi0),df.grad(phi0))* epsdf**2)\n",
    "\n",
    "    a = phi*w*df.dx\n",
    "\n",
    "    # For the heat equation:\n",
    "    L1heat = - alpha * df.inner(df.grad(phi0),df.grad(w)) * df.dx\n",
    "    L2heat = - alpha * df.inner(df.grad(phi0 + k/2 * phi1),df.grad(w)) * df.dx\n",
    "    L3heat = - alpha * df.inner(df.grad(phi0 + k/2 * phi2),df.grad(w)) * df.dx\n",
    "    L4heat = - alpha * df.inner(df.grad(phi0 + k * phi3),df.grad(w)) * df.dx\n",
    "\n",
    "\n",
    "    # For the Eikonal equation:\n",
    "    L1eik = sign_term * (1.0 - df.sqrt (df.inner( df.grad ( phi0 ) , df.grad ( phi0 ))))* w*df.dx\n",
    "    L2eik = sign_term * (1.0 - df.sqrt (df.inner( df.grad ( phi0 + k/2 * phi1 ) , df.grad ( phi0 + k/2 * phi1 ))))* w*df.dx\n",
    "    L3eik = sign_term * (1.0 - df.sqrt (df.inner( df.grad ( phi0 + k/2 * phi2 ) , df.grad ( phi0 + k/2 * phi2 ))))* w*df.dx\n",
    "    L4eik = sign_term * (1.0 - df.sqrt (df.inner( df.grad ( phi0 + k * phi3 ) , df.grad ( phi0 + k * phi3 ))))* w*df.dx\n",
    "\n",
    "\n",
    "    L1 = L1heat + L1eik\n",
    "    L2 = L2heat + L2eik\n",
    "    L3 = L3heat + L3eik\n",
    "    L4 = L4heat + L4eik\n",
    "\n",
    "    # Boundary condition\n",
    "    bc = []\n",
    "    # Flag setup\n",
    "    Ei = 1e10 ; E_old = 1e10\n",
    "    cont = 0; num_steps = 10\n",
    "\n",
    "\n",
    "\n",
    "    for i in range(Niter):\n",
    "        \n",
    "        df.solve (a == L1, phi1, bc)\n",
    "        df.solve (a == L2, phi2, bc)\n",
    "        df.solve (a == L3, phi3, bc)\n",
    "        df.solve (a == L4, phi4, bc)\n",
    "\n",
    "\n",
    "        phi_new = phi0 + sixth * (phi1 + 2*phi2 + 2*phi3 + phi4)\n",
    "\n",
    "\n",
    "        # Euclidean norm\n",
    "        error = ((( phi_new - phi0 )/k )**2)* df.dx\n",
    "        E = df.sqrt (abs( df.assemble ( error )))\n",
    "        \n",
    "\n",
    "        # Divergence flag\n",
    "        if ( E_old < E ):\n",
    "            fail = 1\n",
    "            print(\"* Diverges at reinit *\", cont)\n",
    "            break\n",
    "        \n",
    "        cont +=1\n",
    "        E_old = E\n",
    "\n",
    "        phi0.assign(phi_new)\n",
    "\n",
    "    return phi0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data \n",
    "We try to load data from test 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_37309/4098198376.py:23: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  phi1_img_fun.vector().set_local(phi10[idx_img])\n",
      "/tmp/ipykernel_37309/4098198376.py:24: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  phi2_img_fun.vector().set_local(phi20[idx_img])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Agrad\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/_index.py:100: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
      "  self._set_intXint(row, col, x.flat[0])\n",
      "/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py:229: SparseEfficiencyWarning: spsolve requires A be CSC or CSR matrix format\n",
      "  warn('spsolve requires A be CSC or CSR matrix format',\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Mesh used for image\n",
    "Nimg = 256\n",
    "himg = 0.23 / Nimg\n",
    "mimg = -0.115 + himg\n",
    "mesh_img = df.RectangleMesh(df.Point(mimg,mimg), df.Point(-mimg,-mimg), Nimg-1,Nimg-1)\n",
    "V_img = df.FunctionSpace(mesh_img,'CG',1)\n",
    "idx_img = df.dof_to_vertex_map(V_img)\n",
    "idx_img2 = df.vertex_to_dof_map(V_img)\n",
    "\n",
    "# Load data\n",
    "mat_file = glob.glob(inputFolder + '/data4.mat')\n",
    "mat_dict = sp.io.loadmat(mat_file[0])\n",
    "Uel = mat_dict[\"Uel\"]\n",
    "# Load ground truth and plot\n",
    "ground_truth = glob.glob(truthFolder + '/true4.mat')\n",
    "truth_dict = sp.io.loadmat(ground_truth[0])\n",
    "\n",
    "# Represent start guess phi1 and phi2 on mesh\n",
    "#q0_img = 20*np.flipud(truth_dict[\"truth\"]).reshape(256**2,1)+0.8\n",
    "phi1_img_fun = df.Function(V_img)\n",
    "phi2_img_fun = df.Function(V_img)\n",
    "\n",
    "phi1_img_fun.vector().set_local(phi10[idx_img])\n",
    "phi2_img_fun.vector().set_local(phi20[idx_img])\n",
    "\n",
    "phi1_img_fun.set_allow_extrapolation(True)\n",
    "phi2_img_fun.set_allow_extrapolation(True)\n",
    "\n",
    "phi1_fun = df.interpolate(phi1_img_fun,V1)\n",
    "phi2_fun = df.interpolate(phi2_img_fun,V1)\n",
    "\n",
    "# Extract vector of values in the right order\n",
    "phi10 = phi1_fun.vector().get_local()[idx2]\n",
    "phi20 = phi2_fun.vector().get_local()[idx2] \n",
    "\n",
    "q1 = 0.8\n",
    "q2 = 1e-2\n",
    "q3 = 10\n",
    "q4 = 100\n",
    "\n",
    "q = q1*((phi10>0)*(phi20>0)) + q2*((phi10>0)*(phi20<=0)) + q3*((phi10<=0)*(phi20>0)) + q4*((phi10<=0)*(phi20<=0))\n",
    "#q0 = q\n",
    "\n",
    "# We cast it as an CG1 function\n",
    "qfun = df.Function(V1)\n",
    "qfun.vector().set_local(q[idx])\n",
    "\n",
    "p = df.plot(qfun)\n",
    "plt.colorbar(p)\n",
    "\n",
    "# Initialize solver and jacobian and reference data\n",
    "Uel_sim = solver.SolveForward2(q, z)\n",
    "JJ = solver.Jacobian(0.8+0*q,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.43380689910611"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAAGiCAYAAACYr974AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABANUlEQVR4nO3df3RU9Z3/8dfMJDOTH0wChGQgBgNiRVokmJgY2361NTZUj5Wtu4suK5hDcavQukbbgkVCZdeoUExbsVld6W8L656u26plS6O0a41EA2wVgWoVg8AECCQhCZlJZu73jzBDJpkJk0wmmcDzcc4cyc3n/pg5JveVz/18Pm+TYRiGAADABc082hcAAABGH4EAAAAQCAAAAIEAAACIQAAAAEQgAAAAIhAAAAARCAAAgAgEAABABAIAACACAQAAcWnjxo3Kzc2V3W5XUVGR6urqBmxfVVWlyy67TElJScrJydF9992nzs7OiM9HIAAAIM5s2bJF5eXlqqio0M6dOzVnzhyVlpbq6NGjIds/99xzWrFihSoqKrR37149++yz2rJlix588MGIz2miuBEAAPGlqKhIV111lZ588klJks/nU05Ojr72ta9pxYoV/dovX75ce/fuVU1NTWDb/fffrx07dui1116L6JwJw3PpY4vP59Phw4c1btw4mUym0b4cAMAgGYahU6dOacqUKTKbY9PZ3dnZKY/HMyzHMgyj3/3GZrPJZrP1a+vxeFRfX6+VK1cGtpnNZpWUlKi2tjbk8a+55hr9/Oc/V11dnQoLC/XBBx/o5Zdf1h133BHxNV6QgeDw4cPKyckZ7csAAETp4MGDuuiii4b9uJ2dncq9OFWNR73DcrzU1FS1tbUFbauoqNCaNWv6tT1+/Li8Xq+ysrKCtmdlZWnfvn0hj/8P//APOn78uD7zmc/IMAx1d3frq1/96qAeGVyQgWDcuHGSev5Hcjgco3w1AIDBam1tVU5OTuD3+XDzeDxqPOrVX966SI5x0fVAtJ7y6RMFH/e754TqHRiq7du365FHHtFTTz2loqIivf/++7r33nu1du1aPfTQQxEd44IMBP5uG4fDQSAAgDEs1o99HePMUQeCwLEivOdkZGTIYrGosbExaHtjY6OcTmfIfR566CHdcccd+spXviJJmj17ttrb23XXXXfp29/+dkSPVZhlAABAHLFarcrPzw8aIOjz+VRTU6Pi4uKQ+3R0dPS76VssFkk94xcicUH2EAAAEM/Ky8u1ePFiFRQUqLCwUFVVVWpvb1dZWZkkadGiRcrOzlZlZaUk6eabb9aGDRs0d+7cwCODhx56SDfffHMgGJwLgQAAgDizYMECHTt2TKtXr5bL5VJeXp62bt0aGGjY0NAQ1COwatUqmUwmrVq1SocOHdKkSZN0880361//9V8jPucFuQ5Ba2ur0tLS1NLSwhgCABiDYv173H981/6pwzKo0HlZQ9zfcxhDAAAACAQAAIAxBAAAhNXqc8vwRfe38ymfb5iuJrboIQAAAAQCAABAIAAAACIQAAAAEQgAAIAIBAAAQAQCAAAgAgEAABALEwEAEFarT4p2XaG2sbEuET0EAABgBALBxo0blZubK7vdrqKiItXV1YVtu2fPHt16663Kzc2VyWRSVVVV1McEAADnFtNAsGXLFpWXl6uiokI7d+7UnDlzVFpaqqNHj4Zs39HRoenTp+vRRx+V0+kclmMCAIBzi2kg2LBhg5YuXaqysjLNmjVL1dXVSk5O1qZNm0K2v+qqq7Ru3Trddtttstlsw3JMAABwbjELBB6PR/X19SopKTl7MrNZJSUlqq2tHdFjut1utba2Br0AAMBZMQsEx48fl9frVVZWVtD2rKwsuVyuET1mZWWl0tLSAq+cnJwhnR8AgPPVBTHLYOXKlWppaQm8Dh48ONqXBABAXInZOgQZGRmyWCxqbGwM2t7Y2Bh2wGCsjmmz2cKOSQAAADHsIbBarcrPz1dNTU1gm8/nU01NjYqLi+PmmAAAhHPCZ1dTlK8TPvtov42IxHSlwvLyci1evFgFBQUqLCxUVVWV2tvbVVZWJklatGiRsrOzVVlZKaln0OC7774b+PehQ4e0e/dupaamasaMGREdEwAADF5MA8GCBQt07NgxrV69Wi6XS3l5edq6dWtgUGBDQ4PM5rOdFIcPH9bcuXMDX69fv17r16/Xtddeq+3bt0d0TAAAMHgmwzCM0b6Ikdba2qq0tDS1tLTI4XCM9uUAAAYp1r/H/cf/3dsXK2VcdE/X20/59IXZH8X9PeeCmGUAAAAGRiAAAAAEAgAAQCAAAAAiEAAAABEIAACAYrwOAQAAY1mLL0ldPktUx+jweYfpamKLHgIAAEAgAAAABAIAACACAQAAEIEAAIC4tHHjRuXm5sput6uoqEh1dXVh21533XUymUz9XjfddFPE5yMQAAAQZ7Zs2aLy8nJVVFRo586dmjNnjkpLS3X06NGQ7X/1q1/pyJEjgdc777wji8Wiv/u7v4v4nAQCAADizIYNG7R06VKVlZVp1qxZqq6uVnJysjZt2hSy/YQJE+R0OgOvbdu2KTk5mUAAAEC8aW1tDXq53e6Q7Twej+rr61VSUhLYZjabVVJSotra2ojO9eyzz+q2225TSkpKxNfHwkQAAIRxwpui093R3SpPe7slSTk5OUHbKyoqtGbNmn7tjx8/Lq/Xq6ysrKDtWVlZ2rdv3znPV1dXp3feeUfPPvvsoK6TQAAAwAg4ePCgHA5H4GubzRaT8zz77LOaPXu2CgsLB7UfgQAAgBHgcDiCAkE4GRkZslgsamxsDNre2Ngop9M54L7t7e3avHmzHn744UFfH2MIAACII1arVfn5+aqpqQls8/l8qqmpUXFx8YD7Pv/883K73frHf/zHQZ+XHgIAAOJMeXm5Fi9erIKCAhUWFqqqqkrt7e0qKyuTJC1atEjZ2dmqrKwM2u/ZZ5/V/PnzNXHixEGfk0AAAECcWbBggY4dO6bVq1fL5XIpLy9PW7duDQw0bGhokNkc3Mm/f/9+vfbaa/rd7343pHMSCAAAiEPLly/X8uXLQ35v+/bt/bZddtllMgxjyOdjDAEAACAQAAAAHhkAABBWizdZHu/wLEwU7+ghAAAABAIAAEAgAAAAIhAAAAARCAAAgAgEAABABAIAACACAQAAEAsTAQAQVqs3SR5vYlTH6PR2DdPVxBY9BAAAgEAAAAAIBAAAQAQCAAAgAgEAABCBAAAAiEAAAABEIAAAACIQAAAAsVIhAABhNXenyNYd3UqF7m5WKgQAAGMEgQAAABAIAAAAgQAAAIhAAAAARCAAAAAiEAAAABEIAACAWJgIAICwTnXZ5O6yRnUMT9fY+Nt7bFwlAACIKQIBAAAgEAAAAAIBAAAQgQAAgLi0ceNG5ebmym63q6ioSHV1dQO2b25u1rJlyzR58mTZbDZ94hOf0Msvvxzx+ZhlAABAnNmyZYvKy8tVXV2toqIiVVVVqbS0VPv371dmZma/9h6PRzfccIMyMzP1n//5n8rOztZHH32k9PT0iM9JIAAAIM5s2LBBS5cuVVlZmSSpurpaL730kjZt2qQVK1b0a79p0yadOHFCr7/+uhITEyVJubm5gzonjwwAABgBra2tQS+32x2yncfjUX19vUpKSgLbzGazSkpKVFtbG3KfX//61youLtayZcuUlZWlT33qU3rkkUfk9Xojvj56CAAACKO1O0mJUS5M1NVtkSTl5OQEba+oqNCaNWv6tT9+/Li8Xq+ysrKCtmdlZWnfvn0hz/HBBx/olVde0cKFC/Xyyy/r/fff1z333KOuri5VVFREdJ0EAgAARsDBgwflcDgCX9tstmE7ts/nU2Zmpp5++mlZLBbl5+fr0KFDWrduHYEAAIB44nA4ggJBOBkZGbJYLGpsbAza3tjYKKfTGXKfyZMnKzExURaLJbDt8ssvl8vlksfjkdV67l4OxhAAABBHrFar8vPzVVNTE9jm8/lUU1Oj4uLikPt8+tOf1vvvvy+fzxfY9pe//EWTJ0+OKAxIBAIAAOJOeXm5nnnmGf3kJz/R3r17dffdd6u9vT0w62DRokVauXJloP3dd9+tEydO6N5779Vf/vIXvfTSS3rkkUe0bNmyiM/JIwMAAOLMggULdOzYMa1evVoul0t5eXnaunVrYKBhQ0ODzOazf9Pn5OTof/7nf3TffffpiiuuUHZ2tu69915961vfivicJsMwjGF/J3GutbVVaWlpamlpieh5DgAgvsT697j/+H+zrUyJKVHOMmj36L9u+FHc33N4ZAAAAEYmEAx2Pebnn39eM2fOlN1u1+zZs/utxXznnXfKZDIFvebNmxfLtwAAwHkt5oHAvx5zRUWFdu7cqTlz5qi0tFRHjx4N2f7111/X7bffriVLlmjXrl2aP3++5s+fr3feeSeo3bx583TkyJHA65e//GWs3woA4ALT1mUdltdYEPNA0Hs95lmzZqm6ulrJycnatGlTyPbf+973NG/ePH3jG9/Q5ZdfrrVr1+rKK6/Uk08+GdTOZrPJ6XQGXuPHj4/1WwEA4LwV00AwlPWYa2trg9pLUmlpab/227dvV2Zmpi677DLdfffdampqCnsdbre73xrSAADgrJgGgoHWY3a5XCH3cblc52w/b948/fSnP1VNTY0ee+wx/eEPf9AXv/jFsEUcKisrlZaWFnj1XU8aAIAL3Zhch+C2224L/Hv27Nm64oordMkll2j79u26/vrr+7VfuXKlysvLA1+3trYSCgAA6CWmPQRDWY/Z6XQOqr0kTZ8+XRkZGXr//fdDft9mswXWkI50LWkAAC4kMQ0EQ1mPubi4OKi9JG3bti1se0n6+OOP1dTUpMmTJw/PhQMAcIGJ+SyDwa7HfO+992rr1q367ne/q3379mnNmjV66623tHz5cklSW1ubvvGNb+iNN97QgQMHVFNTo1tuuUUzZsxQaWlprN8OAADnpZiPIRjseszXXHONnnvuOa1atUoPPvigLr30Ur3wwgv61Kc+JUmyWCz685//rJ/85Cdqbm7WlClT9IUvfEFr164d1trSAABcSKhlwHgCABhzRqqWwQ0v/9Ow1DLYduO/xf09Z0zOMgAAYCR0dCUqIcqVBru7xsbf3RQ3AgAABAIAAEAgAAAAIhAAAAARCAAAgAgEAABABAIAACACAQAAEAsTAQAQVkeXVRZPdAsTeVmYCAAAjBUEAgAAQCAAAAAEAgAAIAIBAAAQgQAAAIhAAAAARCAAAABiYSJgzDh9ZFrg30mTPxzFKwEuHJ1dibJ0JUZ1DG+Xb5iuJrYIBEAc6x0CJKmh262pCTadPjKNUABgWBEIgDjTNwS0+Nz6oNuuv3oy1eJN1pVJBzTXagTaRRoMBtsewIWFQADEiVC9AX/tnqAP3NPU4k3WR6cnqqUrSS3eZDUnH9CV1hNKM5+7t6DvceldABAKgQAYRQP1BjR4MgIhoLEjVU3tKZKkti6rTnanqCn5I92Q3BAyFIQLF+nmjiH1LgA4/xEIgFEwUG/AAfckHewYr7Yuq462p6qlPUmedqtMpxJkWH16z5Og9i6rlNGzb6G9ITCuoLe+jxoOuCdpfEL7oHoXQl0rIQI4PxEIgBESKgQ0+YJ7Aw51pKm9y6qm9hS1t9nka0uUpc0iW5tJFo/ktZrl8SSrwWORJLWm2YPGFfiP2ztctHbZdagjTUfbU5WZ0hboXegdJELd5Htfrz9c0LsAjJyNGzdq3bp1crlcmjNnjn7wgx+osLAwZNsf//jHKisrC9pms9nU2dkZ8fkIBMAI2+UxqdmXHNQb0NiRqnaPNag3IKHNLHubZPZIiW2S9ZQhzziTLB6zTsumBk3o2afXuIKm7tSQjxr84aJlQpLau6xqTbP3XEyfUBCu56KpO0sNnoxB9y4AGJotW7aovLxc1dXVKioqUlVVlUpLS7V//35lZmaG3MfhcGj//v2Br00m06DOSSAARlCLz62dp2fqz205gb/aW9qT1O2xBPUGJLZJFo+U2GbI2mrI2tota4tHnZl2WTwWSWa5PXYd67KosytRbV3WQAgI9aghoc2sRI+CehckhZy10Hccw8nulMAjjEh7FwD019raGvS1zWaTzWYL2XbDhg1aunRp4K/+6upqvfTSS9q0aZNWrFgRch+TySSn0znk6yMQACOoxddzE/5LyyQ1NE6Qr8sS1BuQ2NYTAixuydbqVWJrtxKaO2VuPiV1upXUmSEpVZJFZo9Jbo9Vp9xmvedJ0NGUVHV2JYZ81JB4pqfB4ukJEqF6F9LNHUE9F70fNbS0J0lSoHehxZusG1L2EQpw3nN7LLIkRHer9Hq6JUk5OTlB2ysqKrRmzZp+7T0ej+rr67Vy5crANrPZrJKSEtXW1oY9T1tbmy6++GL5fD5deeWVeuSRR/TJT34y4uskEACjxNdlke0j65kQ0PNIwOI+2xtgae6QmltldJyW93TPc0Bzx2klKUdmd7Is7kRZPCZ1ehLk8STrmNUuk8cc8lGDrdUrSWd6F0xyK7h34WR3isYntId91GBps8hnNdTgsajdYw28h6GuiQBciA4ePCiHwxH4OlzvwPHjx+X1epWVlRW0PSsrS/v27Qu5z2WXXaZNmzbpiiuuUEtLi9avX69rrrlGe/bs0UUXXRTR9REIgBHU5LPrZHdKz03VbZbFI6UcMfr1BhgnmgMhoDff6U6ZPziopM4sWdwOWdxWmT1mWTxmea3msI8aLM0d8tmtMruTJSX2611o77IqJdET9lFDYpvks5oCjyl2SUNaEwG4kDkcjqBAMJyKi4tVXFwc+Pqaa67R5Zdfrn/7t3/T2rVrIzoGgQAYQc2+ZLV22dXZlSiTx9zTje82lNTQJrPruLxNJ+U9xzF8pzulv34ka6dTls7xSnD7xxUo7KMGb9NJmZPssilHUv/eBf+4glCPGvzhwuMwyewx6bQSdUxpQb0LjCsAhk9GRoYsFosaGxuDtjc2NkY8RiAxMVFz587V+++/H/F5CQTACPB3qTd1p6qlK0luT4LMnp6bboLbJ3OnR96mk4M6pveQS5Yz4wp6/vJX0KOGvuFioN4Ft8cus8cU8lGDP1y4s3qChNS/dyHcrAUAg2e1WpWfn6+amhrNnz9fkuTz+VRTU6Ply5dHdAyv16u3335bN954Y8TnJRAAI6TF51aLN3lYj+ltOimLpKROh9TpDvuowS9c70Jim+nMoMP+jxr8x03qzJKULql/74J/XEE0tRYAnFVeXq7FixeroKBAhYWFqqqqUnt7e2DWwaJFi5Sdna3KykpJ0sMPP6yrr75aM2bMUHNzs9atW6ePPvpIX/nKVyI+J4EAGGFtXVZ1eyyyeHpuwma3T+p0D/l43qaTUpS9Cx5HghLcvgHHMZgPNypJCtm70CRpl7IZVwAMkwULFujYsWNavXq1XC6X8vLytHXr1sBAw4aGBpnN5kD7kydPaunSpXK5XBo/frzy8/P1+uuva9asWRGfk0AAxEj/pYR7/oJu77LK12VR4pm/yC1RBoKh8jadlLnjtGzKkbUlIeyjBr9wvQs94wr6z1oYqNYCgHNbvnx52EcE27dvD/r6iSee0BNPPBHV+QgEwDAKV0/AP7+/7wwDi1uydHbL6Dg9KtfrH1dgkgZ81NBb/7ELA48rYLAhMDYQCIBhEEnp4t6L/PhnGMQDX4RBoLfevQsDzVqQGFcAjBUEAmCIzlW62L/kb99FfvyLB0k9Uw5Nnd1DuimPtnPNWgi1GiLjCjDWeD0WGQmWczccgM8T3f4jhUAADNK5Shf3XfLXv8iP2WMK1CnwT+sLTDkcpfcSrfBrIoReDZFxBUD8IhAAEThXb8BAS/4mes6GgN4rCFrcPiU0d47KgMLhFmpcQajVEJXR055xBUD8IRAA59C7CmCLT0G9AQOVLk4MrPQXvMiPpbP7nCP6x6JIxxX4iyMxrgCILwQCIAIN3W7VdU4N9Ab4HwmEqi4Yrp6AqbN7wDoF54OBxhWclo1xBUAcIxAAEWjy2fV/HRfrreM5ampPkduTENQb4C9dbPb0X/LX3Ok573oDBhJ+XIE5UByp97gCOfYQCoA4QCAAItDs61lyuN1j1SlXalBvQE+PQIglf/uULr7Q9B5XIKVKsoQeVyBRHAmIAwQCYAC9BxP2rlKY5DLJfsIIWV3wfH4kMFj+cQVJypHZ3X9cwWFJb4lxBUA8IBAAEQhVpTD5mFf2o53n5QDB4TTwuIKzxZF6jyv4nL1dkugtAEYQgQA4B3+VwlBFiSyuk/Ieco32Jca9UOMKen79hBlXoD2BUACMJl+3ReqKcmGibhYmAs4LfYsSjY0f7fjUd1yBvziSf1xBg6Ts5JZAe3oHgJFDIAAGyTzKVQrHOm/TSVkkJUmBcQU+q0ldEyR7YpcciZ1KN3eM9mUCFxwCAXAOTT573FUpHOv8ocCSfpG8NslrlWTzKcXq0fiEdk00d0qyjfJVAhcW82hfABDvmn3JQTMMzJ6xXZQobtht8trM8lpN8lklc6JXKYkepVnoHQBGA4EACMM/9S3UDAN/USLERhq/mYARx48dgNFht8lnM8tnlXxWQwlWr1LP9BCkmXlcAIw0AgEwgL5TDs29phwyoDA6PrtV3TazvGcCgc3arbTE05qY0DbalwZckAgEwAD6TjlkhsHwMCfZZdgT5LX1jB8wrD5mGACjjFkGwACYYRAbpuQkee0J8p7jyQArFWLUuc2SOcq/nd1j42/vsXGVwCjpPcMAseGfctjZlaiDHeP1atssvdqZohZfTw9M73oSAGKHHgIghFA3IaYcDqMzUw6lnmqRviNWnZL0rrICyxdTAREYWQQCYAADTTmkkFEUOt2yNXZIOlsBsUPBZZH9FRBvSNkXCAUSyxkDsUIgAMIYqKgRAwqjEyiLfKYCYs+qhGfLIveugCgpUBZZYlwBECsEAiCMvjMMEs/MMMDw6F0BMVWTgsoi+ysg9vhEoCzyldYTrFEAxAiBABgkphwOL+8hl6xSoCxy7wqIx5QWVBY5Pf3NQE8BgOFFIADCYMrhyOldFtlfAVEySeoZbNie0k7RIyDGCARAGBQ1Glm9xxVI6fKMs8o9IbjoETUOgNghEAB9RFLUiBkGseE73SmLRI0DxA2TxyyTJbokavKMjSQ7Nq4SGGH+GQYYef4aBwBGFj91wAAoajR6whU9YsohEBsEAiAEihqNDooeAaOHQACEwAyD0dG76JG/xkGK1dNrhgGAWCEQACH0nWGAEXKmxoHX2tNDYE5k+CYwUkbkN93GjRuVm5sru92uoqIi1dXVDdj++eef18yZM2W32zV79my9/PLLQd83DEOrV6/W5MmTlZSUpJKSEr333nuxfAu4QISrrMeUw9HDlENcqAZ77/TbvHmzTCaT5s+fP6jzxfxHbMuWLSovL1dFRYV27typOXPmqLS0VEePHg3Z/vXXX9ftt9+uJUuWaNeuXZo/f77mz5+vd955J9Dm8ccf1/e//31VV1drx44dSklJUWlpqTo7+UWN4THQlEPEkN3GlENAg793+h04cEAPPPCAPvvZzw76nDEPBBs2bNDSpUtVVlamWbNmqbq6WsnJydq0aVPI9t/73vc0b948feMb39Dll1+utWvX6sorr9STTz4pqad3oKqqSqtWrdItt9yiK664Qj/96U91+PBhvfDCCyGP6Xa71draGvQCwulb1IgZBiPHP+Uw3AwDYCzrex9yu8P/PhnsvVOSvF6vFi5cqO985zuaPn36oK8vpoHA4/Govr5eJSUlZ09oNqukpES1tbUh96mtrQ1qL0mlpaWB9h9++KFcLldQm7S0NBUVFYU9ZmVlpdLS0gKvnJycaN8azmMDzjBAzEQyw4Aphxhp5i7TmT8Konh1mSRJOTk5QfeiysrKkOccyr1Tkh5++GFlZmZqyZIlQ3qvMV2p8Pjx4/J6vcrKygranpWVpX379oXcx+VyhWzvcrkC3/dvC9emr5UrV6q8vDzwdWtrK6EAQ0MPQcyYkpNG+xKAmDp48KAcDkfga5st9GOwodw7X3vtNT377LPavXv3kK/vgli62Gazhf3ggb6Ycjh6Bp5yyM8wxjaHwxEUCIbLqVOndMcdd+iZZ55RRkbGkI8T00CQkZEhi8WixsbGoO2NjY1yOp0h93E6nQO29/+3sbFRkydPDmqTl5c3jFePCxVFjUZJiCmHzDDAhWiw986//vWvOnDggG6++ebANp+v5xFnQkKC9u/fr0suueSc543pj5nValV+fr5qamoC23w+n2pqalRcXBxyn+Li4qD2krRt27ZA+2nTpsnpdAa1aW1t1Y4dO8IeE4hEJEWNEEPMMAAkDf7eOXPmTL399tvavXt34PWlL31Jn/vc57R79+6IH5HH/JFBeXm5Fi9erIKCAhUWFqqqqkrt7e0qKyuTJC1atEjZ2dmBwRX33nuvrr32Wn33u9/VTTfdpM2bN+utt97S008/LUkymUz653/+Z/3Lv/yLLr30Uk2bNk0PPfSQpkyZMug5l0BfvWcYYGT1nmEAXOgGc++02+361Kc+FbR/enq6JPXbPpCYB4IFCxbo2LFjWr16tVwul/Ly8rR169bAYImGhgaZzWc7Kq655ho999xzWrVqlR588EFdeumleuGFF4Le1De/+U21t7frrrvuUnNzsz7zmc9o69atstvtsX47uIB0eyyyMOVwVPishpIpaoQL2GDvncPBZBiGMaxHHANaW1uVlpamlpaWmAzwwNh0+sg0NXS79Z+tV2qba6YOfDxJto+sGtdgKO2vbln3fSxv08nRvszzkjnJLt+saWqZkaJTF5vUMbVbk3JO6topf9WX09/UXKtBIECQWP8e9x8/91//VeYo/9j0dXbqwLe/Hff3HIbqAL0ww2B0UNQIGH0EAqCXUDMMJMmTZpUxPUfmJB5LxcQAMwwAjIwLYh0C4FxCFTUyrD65J5glmeS1JcpnS1WScmRxHefRwQhiyiFGk9ljktlsiu4gnij3HyEEAqCXpu5UORI7NTX9pBoknbIly2dNlM9qkmSRlCq7PUEWu03eQ6FXxsQQMOUQGHUEAqCXG5IbNDGhTeMT2pWaeJE+SJygpsRUnbbaJJnltSao25asJHuCrHabjMONLFY0DPoWNeo7wwBA7BEIAPVMaTt9ZJrSzDZ9zt6udPO7PX+dJuboL9ZJatAEnZZNXqtZPqtZXptNSbZ02exWmT84SCiIgjnJLh9FjYBRRyAAzvDfdE4fmaa5VkMTzfuUZumQI7HnZn/Ymia31S6fNUFea8+4AilZNuUQCqLgn2EAYHTxUwj04e8tmJpgU1pyQ8/GDGlvokcN1vGBcQWSSdbWBFlbEjQ2hgzFN4oaAaOLQACE0PsRQt9xBbs82eo6lSCdiQEUPYoSRY2AuMCPGxCG/xFCmtmmK60nNNV6PPA9ih4ND3OSnRkGQJyghwAYgL+nQFKg6BE1DqJnmTheSnfIm54sT1r/GQYARh6BAIhAi68nELR3WeXrsiiRToFBMyfZZZqQLl/6OHnS7epyJMjtsMhrk7pSex4X+FHUCPHC5JGirSFkjJHfFwQCYIgsHkMWeggG5A8BstsCvQEeR4I8DpO8VpO6UqWuVKk71ZA31Stzale/KYcARgaBAIgARY+GxpScJE/upEBvgGdcT0/A2SDgkzGuW9YUj5Kt3ZqY0q6s5DZmGACjgEAARCBU0SOL22CGQYQ6JlnU4TTJaw3uDUhNdcue2KXMlDZlJ7fo4qQmTbUe1yXWo8wwAEYYgQAYgH9AYVN3qlq6kuT2JPSbYWAk2QkF4fSaUtiVKnVN9sia4tGElNNKsXqUldymnOSTyrUd03TbUV2ScEJpZp2ZXUDvADCSCATAELkdFpkv7lm+mAqIYfSZUmhN8Whu9iGlJZ4O6g2YntDZLwQwmBAYWQQC4BxafO7AlEObtVunJnapw2MNLF/ss1EBMZxwRYvmT6zXJQknNDXBHwB6/ksIAEYPgQCIwHTbUV0z8QOlJl6kd5WlU1KgLHJQBUSJUHBG76JFoZwNAwQBIB4QCIBz6FsBUVJQWWR/BUTJKmkSZZFDoIohEP8IBMAAeq9UONdqSDogSYGyyL0rIErBZZEv9HEF/iqGFC3CWGbpkizRznjpGpZLiTkCAXAOA5VFDlRAVKo6lMC4gt4oWgSMKQQCIEJ9yyL3roD4rhQoi9x7XEGqJIsunHEFfVcm7Fu0CED8IhAAg9C7LLJ/XIFf6HEFZwYbnufjCvzFinx2q7p61SnwjOtZjMiPKoZA/CIQAIPUb1xBas9gw77jCnp+vM7fcQV9ixV5beZAnYKu1J6FiHqvTOifckjRIiA+EQiAIYh0XIHPGmJcgTTmQ4E5yS7frGnypFnls5kDvQH+GgU+a3Cdggkpp5WZ0kbRIiCOEQiAKIQbVyBNV4PCjStwnjeDDU9PSlTnRFNwsSKrL1CnwF+sqPfKhMwwAOITgQCIUrhxBamJF/UbVyCdH+MKek8p7JwguZ3dks0na4pHaWd6A/zFitIsHYE6BT2LEREGgHhEIACGwWDGFfis58G4gr5TClO7NDXrRFCxojRLB3UKgDGEQAAMk3ONK3hPk+SW/fwYV9CnaFGC1aus5DZ9dvxf+vQGSNQpwFhm9kjm0KtvR8zwDM+1xBqBABhm4ccVqGewYZ9xBZJd9jE2rsBftKivNEuHPmdvFyEAGHsIBEAM9B1X4F/yOPS4gl7FkUZgXIE5yS5Jw3KOvlUMmVIIjF0EAiBGeo8r6F0cqfe4Ao+SJZlHZFyBf/Egb3qyTJ3dQz5H7yqG4YoWARh7CARADEU0rsAau3EFfRcP6nIkqNtmVoLbN+RaCxQtAs5PBAJgBIQaV+A33OMKzEl2mZKTAr0BnjRrYAXBwKwAj/nsYwpFVmuhd7gIVbQIwNhGzTFghPh7C/zjCj7v2KNrJn6gWZMaNSmzRYazU6edPrknSKeyE9SWkyxP7iRZLrk48Nx/IJaJ42XJdsqYniPPzIvU/okJapmRopbpVrVPMavDaVLbVKltqqEOp9Q+xazTk6znPIdl4nhZLrlYvlnTdPqyLJ2emqrTkxL7taOKITC8Nm7cqNzcXNntdhUVFamuri5s21/96lcqKChQenq6UlJSlJeXp5/97GeDOh89BMAIimRcwWklB4ojnWtcQdBf7faEoN6ArtSewkI9Kwj21BMwp/YUZne3JcpnDV9rIdSjBrfDIq9NgToF/pUJE61eihYBw2zLli0qLy9XdXW1ioqKVFVVpdLSUu3fv1+ZmZn92k+YMEHf/va3NXPmTFmtVr344osqKytTZmamSktLIzongQAYYQONK3hL0mEp5LiCJCkwrqD3AEGvPSGouuBA9QRSrB6lJHrU0NxTa6FDIcYuhHnUcDYEnA0XiVav0lJOB80wABC9DRs2aOnSpSorK5MkVVdX66WXXtKmTZu0YsWKfu2vu+66oK/vvfde/eQnP9Frr71GIADiXbhxBYHiSL3GFfREgZ4btsmZEba6YE8QOHvD9tcTSEn0BJYSlnqmP76r0LUWEjLtgXDhO9PDEKhTcCZcJFu7A3UK/CsT+mcYMOUQCK21tTXoa5vNJputf6+ax+NRfX29Vq5cGdhmNptVUlKi2trac57HMAy98sor2r9/vx577LGIr49AAIyi3usVXGk9ITn2aHxCe7/1CiTz2Ru229evN6A71ZDPavSrLpid3CJHYqdybcc03Xa037TAvmsi+M7UWwj1qCE11S17YldQnYKp1uO6xHpUE82dvVYmBM4fFo9kiXKlQp0Zc5uTkxO0uaKiQmvWrOnX/Pjx4/J6vcrKygranpWVpX379oU9TUtLi7Kzs+V2u2WxWPTUU0/phhtuiPgyCQTAKAtVHKn3uIIGTdBpBd+wz1VdMCf5pMYntAdu2GfrCZwxYK2F0I8aevcG+JcnTjMrqE4BvQNAeAcPHpTD4Qh8Hap3IBrjxo3T7t271dbWppqaGpWXl2v69On9HieEQyAA4sBA4wokBW7YPmtC0CMB/zP8gasLSr1v2OHWRGiw9owrGKh0McWKgKFzOBxBgSCcjIwMWSwWNTY2Bm1vbGyU0+kMu5/ZbNaMGTMkSXl5edq7d68qKysJBMBY1HdcgSQpI3hcQbhn+JFWFwxfa2G6jvZ6JND7UQPFioCRY7ValZ+fr5qaGs2fP1+S5PP5VFNTo+XLl0d8HJ/PJ7fbHXF7AgEQZ3o/Qrih1w3bP67g3M/wz33DDvWYQpJOpqWEedRAbwAwksrLy7V48WIVFBSosLBQVVVVam9vD8w6WLRokbKzs1VZWSlJqqysVEFBgS655BK53W69/PLL+tnPfqYf/vCHEZ+TQADEoXDjCnKSJw3bM/zeayLMtRpS6rtq9iXTGwDEgQULFujYsWNavXq1XC6X8vLytHXr1sBAw4aGBpnNZ1cCa29v1z333KOPP/5YSUlJmjlzpn7+859rwYIFEZ/TZBiGMezvJM61trYqLS1NLS0tET3PAUaT/6bd0O1Wk8/ef4Cgor9h+8/RF0EA8SrWv8f9x//kVx+RxXbulUIH4nV3ak/1g3F/z6GHAIhzvZ/5T5WhWPzV3ru3gBAAXJgIBMAYMBI3bIIAcGEjEABjBDdsYOSZuyRzlAsTGV3Dcy2xRm0yAABAIAAAAAQCAAAgAgEAABCBAAAAiEAAAABEIAAAACIQAAAAsTARAABhWTyGLIqy5I9nbJQMoocAAAAQCAAAAIEAAACIQAAAAEQgAAAAIhAAAAARCAAAgAgEAABALEwEAEBYFrdkiXZdIc+wXErM0UMAAAAIBAAAIMaB4MSJE1q4cKEcDofS09O1ZMkStbW1DbhPZ2enli1bpokTJyo1NVW33nqrGhsbg9qYTKZ+r82bN8fyrQAAcF6LaSBYuHCh9uzZo23btunFF1/UH//4R911110D7nPffffpN7/5jZ5//nn94Q9/0OHDh/XlL3+5X7sf/ehHOnLkSOA1f/78GL0LAADOfzEbVLh3715t3bpVb775pgoKCiRJP/jBD3TjjTdq/fr1mjJlSr99Wlpa9Oyzz+q5557T5z//eUk9N/7LL79cb7zxhq6++upA2/T0dDmdzlhdPgAAF5SY9RDU1tYqPT09EAYkqaSkRGazWTt27Ai5T319vbq6ulRSUhLYNnPmTE2dOlW1tbVBbZctW6aMjAwVFhZq06ZNMozww0DdbrdaW1uDXgAA4KyY9RC4XC5lZmYGnywhQRMmTJDL5Qq7j9VqVXp6etD2rKysoH0efvhhff7zn1dycrJ+97vf6Z577lFbW5u+/vWvhzxuZWWlvvOd70T3hgAAOI8NuodgxYoVIQf19X7t27cvFtca8NBDD+nTn/605s6dq29961v65je/qXXr1oVtv3LlSrW0tAReBw8ejOn1AQAw1gy6h+D+++/XnXfeOWCb6dOny+l06ujRo0Hbu7u7deLEibDP/p1Opzwej5qbm4N6CRobGwccL1BUVKS1a9fK7XbLZrP1+77NZgu5HQAA9Bh0IJg0aZImTZp0znbFxcVqbm5WfX298vPzJUmvvPKKfD6fioqKQu6Tn5+vxMRE1dTU6NZbb5Uk7d+/Xw0NDSouLg57rt27d2v8+PHc9AEAw8rsMWQZYIxaJIyuaJc6HBkxG0Nw+eWXa968eVq6dKmqq6vV1dWl5cuX67bbbgvMMDh06JCuv/56/fSnP1VhYaHS0tK0ZMkSlZeXa8KECXI4HPra176m4uLiwAyD3/zmN2psbNTVV18tu92ubdu26ZFHHtEDDzwQq7cCAMB5L6a1DH7xi19o+fLluv7662U2m3Xrrbfq+9//fuD7XV1d2r9/vzo6OgLbnnjiiUBbt9ut0tJSPfXUU4HvJyYmauPGjbrvvvtkGIZmzJihDRs2aOnSpbF8KwAAnNdMxkDz9c5Tra2tSktLU0tLixwOx2hfDgBgkGL9e9x//Kvm/4sSEu1RHau7q1NvvrAq7u851DIAAAAEAgAA4tHGjRuVm5sru92uoqIi1dXVhW37zDPP6LOf/azGjx+v8ePHq6SkZMD2oRAIAACIM1u2bFF5ebkqKiq0c+dOzZkzR6Wlpf2m8/tt375dt99+u1599VXV1tYqJydHX/jCF3To0KGIz0kgAAAgzvgHy5eVlWnWrFmqrq5WcnKyNm3aFLL9L37xC91zzz3Ky8vTzJkz9e///u/y+XyqqamJ+JwEAgAARkDfmjputztkO4/Ho/r6+qC6PmazWSUlJf3q+oTT0dGhrq4uTZgwIeLrIxAAABBGgts3LC9JysnJUVpaWuBVWVkZ8pzHjx+X1+tVVlZW0Pa+dX0G8q1vfUtTpkwJChXnfK8RtwQAAEN28ODBoGmHsVpd99FHH9XmzZu1fft22e2RT5kkEAAAMAIcDkdE6xBkZGTIYrGosbExaPu56vpI0vr16/Xoo4/q97//va644opBXR+PDAAAiCNWq1X5+flBAwL9AwQHquvz+OOPa+3atdq6dasKCgoGfV56CAAAiDPl5eVavHixCgoKVFhYqKqqKrW3t6usrEyStGjRImVnZwfGITz22GNavXq1nnvuOeXm5gbGGqSmpio1NTWicxIIAACIMwsWLNCxY8e0evVquVwu5eXlaevWrYGBhg0NDTKbz3by//CHP5TH49Hf/u3fBh2noqJCa9asieicBAIAAOLQ8uXLtXz58pDf2759e9DXBw4ciPp8jCEAAAAEAgAAwCMDAADCMnt8Mvt80R2jO7r9Rwo9BAAAgEAAAAAIBAAAQAQCAAAgAgEAABCBAAAAiEAAAABEIAAAAGJhIgAAwrK4fbJ4o1tYyGBhIgAAMFYQCAAAAIEAAAAQCAAAgAgEAABABAIAACACAQAAEIEAAACIQAAAAMRKhQAAhGXp7JYloTuqYxjd0e0/UughAAAABAIAAEAgAAAAIhAAAAARCAAAgAgEAABABAIAACACAQAAEAsTAQAQlsntlSnKhYVMXu8wXU1s0UMAAAAIBAAAgEAAAABEIAAAACIQAAAQlzZu3Kjc3FzZ7XYVFRWprq4ubNs9e/bo1ltvVW5urkwmk6qqqgZ9PgIBAABxZsuWLSovL1dFRYV27typOXPmqLS0VEePHg3ZvqOjQ9OnT9ejjz4qp9M5pHMSCAAAiDMbNmzQ0qVLVVZWplmzZqm6ulrJycnatGlTyPZXXXWV1q1bp9tuu002m21I5yQQAAAwAlpbW4Nebrc7ZDuPx6P6+nqVlJQEtpnNZpWUlKi2tjZm10cgAAAgDHOnZ1hekpSTk6O0tLTAq7KyMuQ5jx8/Lq/Xq6ysrKDtWVlZcrlcMXuvrFQIAMAIOHjwoBwOR+DroXbtxwqBAACAEeBwOIICQTgZGRmyWCxqbGwM2t7Y2DjkAYOR4JEBAABxxGq1Kj8/XzU1NYFtPp9PNTU1Ki4ujtl56SEAACDOlJeXa/HixSooKFBhYaGqqqrU3t6usrIySdKiRYuUnZ0dGIfg8Xj07rvvBv596NAh7d69W6mpqZoxY0ZE5yQQAAAQZxYsWKBjx45p9erVcrlcysvL09atWwMDDRsaGmQ2n+3kP3z4sObOnRv4ev369Vq/fr2uvfZabd++PaJzEggAAIhDy5cv1/Lly0N+r+9NPjc3V4ZhRHU+xhAAAAACAQAA4JEBAADhud3R/+nsC70iYbyhhwAAABAIAAAAgQAAAIhAAAAARCAAAAAiEAAAABEIAACACAQAAEAxDAQnTpzQwoUL5XA4lJ6eriVLlqitrW3AfZ5++mldd911cjgcMplMam5uHpbjAgCAgcUsECxcuFB79uzRtm3b9OKLL+qPf/yj7rrrrgH36ejo0Lx58/Tggw8O63EBABiSTo/U6Y7y5RntdxERkxFteaQQ9u7dq1mzZunNN99UQUGBJGnr1q268cYb9fHHH2vKlCkD7r99+3Z97nOf08mTJ5Wenj5sx/VrbW1VWlqaWlpa5HA4hvYmAQCjJta/x/3HL8n8ihLM1qiO1e3z6PdH/z3u7zkx6SGora1Venp64KYtSSUlJTKbzdqxY8eIH9ftdqu1tTXoBQAAzopJIHC5XMrMzAzalpCQoAkTJsjlco34cSsrK5WWlhZ45eTkDPkaAAA4Hw0qEKxYsUImk2nA1759+2J1rUO2cuVKtbS0BF4HDx4c7UsCACCuDKr88f33368777xzwDbTp0+X0+nU0aNHg7Z3d3frxIkTcjqdg75Iv6Ee12azyWazDfm8AACc7wYVCCZNmqRJkyads11xcbGam5tVX1+v/Px8SdIrr7win8+noqKioV1pDI8LAMCFLiZjCC6//HLNmzdPS5cuVV1dnf70pz9p+fLluu222wIzAQ4dOqSZM2eqrq4usJ/L5dLu3bv1/vvvS5Lefvtt7d69WydOnIj4uAAAYPBitg7BL37xC82cOVPXX3+9brzxRn3mM5/R008/Hfh+V1eX9u/fr46OjsC26upqzZ07V0uXLpUk/b//9/80d+5c/frXv474uAAAYPBisg5BvGMdAgAY20ZqHYLrxy1UginKdQgMj2pO/SLu7znUMgAAAAQCAABAIAAAACIQAAAAEQgAAIAIBAAAQAQCAAAgAgEAANAgaxkAAHAh8Z12y2fyRXcMo2uYria26CEAAAAEAgAAQCAAAAAiEAAAABEIAACACAQAAMSljRs3Kjc3V3a7XUVFRaqrqxuw/fPPP6+ZM2fKbrdr9uzZevnllwd1PgIBAABxZsuWLSovL1dFRYV27typOXPmqLS0VEePHg3Z/vXXX9ftt9+uJUuWaNeuXZo/f77mz5+vd955J+JzmgzDMIbrDYwVLS0tSk9P18GDB+VwOEb7cgAAg9Ta2qqcnBw1NzcrLS0tJsdPS0vTZxNuUYISozpWt7r0v93/3e+eY7PZZLPZQu5TVFSkq666Sk8++aQkyefzKScnR1/72te0YsWKfu0XLFig9vZ2vfjii4FtV199tfLy8lRdXR3RdV6QCxOdOnVKkpSTkzPKVwIAiMapU6diEgisVqucTqf+1/Xfw3K81NTUfveciooKrVmzpl9bj8ej+vp6rVy5MrDNbDarpKREtbW1IY9fW1ur8vLyoG2lpaV64YUXIr7GCzIQTJkyRQcPHtS4ceNkMpmG/fj+5EoPxNDxGUaHzy86fH7Ri/VnaBiGTp06pSlTpgz7sSXJbrfrww8/lMfjGZbjGYbR734Trnfg+PHj8nq9ysrKCtqelZWlffv2hdzH5XKFbO9yuSK+xgsyEJjNZl100UUxP4/D4eCXSZT4DKPD5xcdPr/oxfIzjEXPQG92u112uz2m54gnDCoEACCOZGRkyGKxqLGxMWh7Y2OjnE5nyH2cTueg2odCIAAAII5YrVbl5+erpqYmsM3n86mmpkbFxcUh9ykuLg5qL0nbtm0L2z6UC/KRQazZbDZVVFSEfT6Ec+MzjA6fX3T4/KLHZxid8vJyLV68WAUFBSosLFRVVZXa29tVVlYmSVq0aJGys7NVWVkpSbr33nt17bXX6rvf/a5uuukmbd68WW+99ZaefvrpiM95QU47BAAg3j355JNat26dXC6X8vLy9P3vf19FRUWSpOuuu065ubn68Y9/HGj//PPPa9WqVTpw4IAuvfRSPf7447rxxhsjPh+BAAAAMIYAAAAQCAAAgAgEAABABAIAACACwZCcOHFCCxculMPhUHp6upYsWaK2trYB93n66ad13XXXyeFwyGQyqbm5eViOO1YN5b12dnZq2bJlmjhxolJTU3Xrrbf2W4jDZDL1e23evDmWb2VEDHcZVMMwtHr1ak2ePFlJSUkqKSnRe++9F8u3MOqG+zO88847+/2/Nm/evFi+hVE1mM9vz549uvXWW5WbmyuTyaSqqqqoj4kRYGDQ5s2bZ8yZM8d44403jP/93/81ZsyYYdx+++0D7vPEE08YlZWVRmVlpSHJOHny5LAcd6waynv96le/auTk5Bg1NTXGW2+9ZVx99dXGNddcE9RGkvGjH/3IOHLkSOB1+vTpWL6VmNu8ebNhtVqNTZs2GXv27DGWLl1qpKenG42NjSHb/+lPfzIsFovx+OOPG++++66xatUqIzEx0Xj77bcDbR599FEjLS3NeOGFF4z/+7//M770pS8Z06ZNG/OfVTix+AwXL15szJs3L+j/tRMnTozUWxpRg/386urqjAceeMD45S9/aTidTuOJJ56I+piIPQLBIL377ruGJOPNN98MbPvtb39rmEwm49ChQ+fc/9VXXw0ZCKI97lgylPfa3NxsJCYmGs8//3xg2969ew1JRm1tbWCbJOO//uu/Ynbto6GwsNBYtmxZ4Guv12tMmTLFqKysDNn+7//+742bbropaFtRUZHxT//0T4ZhGIbP5zOcTqexbt26wPebm5sNm81m/PKXv4zBOxh9w/0ZGkZPILjlllticr3xZrCfX28XX3xxyEAQzTERGzwyGKTa2lqlp6eroKAgsK2kpERms1k7duyIu+PGo6G81/r6enV1damkpCSwbebMmZo6dWq/cqDLli1TRkaGCgsLtWnTJhljeKkNfxnU3u87kjKovdtLPWVQ/e0//PBDuVyuoDZpaWkqKioKe8yxLBafod/27duVmZmpyy67THfffbeampqG/w2MsqF8fqNxTESPpYsHyeVyKTMzM2hbQkKCJkyYMKgykyN13Hg0lPfqcrlktVqVnp4etL1vec+HH35Yn//855WcnKzf/e53uueee9TW1qavf/3rw/4+RkIsyqD6/xttqdSxIlalZOfNm6cvf/nLmjZtmv7617/qwQcf1Be/+EXV1tbKYrEM/xsZJUP5/EbjmIgegeCMFStW6LHHHhuwzd69e0foasamePgMH3roocC/586dq/b2dq1bt27MBgLEr9tuuy3w79mzZ+uKK67QJZdcou3bt+v6668fxSsDhoZAcMb999+vO++8c8A206dPl9Pp1NGjR4O2d3d368SJE4MqM9lXrI47kmL5GTqdTnk8HjU3Nwf1EpyrvGdRUZHWrl0rt9s9JousxKIMqv+/jY2Nmjx5clCbvLy8Ybz6+DBSpWSnT5+ujIwMvf/+++dVIBjK5zcax0T0GENwxqRJkzRz5swBX1arVcXFxWpublZ9fX1g31deeUU+ny9QdGIoYnXckRTLzzA/P1+JiYlB5T3379+vhoaGAct77t69W+PHjx+TYUCKTRnUadOmyel0BrVpbW3Vjh07BlUqdawYqVKyH3/8sZqamoJC1vlgKJ/faBwTw2C0RzWORfPmzTPmzp1r7Nixw3jttdeMSy+9NGjK3Mcff2xcdtllxo4dOwLbjhw5Yuzatct45plnDEnGH//4R2PXrl1GU1NTxMc9nwzlM/zqV79qTJ061XjllVeMt956yyguLjaKi4sD3//1r39tPPPMM8bbb79tvPfee8ZTTz1lJCcnG6tXrx7R9zbcNm/ebNhsNuPHP/6x8e677xp33XWXkZ6ebrhcLsMwDOOOO+4wVqxYEWj/pz/9yUhISDDWr19v7N2716ioqAg57TA9Pd347//+b+PPf/6zccstt5z30w6H8zM8deqU8cADDxi1tbXGhx9+aPz+9783rrzySuPSSy81Ojs7R+U9xtJgPz+3223s2rXL2LVrlzF58mTjgQceMHbt2mW89957ER8TI49AMARNTU3G7bffbqSmphoOh8MoKyszTp06Ffj+hx9+aEgyXn311cC2iooKQ1K/149+9KOIj3s+GcpnePr0aeOee+4xxo8fbyQnJxt/8zd/Yxw5ciTw/d/+9rdGXl6ekZqaaqSkpBhz5swxqqurDa/XO5JvLSZ+8IMfGFOnTjWsVqtRWFhovPHGG4HvXXvttcbixYuD2v/Hf/yH8YlPfMKwWq3GJz/5SeOll14K+r7P5zMeeughIysry7DZbMb1119v7N+/fyTeyqgZzs+wo6PD+MIXvmBMmjTJSExMNC6++GJj6dKl5/XNbDCfn//nt+/r2muvjfiYGHmUPwYAAIwhAAAABAIAACACAQAAEIEAAACIQAAAAEQgAAAAIhAAAAARCAAAgAgEAABABAIAACACAQAAkPT/ASqP5L0zutWtAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Starting guess\n",
    "r1 = 0.02\n",
    "r2 = 0.03\n",
    "k1 = np.linalg.norm(g-[0,0], axis=1)\n",
    "k2 = np.linalg.norm(g-[0,0.05], axis=1)\n",
    "\n",
    "phi10 = k1-r2\n",
    "phi20 = k2-r1\n",
    "phi20 = 2+g[:,0]\n",
    "\n",
    "# Initialize level set function\n",
    "phi1k = phi10\n",
    "phi1 = phi1k\n",
    "phi2k = phi20\n",
    "phi2 = phi2k\n",
    "\n",
    "# Initial level set functions\n",
    "#phi1k = phi10\n",
    "#phi2k = phi20\n",
    "\n",
    "q1 = 0.8\n",
    "q2 = 0.01\n",
    "q3 = 0.01\n",
    "q4 = 0.01\n",
    "\n",
    "# Starting guess becomes this:\n",
    "q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "q0 = q\n",
    "\n",
    "# We cast it as an CG1 function\n",
    "qfun = df.Function(V1)\n",
    "qfun.vector().set_local(q[idx])\n",
    "\n",
    "# Parameters and data for algorithm\n",
    "# Load reference data\n",
    "mat_file = glob.glob(inputFolder + '/ref.mat')\n",
    "mat_dictref = sp.io.loadmat(mat_file[0])\n",
    "Umeas_ref = mat_dictref[\"Uelref\"]\n",
    "\n",
    "# Slice data corresponding to difficulty level\n",
    "Umeas = Uel[vincl]\n",
    "Umeas_ref = Umeas_ref[vincl]\n",
    "\n",
    "# Reinitialization parameters\n",
    "alpha_dif = 9*1e-4 # diffusion parameter\n",
    "dt = 1.5*1e-4\n",
    "Ninit = 50\n",
    "\n",
    "# TV Regularization parameter\n",
    "beta = 1e-12\n",
    "zeta = 25\n",
    "\n",
    "# TV Smoothness parameter in lagged diffusion (should be around average length of element)\n",
    "delta = 1e-3\n",
    "\n",
    "# Smoothness parameter for delta approximation and sign function in reinitializationi (should be small)\n",
    "eps = 1e-3\n",
    "# Step size\n",
    "alpha = 0.05\n",
    "# Number of iterations\n",
    "Miter = 200\n",
    "\n",
    "# Backtracking line search\n",
    "#tau = 0.5\n",
    "#c = 0.025\n",
    "\n",
    "# Initialize Total variation object\n",
    "TV = MyTV(qfun,delta)\n",
    "\n",
    "# Initial functional value\n",
    "#F0 = compute_functional2(q,solver,Umeas,Umeas_ref,z,beta,idx,TV)\n",
    "time_since_last1 = 0\n",
    "time_since_last2 = 0\n",
    "\n",
    "p = df.plot(qfun)\n",
    "plt.colorbar(p)\n",
    "compute_functional3(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,1e5,D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8849994723894359\n",
      "Iteration = 0 ::: Loss = [[0.34196176]]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m/app/level-with-4-classes.ipynb Cell 23\u001b[0m line \u001b[0;36m7\n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=2'>3</a>\u001b[0m j \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(Miter):\n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=4'>5</a>\u001b[0m \n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=5'>6</a>\u001b[0m     \u001b[39m# Take step in phi1 direction\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=6'>7</a>\u001b[0m     dFdq, disp \u001b[39m=\u001b[39m find_direction3_dFdq(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,eps,zeta,D)\n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m     dqdphi1,dqdphi2 \u001b[39m=\u001b[39m find_direction_dqdphi(phi1k,phi2k,q1,q2,q3,q4,eps)\n\u001b[1;32m      <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m     phi1k \u001b[39m=\u001b[39m phi1k \u001b[39m-\u001b[39m alpha \u001b[39m*\u001b[39m (dFdq\u001b[39m*\u001b[39mdqdphi1)\n",
      "\u001b[1;32m/app/level-with-4-classes.ipynb Cell 23\u001b[0m line \u001b[0;36m1\n\u001b[1;32m    <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=99'>100</a>\u001b[0m Usim \u001b[39m=\u001b[39m solver\u001b[39m.\u001b[39mSolveForward2(q, z)\n\u001b[1;32m    <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=101'>102</a>\u001b[0m \u001b[39m# Jacobian\u001b[39;00m\n\u001b[0;32m--> <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=102'>103</a>\u001b[0m J \u001b[39m=\u001b[39m solver\u001b[39m.\u001b[39;49mJacobian(q, z)\n\u001b[1;32m    <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=104'>105</a>\u001b[0m \u001b[39m# TV regularization direction\u001b[39;00m\n\u001b[1;32m    <a href='vscode-notebook-cell://attached-container%2B7b22636f6e7461696e65724e616d65223a222f68617070795f7468617270227d/app/level-with-4-classes.ipynb#X32sdnNjb2RlLXJlbW90ZQ%3D%3D?line=105'>106</a>\u001b[0m tvdir \u001b[39m=\u001b[39m TV\u001b[39m.\u001b[39meval_grad(qfun)\n",
      "File \u001b[0;32m/app/KTCFwd.py:270\u001b[0m, in \u001b[0;36mEITFEM.Jacobian\u001b[0;34m(self, sigma, z)\u001b[0m\n\u001b[1;32m    267\u001b[0m m \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(sigma)\n\u001b[1;32m    268\u001b[0m n \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mUmeas)\n\u001b[0;32m--> 270\u001b[0m Jleft \u001b[39m=\u001b[39m sp\u001b[39m.\u001b[39;49msparse\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49mspsolve(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mA\u001b[39m.\u001b[39;49mT, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mQC\u001b[39m.\u001b[39;49mT, use_umfpack \u001b[39m=\u001b[39;49m \u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m    271\u001b[0m Jright \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtheta\n\u001b[1;32m    273\u001b[0m Js \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros((n, m))\n",
      "File \u001b[0;32m/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py:228\u001b[0m, in \u001b[0;36mspsolve\u001b[0;34m(A, b, permc_spec, use_umfpack)\u001b[0m\n\u001b[1;32m    225\u001b[0m     A \u001b[39m=\u001b[39m A\u001b[39m.\u001b[39mto_scipy_sparse()\u001b[39m.\u001b[39mtocsc()\n\u001b[1;32m    227\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (issparse(A) \u001b[39mand\u001b[39;00m A\u001b[39m.\u001b[39mformat \u001b[39min\u001b[39;00m (\u001b[39m\"\u001b[39m\u001b[39mcsc\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mcsr\u001b[39m\u001b[39m\"\u001b[39m)):\n\u001b[0;32m--> 228\u001b[0m     A \u001b[39m=\u001b[39m csc_matrix(A)\n\u001b[1;32m    229\u001b[0m     warn(\u001b[39m'\u001b[39m\u001b[39mspsolve requires A be CSC or CSR matrix format\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m    230\u001b[0m             SparseEfficiencyWarning)\n\u001b[1;32m    232\u001b[0m \u001b[39m# b is a vector only if b have shape (n,) or (n, 1)\u001b[39;00m\n",
      "File \u001b[0;32m/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/_compressed.py:84\u001b[0m, in \u001b[0;36m_cs_matrix.__init__\u001b[0;34m(self, arg1, shape, dtype, copy)\u001b[0m\n\u001b[1;32m     80\u001b[0m     \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m     81\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39munrecognized \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m_matrix constructor usage\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m     82\u001b[0m                          \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mformat)) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m     83\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_set_self(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m(\n\u001b[0;32m---> 84\u001b[0m         \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_coo_container(arg1, dtype\u001b[39m=\u001b[39;49mdtype)\n\u001b[1;32m     85\u001b[0m     ))\n\u001b[1;32m     87\u001b[0m \u001b[39m# Read matrix dimensions given, if any\u001b[39;00m\n\u001b[1;32m     88\u001b[0m \u001b[39mif\u001b[39;00m shape \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/_coo.py:195\u001b[0m, in \u001b[0;36m_coo_base.__init__\u001b[0;34m(self, arg1, shape, dtype, copy)\u001b[0m\n\u001b[1;32m    192\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39minconsistent shapes: \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m != \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m'\u001b[39m \u001b[39m%\u001b[39m\n\u001b[1;32m    193\u001b[0m                          (shape, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_shape))\n\u001b[1;32m    194\u001b[0m index_dtype \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_index_dtype(maxval\u001b[39m=\u001b[39m\u001b[39mmax\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_shape))\n\u001b[0;32m--> 195\u001b[0m row, col \u001b[39m=\u001b[39m M\u001b[39m.\u001b[39;49mnonzero()\n\u001b[1;32m    196\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrow \u001b[39m=\u001b[39m row\u001b[39m.\u001b[39mastype(index_dtype, copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m    197\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcol \u001b[39m=\u001b[39m col\u001b[39m.\u001b[39mastype(index_dtype, copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Iterate!\n",
    "\n",
    "j = 0\n",
    "for i in range(Miter):\n",
    "\n",
    "    # Take step in phi1 direction\n",
    "    dFdq, disp = find_direction3_dFdq(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,eps,zeta,D)\n",
    "    dqdphi1,dqdphi2 = find_direction_dqdphi(phi1k,phi2k,q1,q2,q3,q4,eps)\n",
    "    phi1k = phi1k - alpha * (dFdq*dqdphi1)\n",
    "    # Form q \n",
    "    q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "\n",
    "    # Take step in phi2 direction\n",
    "    dFdq, disp = find_direction3_dFdq(q,solver,Umeas,Umeas_ref,z,beta,idx,TV,eps,zeta,D)\n",
    "    dqdphi1,dqdphi2 = find_direction_dqdphi(phi1k,phi2k,q1,q2,q3,q4,eps)\n",
    "    phi2k = phi2k - alpha * (dFdq*dqdphi2)\n",
    "    print(np.min(phi2k))\n",
    "    # Form q \n",
    "    q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "\n",
    "\n",
    "    qfun.vector().set_local(q[idx])\n",
    "    F = compute_functional3_given_disp(disp,q,solver,Umeas,Umeas_ref,beta,idx,TV,zeta,D)\n",
    "    #F = compute_functional2(q,solver,Umeas,Umeas_ref,z,beta,idx,TV)\n",
    "    \n",
    "    if i == 5:\n",
    "        alpha = alpha/2\n",
    "        print(\"Updating stepsize =\", alpha)\n",
    "    if i == 20:\n",
    "        alpha = alpha/2\n",
    "        print(\"Updating stepsize =\", alpha)\n",
    "    if i == 50:\n",
    "        alpha = alpha/2 \n",
    "        print(\"Updating stepsize =\", alpha)\n",
    "    if i == 100:\n",
    "        alpha = alpha/2\n",
    "        print(\"Updating stepsize =\", alpha)\n",
    "    # Backtracking line search \n",
    "    #tt = c * np.linalg.norm(dF)**2\n",
    "    #j = 0\n",
    "    #while(F0-F < alpha*tt and F0-F > 1e-5):\n",
    "    #    j = j+1\n",
    "    #    alpha = tau*alpha\n",
    "    #    phik_new = phik_new + alpha * dF\n",
    "    #    q = q1*(phik_new>0) + q2*(phik_new<=0)  \n",
    "    #    qfun.vector().set_local(q[idx])\n",
    "    #    F = compute_functional2(q,solver,Umeas,Umeas_ref,z,beta,idx,TV)\n",
    "\n",
    "    # Take a step of length alpha in that direction\n",
    "    print(\"Iteration =\", i, \"::: Loss =\", F)\n",
    "    #phik = phik + alpha * dF\n",
    "    #q = q1*(phik>0) + q2*(phik<=0)  \n",
    "    #F0 = F\n",
    "    \n",
    "\n",
    "    # if phi1 is changed more than 10% we reinitialize and recompute TV object\n",
    "    if np.linalg.norm(phi1k-phi1)/np.linalg.norm(phi1) > 0.1 or time_since_last1 >= 10:\n",
    "        print(\"Reinitializing phi1\")\n",
    "        phi1k = reinitRK(phi1k,idx,Ninit,dt,eps,alpha_dif).vector().get_local()[idx2]\n",
    "        phi1 = phi1k.copy()\n",
    "        q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "        qfun.vector().set_local(q[idx])\n",
    "        TV.update_op(qfun)\n",
    "        time_since_last1 = 0\n",
    "\n",
    "    if np.linalg.norm(phi2k-phi2)/np.linalg.norm(phi2) > 0.1 or time_since_last2 >= 10:\n",
    "        print(\"Reinitializing phi2\")\n",
    "        phi2k = reinitRK(phi2k,idx,Ninit,dt,eps,alpha_dif).vector().get_local()[idx2]\n",
    "        phi2 = phi2k.copy()\n",
    "        q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "        qfun.vector().set_local(q[idx])\n",
    "        TV.update_op(qfun)\n",
    "        time_since_last2 = 0\n",
    "    \n",
    "    time_since_last1 += 1\n",
    "    time_since_last2 += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0xffff31c7ef20>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "\n",
    "qfun.vector().set_local(q[idx])\n",
    "p = df.plot(qfun)\n",
    "plt.colorbar(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Diverges at reinit * 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0xffff31b628c0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "phi1k1 = reinitRK(phi1k,idx,Ninit,2.0*1e-4,eps,8.0*1e-4).vector().get_local()[idx2]\n",
    "phi2k2 = reinitRK(phi2k,idx,Ninit,2.0*1e-4,eps,8.0*1e-4).vector().get_local()[idx2]\n",
    "#phi = phik2\n",
    "#q = q1*((phi1k>0)*(phi2k>0)) + q2*((phi1k>0)*(phi2k<=0)) + q3*((phi1k<=0)*(phi2k>0)) + q4*((phi1k<=0)*(phi2k<=0))\n",
    "\n",
    "qfun.vector().set_local(phi2k2[idx])\n",
    "\n",
    "p = df.plot(qfun)\n",
    "plt.colorbar(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0xffff318e6a70>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAESCAYAAADXBC7TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlQUlEQVR4nO3df3DU9Z3H8VdCkoUISQiQLJEfolAYLsp5gDF47Z0lx49SFeVO+TE9ihYLBKcI5bzUUdC7MbW23tUW9e6mxR+9QeXGyJRDlBJ+1hAFQ62gQRwg/MgmNZBN+JElYd/3h2XPNUF2Qzbf7ybPx8x7huz3k933frPzzovN97vfBDMzAQAAuEii0w0AAAB8GQEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4DgEFAAC4jqMBZdWqVbrmmmvUs2dP5eXl6d1333WyHQBxgLkBdA+OBZRXX31VS5cu1YoVK/T+++9rzJgxmjx5smpra51qCYDLMTeA7iPBqYsF5uXlafz48frlL38pSQoGgxo8eLAeeOAB/fM//7MTLQFwOeYG0H0kOfGg58+f1549e1RUVBS6LTExUQUFBSorK2u1PhAIKBAIhL4OBoM6efKk+vXrp4SEhE7pGUA4M1NjY6NycnKUmBj7N2OjnRsSswNwm2jmhiMB5bPPPtOFCxeUnZ0ddnt2drY+/vjjVuuLi4v12GOPdVZ7AKJw9OhRDRo0KOaPE+3ckJgdgFtFMjfi4iyeoqIi+f3+UFVVVTndEoA/69Onj9MtXBKzA3CnSOaGI++g9O/fXz169FBNTU3Y7TU1NfJ6va3WezweeTyezmoPQBQ6608l0c4NidkBuFUkc8ORd1BSUlI0duxYbd68OXRbMBjU5s2blZ+f70RLAFyOuQF0L468gyJJS5cu1dy5czVu3DjddNNN+vd//3edOXNG8+bNc6olAC7H3AC6D8cCyj333KM//elPevTRR+Xz+fSXf/mX2rhxY6sD4ADgIuYG0H049jkoV6KhoUHp6elOtwFAkt/vV1pamtNtRITZAbhDJHMjLs7iAQAA3QsBBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuA4BBQAAuE6HB5SVK1cqISEhrEaNGhXa3tTUpMLCQvXr10+9e/fWjBkzVFNT09FtAIgjzA0AXxaTd1D+4i/+QtXV1aHauXNnaNuDDz6o3/72t1q7dq22bdumEydO6K677opFGwDiCHMDQBjrYCtWrLAxY8a0ua2+vt6Sk5Nt7dq1ods++ugjk2RlZWURP4bf7zdJFEW5oPx+/5WOjU6ZG2bMDopyS0UyN2LyDsonn3yinJwcXXvttZozZ46qqqokSXv27FFzc7MKCgpCa0eNGqUhQ4aorKzskvcXCATU0NAQVgC6lo6eGxKzA4hnHR5Q8vLy9MILL2jjxo167rnndOjQIX39619XY2OjfD6fUlJSlJGREfY92dnZ8vl8l7zP4uJipaenh2rw4MEd3TYAB8VibkjMDiCeJXX0HU6dOjX07xtuuEF5eXkaOnSoXnvtNfXq1atd91lUVKSlS5eGvm5oaGDQAF1ILOaGxOwA4lnMTzPOyMjQ1772NR08eFBer1fnz59XfX192Jqamhp5vd5L3ofH41FaWlpYAei6OmJuSMwOIJ7FPKCcPn1an376qQYOHKixY8cqOTlZmzdvDm2vrKxUVVWV8vPzY90KgDjB3ADQ4WfxLFu2zLZu3WqHDh2y3//+91ZQUGD9+/e32tpaMzNbsGCBDRkyxEpLS2337t2Wn59v+fn5UT0GR+JTlHuqI87i6Yy5weygKPdUJHOjwwPKPffcYwMHDrSUlBS7+uqr7Z577rGDBw+Gtp87d84WLVpkffv2tdTUVLvzzjuturo6qsdgyFCUe6ojAkpnzA1mB0W5pyKZGwlmZoozDQ0NSk9Pd7oNAJL8fn/cHNvB7ADcIZK5wbV4AACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAACA6xBQAABxIzExUSdOnFBpaanTrSDGCCgAgLjwhz/8QYFAQAMHDtStt96q5uZm/fSnP1VSUpLTrSEGCCgAANcbOHCgUlNTw8JIUlKSli1bpu985zsOdoZYIaAAAFzta1/7mkpKSjR8+PA2t+fm5iojI6Nzm0LMEVAAAK72/e9/X3l5eZfcvnTpUuXm5nZiR+gMBBQAgGtNmDBBt95662XXLVmyRH379u2EjtBZCCgAANfKzc3VjTfeeNl1M2bMUJ8+fTqhI3QWAgoAAHAdAgoAwJX++q//Wj//+c8jXp+YyK+0roSfJgDAlZKSktSzZ8+I1x86dCiq9XA3Pt0GHW7kyJHq3bt31N93+PBh1dXVxaAjAPEmJSVFI0eOdLoNOMmitG3bNvv2t79tAwcONElWUlIStj0YDNojjzxiXq/XevbsaRMnTrQDBw6Eramrq7PZs2dbnz59LD093e69915rbGyMuAe/32+SKJdURkaG/cM//EOoKisro31ZmZnZs88+G7qPxMREx58XFVn5/f7L/mzdMDfMmB3xVNdcc01UP9uLevbs6Xjv1OUrkrkRdUDZsGGDPfzww/b666+b1HrQ/PjHP7b09HR744037A9/+IPdfvvtNmzYMDt37lxozZQpU2zMmDG2a9cu27Fjhw0fPtxmzZoVcQ8MGXdUQkKCPfzww7Zq1apoX0aXtXLlSnvggQccf47U5SuSQeOGuWHG7IinIqB07YpJQAn7ZoUPmmAwaF6v15566qnQbfX19ebxeGzNmjVmZrZ//36TZO+9915ozZtvvmkJCQl2/PjxiB6XIeOO+s///M8reflc1pkzZ+yll16y++67z/HnSl26Ihk0XyQ5MzfMmB3xVO0NKC+88ILjvVOXr0jmRoceJHvo0CH5fD4VFBSEbktPT1deXp7KysokSWVlZcrIyNC4ceNCawoKCpSYmKjy8vI27zcQCKihoSGs4Kw1a9bo3nvvjeljpKam6jvf+Y6eeOIJzZkzJ6aPBefEam5IzI545fF49Prrr7fre++5554O7gZO6dCA4vP5JEnZ2dlht2dnZ4e2+Xw+ZWVlhW1PSkpSZmZmaM2XFRcXKz09PVSDBw/uyLYRhZUrV+r48eP6+7//e/Xo0aNTHjMrK0vPPvusjh8/ruPHj3PNjS4mVnNDYnbEq8TExIg+nA1dW1ycZlxUVCS/3x+qo0ePOt1St5OYmKjFixfrkUceUU5OTqdf3jwtLU05OTnKyclRbW2tampqOJ0Ql8XsAOJXhwYUr9crSaqpqQm7vaamJrTN6/WqtrY2bHtLS4tOnjwZWvNlHo9HaWlpYYXOk5SUpNmzZ+sXv/iFKz4IKTk5WVlZWdq7d2+r/3Uj/sRqbkjMDiCedehvm2HDhsnr9Wrz5s2h2xoaGlReXq78/HxJUn5+vurr67Vnz57QmtLSUgWDwa+8WiWckZiYqJkzZ+rll192upVWRo4cqddff13XXXed063gCjA30JF69OihCRMmON0GOkK0R0g3NjZaRUWFVVRUmCR7+umnraKiwo4cOWJmn58umJGRYevWrbMPPvjA7rjjjjZPF7zxxhutvLzcdu7caSNGjOA0Y5dWYWFhtC+RTvfWW2/ZqFGjHN9X3bUiORrfDXPDjNkRL7Vw4cLohsCXHDlyxPHnQH11xeQ04y1btrT5YHPnzjWz///ApezsbPN4PDZx4sRWH9xVV1dns2bNst69e1taWprNmzePD2pzYa1cudIuXLgQ7UvEEZyK7FxFMmjcMDfMmB3xUoFAIKqf65cRUNxfkcyNBDMzxZmGhgalp6c73UaX9tOf/lSLFy+Wx+NxupWIfPDBB5ozZ44+/PBDp1vpdvx+f9wc28HsiA+BQEApKSnt/v6qqioNHTq0AztCR4tkbjh/xCNc58knn9SiRYviJpxI0g033KDMzEyn2wAAdBACCsIkJCRo0KBB6tWrl9OtRM0NZxgBADoGEx1hHn74Yc2ePdvpNtply5YtvK0LAF0EAQVhEhISnG7hiowePTrunwMAgICCLxg0aJBGjx7tdBtXZMOGDXF17AwAoG0EFIRMmDBBM2fOdLqNK/bggw863QKAdlq8eHGnXecL7kZAQZfzr//6r/rZz37mdBsA2uGhhx4ioEASAQV/NnLkSD3++ONOt9EhLl7YcMeOHSoqKnK6HQBAOxBQIEnq3bu3Ro4c6XQbHSYlJUUej0fPP/+8060AiFBJSYkGDhx4xfdz9dVXa+3atR3QEZyU5HQDcIeueGBpIBDQqVOnnG4D6HZ69uzZ5tl0r732mv7u7/7ukt+XkpLSIWfh9ejRQzNmzFBTU5NWrFihZ555Jmx7MBhUIBC44sdBbPFR91BWVlarS913BTt37tTXv/51p9vo8vioe6SmpiorKyv0dXl5edjXblNZWakpU6aE3Xb06FFduHDBoY66n0jmBu+gAADaJTk5WRMmTNCtt96qFStWON1OxEaOHKlDhw6F3TZz5kz5fD5Jn//y3Lt3rwOd4YsIKACAqM2dO1eZmZl6+umnnW6lQ7zyyiuhfx88eFBPPvmkJOl3v/udDh8+7FBX3RsBBV3WNddco7vvvluvvfaa060AXco//dM/6V/+5V+u6IrDbjZ8+HD913/9lyRp3bp1+uSTT7RixQqdPXvW4c66FwIKuqxBgwZp6tSpBBSgA61YsUI//OEPu2w4+bI77rhDkpSbm6tTp07F7bXK4hEBBQAQsZtvvlm9e/d2uo1ON2XKFAWDQaWmpmr69OlOt9Mt8Dko6NJmz56tJUuWON0GgC4gMTFRt912m9asWcNFSTsBAQVdWkpKinr27Ol0G0CX0djYqGAw6HQbjklMTNTMmTP11FNPOd1Kl0dAQZd26tSpLvkZL4BT7r77bv3v//5vtw4pkngHpRMQUNClrVu3TqtXr3a6DaBLuf322/Xqq6/qzTffdLoVdGEEFABA1GbPnq27775bL774otOtdKq6ujr95Cc/UWlpqdOtdHmcxQMAaJfTp09r2bJl2rZtmyTp/vvv18033+xwV7Fz7tw5zZ8/XyUlJU630i0QUKBTp05p/vz5oQ8mAoBI1dXVhf6M+s4772jAgAGSpC1btigpqev8irntttv02WefadeuXU630m10nVcP2q25uVkVFRVOt9Hh3nvvPS1btszpNoBuo7KyUpWVlZKka6+9NnQg6Zw5c/TEE0842Vq7PPnkk3r22WclSceOHev2BwZ3Nq5mDEmfH5E+c+ZMvfTSS13ifz3Hjh3Tddddp/PnzzvdSpfH1YxxOT169FBycnLY13/6059anQnj8Xg67eyYYDDYaj4EAgF5vd7Q183NzVzhOEa4mjEiZmZas2aNhg8frscff9zpdq7YsWPHCCeAS1y4cKHVL/rU1NRW637/+99rwoQJHfJ4x48f/8o1b7/9tubPn3/Fj4XYIaAgzJEjR1RbW6usrCynW2m3QCCg/Px8p9sAEKW9e/dq3LhxV3ydn+PHj2vo0KEd1BWcwmnGCPPSSy/p7bffdroNAN1QYWGhamtrnW4DLkFAQZfz6KOPOt0CAOAKEVDQyr/927/pwIEDTrfRbs8884zTLQBwSHNzM8eWdBEEFLTy/vvv69SpU0630S6TJ09WIBBwug0ADrlw4QJ/pu4iCChoUzye729m+vjjjxWHZ84DAL6EgII23XLLLaqurna6jah885vfVFVVldNtAAA6QNQBZfv27brtttuUk5OjhIQEvfHGG2Hbv/vd7yohISGspkyZErbm5MmTmjNnjtLS0pSRkaH77rtPp0+fvqIngo5lZvroo4+cbiNix44dU2Njo9Nt4BKYGwCiFXVAOXPmjMaMGaNVq1Zdcs2UKVNUXV0dqjVr1oRtnzNnjvbt26dNmzZp/fr12r59u+6///7ou0dMTZw4UevWrXO6jYisXLlSe/bscboNXAJzA51lw4YNTreAjmJXQJKVlJSE3TZ37ly74447Lvk9+/fvN0n23nvvhW578803LSEhwY4fPx7R4/r9fpNEdUKlpqa256XRqd59910bN26c4/uqu5bf74/q5yU5MzfMmB3xUEePHo3q9fRlPXv2dPw5UJevSOZGTI5B2bp1q7KysjRy5EgtXLhQdXV1oW1lZWXKyMjQuHHjQrcVFBQoMTFR5eXlbd5fIBBQQ0NDWKFznD9/Xt/73vf0s5/9zOlWWjl27Ji+973vadGiRdq9e7fT7eAKdfTckJgd8Wj58uVc/waSYvBR91OmTNFdd92lYcOG6dNPP9WPfvQjTZ06VWVlZerRo4d8Pl+rj1FPSkpSZmamfD5fm/dZXFysxx57rKNbRQRaWlr0q1/9ShkZGUpISNDSpUudbkmS1NjYqOnTp/NnnS4iFnNDYnbEo1deeUUvvviievTo4XQrcFiHB5SZM2eG/n399dfrhhtu0HXXXaetW7dq4sSJ7brPoqKisF+MDQ0NGjx48BX3isjV19drxYoVysjI0L333utID/Pnz9emTZskfX4a9NGjRx3pAx0vFnNDYnZ0N/n5+WpqanK6DXSQmF8s8Nprr1X//v118OBBTZw4UV6vt9W1FlpaWnTy5Mmwy1x/kcfjkcfjiXWruIzTp0/r+9//vgYMGKBvf/vbnXJZ9EAgoJdfflkPPPCAzp8/H5efz4LodcTckJgd3c2JEyecbgEdKOafg3Ls2DHV1dVp4MCBkj5PuPX19WFvzZeWlioYDCovLy/W7eAKtbS06Pbbb9fWrVtj+oFox44d065du9SzZ0/Nnz9fTU1NhJNuhLkBIOqzeBobG62iosIqKipMkj399NNWUVFhR44cscbGRvvhD39oZWVldujQIfvd735nf/VXf2UjRoywpqam0H1MmTLFbrzxRisvL7edO3faiBEjbNasWRH3wJH47qi33nor2pfPVzpw4IDt2LHDduzYYSkpKY4/PyqyiuRofDfMDTNmR7xUIBCIen6YmQ0ZMsTx3qnIKpK5EXVA2bJlS5sPNnfuXDt79qxNmjTJBgwYYMnJyTZ06FCbP3+++Xy+sPuoq6uzWbNmWe/evS0tLc3mzZtnjY2NEffAkHFHJSYm2q9//Wtbt25dtC+jNs2bN8/x50RFX5EMGjfMDTNmR7zUr3/966h+rhcRUOKnYhJQ3IAh467Kzs62l19++Yp/rgSU+KxoPwfFScyO+KhevXpF/bN9/vnnLS0tzfHeqcjKsc9BQfdSU1Ojhx56SHfddZe2bt3arvt44403VFpa2rGNAeg2fvOb3/A5N11MzM/iQfdw4sQJlZSUaM+ePcrMzNRbb73V6nMrvsqBAwd05MiRGHYIAIgnBBR0qKqqKlVVVWnUqFG66qqrLnl14REjRsjv94e+Pnv2bGe1CMDlzp07p7Fjx0b8QYw/+MEPtGvXrhh3hc5GQEFMnDp1SqdOnVJSUtsvMU4ZBvBVTp48GfHaxsZGtbS0xLAbOIFjUBBTwWCwzQKAr9Lc3BzRn33r6upUX18f+4bQ6QgoAADXOX78uL773e9edt2vfvUrlZSUxL4hdDoCCgAgLn366afasWOH020gRggoAABXOnDggH7zm9+0ue3YsWNatGiR1q9f38ldobMQUAAArnTixAk99NBDWrt2battJ0+e1Ntvv+1AV+gsnMUDAHCtEydOaMGCBerXr5+++c1vysw0YsQINTU1Od0aYoyAAgBwtZMnT+pb3/qWevToIYnPTeouCCgAANcLBAJOt4BOxjEoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdQgoAADAdaIKKMXFxRo/frz69OmjrKwsTZ8+XZWVlWFrmpqaVFhYqH79+ql3796aMWOGampqwtZUVVVp2rRpSk1NVVZWlpYvX66WlpYrfzYAXInZASBqFoXJkyfb6tWr7cMPP7S9e/fat771LRsyZIidPn06tGbBggU2ePBg27x5s+3evdtuvvlmmzBhQmh7S0uL5ebmWkFBgVVUVNiGDRusf//+VlRUFHEffr/fJFEU5YLy+/3MDoqioqpI5kZUAeXLamtrTZJt27bNzMzq6+stOTnZ1q5dG1rz0UcfmSQrKyszM7MNGzZYYmKi+Xy+0JrnnnvO0tLSLBAIRPS4DBmKck9FMmiYHRRFfbEimRtXdAyK3++XJGVmZkqS9uzZo+bmZhUUFITWjBo1SkOGDFFZWZkkqaysTNdff72ys7NDayZPnqyGhgbt27evzccJBAJqaGgIKwDxi9kB4HLaHVCCwaCWLFmiW265Rbm5uZIkn8+nlJQUZWRkhK3Nzs6Wz+cLrfnigLm4/eK2thQXFys9PT1UgwcPbm/bABzG7AAQiXYHlMLCQn344Yd65ZVXOrKfNhUVFcnv94fq6NGjMX9MALHB7AAQiaT2fNPixYu1fv16bd++XYMGDQrd7vV6df78edXX14f9T6impkZerze05t133w27v4tH6l9c82Uej0cej6c9rQJwEWYHgIhFc2BbMBi0wsJCy8nJsQMHDrTafvFAt//5n/8J3fbxxx+b1PpAt5qamtCa//iP/7C0tDRramqKqA8OdKMo91QkB7sxOyiK+mJ1+Fk8CxcutPT0dNu6datVV1eH6uzZs6E1CxYssCFDhlhpaant3r3b8vPzLT8/P7T94qmCkyZNsr1799rGjRttwIABnCpIUXFakQwaZgdFUV+sDg8ol3qg1atXh9acO3fOFi1aZH379rXU1FS78847rbq6Oux+Dh8+bFOnTrVevXpZ//79bdmyZdbc3BxxHwwZinJPRTRoLvG9zA6K6p4VydxI+PPwiCsNDQ1KT093ug0A+vyU4bS0NKfbiAizA3CHSOYG1+IBAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuQ0ABAACuE1VAKS4u1vjx49WnTx9lZWVp+vTpqqysDFvzt3/7t0pISAirBQsWhK2pqqrStGnTlJqaqqysLC1fvlwtLS1X/mwAuBKzA0C0kqJZvG3bNhUWFmr8+PFqaWnRj370I02aNEn79+/XVVddFVo3f/58Pf7446GvU1NTQ/++cOGCpk2bJq/Xq3feeUfV1dX6x3/8RyUnJ+uJJ57ogKcEwG2YHQCiZlegtrbWJNm2bdtCt/3N3/yN/eAHP7jk92zYsMESExPN5/OFbnvuuecsLS3NAoFARI/r9/tNEkVRLii/38/soCgqqopkblzRMSh+v1+SlJmZGXb7f//3f6t///7Kzc1VUVGRzp49G9pWVlam66+/XtnZ2aHbJk+erIaGBu3bt6/NxwkEAmpoaAgrAPGL2QHgcqL6E88XBYNBLVmyRLfccotyc3NDt8+ePVtDhw5VTk6OPvjgAz300EOqrKzU66+/Lkny+XxhA0ZS6Gufz9fmYxUXF+uxxx5rb6sAXITZASAiEb0v2oYFCxbY0KFD7ejRo1+5bvPmzSbJDh48aGZm8+fPt0mTJoWtOXPmjEmyDRs2tHkfTU1N5vf7Q3X06FHH356iKOrzivZPPMwOiqJi9ieexYsXa/369dqyZYsGDRr0lWvz8vIkSQcPHpQkeb1e1dTUhK25+LXX623zPjwej9LS0sIKQPxhdgCIVFQBxcy0ePFilZSUqLS0VMOGDbvs9+zdu1eSNHDgQElSfn6+/vjHP6q2tja0ZtOmTUpLS9Po0aOjaQdAnGB2AIhaRO/J/tnChQstPT3dtm7datXV1aE6e/asmZkdPHjQHn/8cdu9e7cdOnTI1q1bZ9dee6194xvfCN1HS0uL5ebm2qRJk2zv3r22ceNGGzBggBUVFUXcR319veNvT1EU9XnV19czOyiKiqoimRtRBZRLPdDq1avNzKyqqsq+8Y1vWGZmpnk8Hhs+fLgtX7681d+aDh8+bFOnTrVevXpZ//79bdmyZdbc3BxxH/wdmaLcU5c7lsRNs+PTTz91fH9RFBXZ3Ej48/CIK8FgUJWVlRo9erSOHj3K35VjoKGhQYMHD2b/xkhX2L9mpsbGRuXk5CgxMT6umlFfX6++ffuqqqpK6enpTrfT5XSF17WbdYX9G83caPdpxk5KTEzU1VdfLUkc+BZj7N/Yivf9G2+/5C8OxPT09Lje724X769rt4v3/Rvp3IiP//YAAIBuhYACAABcJ24Disfj0YoVK+TxeJxupUti/8YW+9cZ7PfYYv/GVnfbv3F5kCwAAOja4vYdFAAA0HURUAAAgOsQUAAAgOsQUAAAgOvEZUBZtWqVrrnmGvXs2VN5eXl69913nW4pLmzfvl233XabcnJylJCQoDfeeCNsu5np0Ucf1cCBA9WrVy8VFBTok08+CVtz8uRJzZkzR2lpacrIyNB9992n06dPd+KzcK/i4mKNHz9effr0UVZWlqZPn67KysqwNU1NTSosLFS/fv3Uu3dvzZgxo9UVequqqjRt2jSlpqYqKytLy5cvV0tLS2c+lS6L2dE+zI7YYW5cWtwFlFdffVVLly7VihUr9P7772vMmDGaPHly2BVO0bYzZ85ozJgxWrVqVZvbf/KTn+iZZ57R888/r/Lycl111VWaPHmympqaQmvmzJmjffv2adOmTVq/fr22b9+u+++/v7Oegqtt27ZNhYWF2rVrlzZt2qTm5mZNmjRJZ86cCa158MEH9dvf/lZr167Vtm3bdOLECd11112h7RcuXNC0adN0/vx5vfPOO3rxxRf1wgsv6NFHH3XiKXUpzI72Y3bEDnPjK0R8lS2XuOmmm6ywsDD09YULFywnJ8eKi4sd7Cr+SLKSkpLQ18Fg0Lxerz311FOh2+rr683j8diaNWvMzGz//v0myd57773QmjfffNMSEhLs+PHjndZ7vKitrTVJtm3bNjP7fH8mJyfb2rVrQ2s++ugjk2RlZWVmZrZhwwZLTEw0n88XWvPcc89ZWlqaBQKBzn0CXQyzo2MwO2KLufH/4uodlPPnz2vPnj0qKCgI3ZaYmKiCggKVlZU52Fn8O3TokHw+X9i+TU9PV15eXmjflpWVKSMjQ+PGjQutKSgoUGJiosrLyzu9Z7fz+/2SpMzMTEnSnj171NzcHLaPR40apSFDhoTt4+uvv17Z2dmhNZMnT1ZDQ4P27dvXid13LcyO2GF2dCzmxv+Lq4Dy2Wef6cKFC2E/BEnKzs6Wz+dzqKuu4eL++6p96/P5lJWVFbY9KSlJmZmZ7P8vCQaDWrJkiW655Rbl5uZK+nz/paSkKCMjI2ztl/dxWz+Di9vQPsyO2GF2dBzmRri4vJox4HaFhYX68MMPtXPnTqdbARAnmBvh4uodlP79+6tHjx6tjl6uqamR1+t1qKuu4eL++6p96/V6Wx1Q2NLSopMnT7L/v2Dx4sVav369tmzZokGDBoVu93q9On/+vOrr68PWf3kft/UzuLgN7cPsiB1mR8dgbrQWVwElJSVFY8eO1ebNm0O3BYNBbd68Wfn5+Q52Fv+GDRsmr9cbtm8bGhpUXl4e2rf5+fmqr6/Xnj17QmtKS0sVDAaVl5fX6T27jZlp8eLFKikpUWlpqYYNGxa2fezYsUpOTg7bx5WVlaqqqgrbx3/84x/DhvmmTZuUlpam0aNHd84T6YKYHbHD7LgyzI2v4PRRutF65ZVXzOPx2AsvvGD79++3+++/3zIyMsKOXkbbGhsbraKiwioqKkySPf3001ZRUWFHjhwxM7Mf//jHlpGRYevWrbMPPvjA7rjjDhs2bJidO3cudB9TpkyxG2+80crLy23nzp02YsQImzVrllNPyVUWLlxo6enptnXrVquurg7V2bNnQ2sWLFhgQ4YMsdLSUtu9e7fl5+dbfn5+aHtLS4vl5ubapEmTbO/evbZx40YbMGCAFRUVOfGUuhRmR/sxO2KHuXFpcRdQzMx+8Ytf2JAhQywlJcVuuukm27Vrl9MtxYUtW7aYpFY1d+5cM/v8dMFHHnnEsrOzzePx2MSJE62ysjLsPurq6mzWrFnWu3dvS0tLs3nz5lljY6MDz8Z92tq3kmz16tWhNefOnbNFixZZ3759LTU11e68806rrq4Ou5/Dhw/b1KlTrVevXta/f39btmyZNTc3d/Kz6ZqYHe3D7Igd5salJZiZdd77NQAAAJcXV8egAACA7oGAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXIeAAgAAXOf/AKOfpELFFh94AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "phi1_grid = KTCAux.interpolateRecoToPixGrid(phi1k, Mesh)\n",
    "phi2_grid = KTCAux.interpolateRecoToPixGrid(phi2k, Mesh)\n",
    "q = 0*((phi1_grid>0)*(phi2_grid>0)) + 2*((phi1_grid>0)*(phi2_grid<0)) + 1*((phi1_grid<0)*(phi2_grid>0)) + 1*((phi1_grid<0)*(phi2_grid<0))\n",
    "#q[q==0.] = \n",
    "#q[q<=q1] = 0\n",
    "\n",
    "#mesh_img.coordinates()\n",
    "#q[q<q1] = 0\n",
    "fig, ax = plt.subplots(1,2)\n",
    "ax[0].imshow(q, cmap=\"gray\")\n",
    "ax[1].imshow(truth_dict[\"truth\"], cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Agrad\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/_index.py:100: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
      "  self._set_intXint(row, col, x.flat[0])\n",
      "/opt/conda/envs/env/lib/python3.10/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py:229: SparseEfficiencyWarning: spsolve requires A be CSC or CSR matrix format\n",
      "  warn('spsolve requires A be CSC or CSR matrix format',\n"
     ]
    }
   ],
   "source": [
    "Nel = 32  # number of electrodes\n",
    "z = (1e-6) * np.ones((Nel, 1))  # contact impedances\n",
    "mat_dict = sp.io.loadmat('app/TrainingData'+ '/ref.mat') #load the reference data\n",
    "Injref = mat_dict[\"Injref\"] #current injections\n",
    "Uelref = mat_dict[\"Uelref\"] #measured voltages from water chamber\n",
    "Mpat = mat_dict[\"Mpat\"] #voltage measurement pattern\n",
    "vincl = np.ones(((Nel - 1),76), dtype=bool) #which measurements to include in the inversion\n",
    "rmind = np.arange(0,2 * (categoryNbr - 1),1) #electrodes whose data is removed\n",
    "\n",
    "\n",
    "#remove measurements according to the difficulty level\n",
    "for ii in range(0,75):\n",
    "    for jj in rmind:\n",
    "        if Injref[jj,ii]:\n",
    "            vincl[:,ii] = 0\n",
    "        vincl[jj,:] = 0\n",
    "\n",
    "# load premade finite element mesh (made using Gmsh, exported to Matlab and saved into a .mat file)\n",
    "mat_dict_mesh = sp.io.loadmat('app/Mesh_sparse.mat')\n",
    "g = mat_dict_mesh['g'] #node coordinates\n",
    "H = mat_dict_mesh['H'] #indices of nodes making up the triangular elements\n",
    "elfaces = mat_dict_mesh['elfaces'][0].tolist() #indices of nodes making up the boundary electrodes\n",
    "\n",
    "\n",
    "\n",
    "#Element structure\n",
    "ElementT = mat_dict_mesh['Element']['Topology'].tolist()\n",
    "for k in range(len(ElementT)):\n",
    "    ElementT[k] = ElementT[k][0].flatten()\n",
    "ElementE = mat_dict_mesh['ElementE'].tolist() #marks elements which are next to boundary electrodes\n",
    "for k in range(len(ElementE)):\n",
    "    if len(ElementE[k][0]) > 0:\n",
    "        ElementE[k] = [ElementE[k][0][0][0], ElementE[k][0][0][1:len(ElementE[k][0][0])]]\n",
    "    else:\n",
    "        ElementE[k] = []\n",
    "\n",
    "#Node structure\n",
    "NodeC = mat_dict_mesh['Node']['Coordinate']\n",
    "NodeE = mat_dict_mesh['Node']['ElementConnection'] #marks which elements a node belongs to\n",
    "nodes = [KTCMeshing.NODE(coord[0].flatten(), []) for coord in NodeC]\n",
    "for k in range(NodeC.shape[0]):\n",
    "    nodes[k].ElementConnection = NodeE[k][0].flatten()\n",
    "elements = [KTCMeshing.ELEMENT(ind, []) for ind in ElementT]\n",
    "for k in range(len(ElementT)):\n",
    "    elements[k].Electrode = ElementE[k]\n",
    "\n",
    "#2nd order mesh data\n",
    "H2 = mat_dict_mesh['H2']\n",
    "g2 = mat_dict_mesh['g2']\n",
    "elfaces2 = mat_dict_mesh['elfaces2'][0].tolist()\n",
    "ElementT2 = mat_dict_mesh['Element2']['Topology']\n",
    "ElementT2 = ElementT2.tolist()\n",
    "for k in range(len(ElementT2)):\n",
    "    ElementT2[k] = ElementT2[k][0].flatten()\n",
    "ElementE2 = mat_dict_mesh['Element2E']\n",
    "ElementE2 = ElementE2.tolist()\n",
    "for k in range(len(ElementE2)):\n",
    "    if len(ElementE2[k][0]) > 0:\n",
    "        ElementE2[k] = [ElementE2[k][0][0][0], ElementE2[k][0][0][1:len(ElementE2[k][0][0])]]\n",
    "    else:\n",
    "        ElementE2[k] = []\n",
    "\n",
    "NodeC2 = mat_dict_mesh['Node2']['Coordinate']  # ok\n",
    "NodeE2 = mat_dict_mesh['Node2']['ElementConnection']  # ok\n",
    "nodes2 = [KTCMeshing.NODE(coord[0].flatten(), []) for coord in NodeC2]\n",
    "for k in range(NodeC2.shape[0]):\n",
    "    nodes2[k].ElementConnection = NodeE2[k][0].flatten()\n",
    "elements2 = [KTCMeshing.ELEMENT(ind, []) for ind in ElementT2]\n",
    "for k in range(len(ElementT2)):\n",
    "    elements2[k].Electrode = ElementE2[k]\n",
    "\n",
    "Mesh = KTCMeshing.Mesh(H,g,elfaces,nodes,elements)\n",
    "Mesh2 = KTCMeshing.Mesh(H2,g2,elfaces2,nodes2,elements2)\n",
    "\n",
    "# print(f'Nodes in inversion 1st order mesh: {len(Mesh.g)}')\n",
    "\n",
    "sigma0 = np.ones((len(Mesh.g), 1)) #linearization point\n",
    "corrlength = 1 * 0.115 #used in the prior\n",
    "var_sigma = 0.05 ** 2 #prior variance\n",
    "mean_sigma = sigma0\n",
    "smprior = KTCRegularization.SMPrior(Mesh.g, corrlength, var_sigma, mean_sigma)\n",
    "\n",
    "# set up the forward solver for inversion\n",
    "solver = KTCFwd.EITFEM(Mesh2, Mesh, Injref, Mpat, vincl)\n",
    "# Initialize solver and jacobian and reference data\n",
    "q0 = 0.8 + 0*g[:,0]\n",
    "Uel_sim = solver.SolveForward2(q0, z)\n",
    "JJ = solver.Jacobian(0.8+0*q0,z)\n",
    "\n",
    "vincl = vincl.T.flatten()\n",
    "\n",
    "# set up the noise model for inversion\n",
    "noise_std1 = 0.05;  # standard deviation for first noise component (relative to each voltage measurement)\n",
    "noise_std2 = 0.01;  # standard deviation for second noise component (relative to the largest voltage measurement)\n",
    "solver.SetInvGamma(noise_std1, noise_std2, Uelref)\n",
    "\n",
    "# Get a list of .mat files in the input folder\n",
    "mat_files = sorted(glob.glob(inputFolder + '/data*.mat'))\n",
    "\n",
    "mat_dict2 = sp.io.loadmat(mat_files[1])\n",
    "Inj = mat_dict2[\"Inj\"]\n",
    "Uel = mat_dict2[\"Uel\"]\n",
    "Mpat = mat_dict2[\"Mpat\"]\n",
    "deltaU = Uel - Uelref\n",
    "#############################  Changed code\n",
    "reg1 = 0.75\n",
    "reg2 = 1e15\n",
    "smprior.L = reg1*smprior.L\n",
    "radius = np.max(np.linalg.norm(Mesh.g, axis = 1))\n",
    "m = Mesh.g.shape[0]\n",
    "num_el =  32 - (2*categoryNbr - 1)\n",
    "electrodes = np.zeros((num_el, 2))\n",
    "angle = 2*np.pi/Nel\n",
    "for i in range(num_el):\n",
    "    electrodes[i] = radius*np.array([np.sin(i*angle), np.cos(i*angle)])\n",
    "\n",
    "\n",
    "D = np.zeros(m)\n",
    "for i in range(m):\n",
    "    v = Mesh.g[i]\n",
    "    dist = np.zeros(num_el)\n",
    "    for k, e in enumerate(electrodes):\n",
    "        dist[k] = np.linalg.norm(v - e)\n",
    "    D[i] = (np.linalg.norm(dist, ord = 3)**3)*np.linalg.norm(v)**4\n",
    "\n",
    "D = np.diag(D)\n",
    "\n",
    "mask = np.array(vincl, bool) # Mask the removed electrodes\n",
    "\n",
    "deltaU = Uel - Uelref\n",
    "J = solver.Jacobian(sigma0, z)\n",
    "deltareco = np.linalg.solve(J.T @ solver.InvGamma_n[np.ix_(mask,mask)] @ J + smprior.L.T @ smprior.L + reg2*D.T@D,\n",
    "                            J.T @ solver.InvGamma_n[np.ix_(mask,mask)] @ deltaU[vincl])\n",
    "\n",
    "# interpolate the reconstruction into a pixel image\n",
    "deltareco_pixgrid = KTCAux.interpolateRecoToPixGrid(deltareco, Mesh)\n",
    "\n",
    "# Do Chan-Vese segmentation\n",
    "mu = np.mean(deltareco_pixgrid)\n",
    "# Feel free to play around with the parameters to see how they impact the result\n",
    "cv = chan_vese(abs(deltareco_pixgrid), mu=0.1, lambda1=1, lambda2=1, tol=1e-6,\n",
    "            max_num_iter=1000, dt=2.5, init_level_set=\"checkerboard\",\n",
    "            extended_output=True)\n",
    "\n",
    "labeled_array, num_features = sp.ndimage.label(cv[0])\n",
    "# Initialize a list to store masks for each region\n",
    "region_masks = []\n",
    "\n",
    "# Loop through each labeled region\n",
    "deltareco_pixgrid_segmented = np.zeros((256,256))\n",
    "\n",
    "for label in range(1, num_features + 1):\n",
    "    # Create a mask for the current region\n",
    "    region_mask = labeled_array == label\n",
    "    region_masks.append(region_mask)\n",
    "    if np.mean(deltareco_pixgrid[region_mask]) < mu:\n",
    "        deltareco_pixgrid_segmented[region_mask] = 1\n",
    "    else:\n",
    "        deltareco_pixgrid_segmented[region_mask] = 2\n",
    "\n",
    "###################################  End of changed code\n",
    "reconstruction = deltareco_pixgrid_segmented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0xffff47462860>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(deltareco_pixgrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2356, 1)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Uel.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "categoryNbr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}