diff --git a/analysis/data/graphene_example.nc b/analysis/data/graphene_example.nc
new file mode 100644
index 0000000000000000000000000000000000000000..c10cc0c62895ff5ae70f81e8d02a7ef130d34edc
Binary files /dev/null and b/analysis/data/graphene_example.nc differ
diff --git a/analysis/scipy_optimizer.ipynb b/analysis/scipy_optimizer.ipynb
index 74b47186af5c55129ac45e7b5cda0a7c2a180f47..c6f3f65bd46486d5080cc00352cfbcc0da9ef4e5 100644
--- a/analysis/scipy_optimizer.ipynb
+++ b/analysis/scipy_optimizer.ipynb
@@ -7,7 +7,20 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'utils'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mcodes\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m utils, hf\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01moptimize\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m anderson\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtqdm\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m tqdm\n",
+      "File \u001b[0;32m~/Sync/kwant-scf/analysis/codes/hf.py:3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msignal\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m convolve2d\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mutils\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mfunctools\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m partial\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mscipy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01moptimize\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m anderson, minimize\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'utils'"
+     ]
+    }
+   ],
    "source": [
     "import kwant\n",
     "import numpy as np\n",
@@ -43,7 +56,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "9cc3b32d-404f-4bc5-a338-83571c9e4c4b",
    "metadata": {
     "tags": []
@@ -63,7 +76,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 203,
+   "execution_count": null,
+   "id": "a341e0e5-330e-48d1-a20f-a0040688a9d7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nk = 10\n",
+    "# Generate coarse-grid k-points\n",
+    "ks, dk = np.linspace(0, 2 * np.pi, nk, endpoint=False, retstep=True)\n",
+    "# Generate Hamiltonian on a k-point grid\n",
+    "hamiltonians_0 = utils.syst2hamiltonian(ks=ks, syst=wrapped_fsyst)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "d1ef154e-70bd-4f28-887f-72362d8533dd",
    "metadata": {
     "tags": []
@@ -76,21 +103,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 204,
+   "execution_count": null,
    "id": "32b9e7c5-db12-44f9-930c-21e5494404b8",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "dummy_syst, deltas = utils.generate_scf_syst(\n",
+    "_, deltas = utils.generate_scf_syst(\n",
     "    max_neighbor=1, syst=wrapped_syst, lattice=graphene\n",
     ")\n",
-    "\n",
-    "deltas = np.asarray(deltas)\n",
+    "deltas = np.asarray(deltas) #deltas are the hopping vecs\n",
     "deltas = np.unique(np.stack([*deltas, *-deltas]), axis=(0))\n",
     "\n",
-    "\n",
     "def compute_gap(\n",
     "    U,\n",
     "    V,\n",
@@ -109,17 +134,19 @@
     "    # Generate coarse-grid k-points\n",
     "    ks, dk = np.linspace(0, 2 * np.pi, nk, endpoint=False, retstep=True)\n",
     "    # Generate Hamiltonian on a k-point grid\n",
-    "    hamiltonians_0 = utils.syst2hamiltonian(kxs=ks, kys=ks, syst=wrapped_fsyst)\n",
+    "    hamiltonians_0 = utils.syst2hamiltonian(ks=ks, syst=wrapped_fsyst)\n",
     "    # Generate guess on the same grid\n",
     "    if guess is None:\n",
-    "        guess = utils.generate_guess(max_neighbor, norbs, lattice, ks, ks, dummy_syst)\n",
+    "        guess = guess = utils.generate_guess(nk, 2, deltas, ndof=4, scale=1)\n",
     "    else:\n",
     "        # guess *= 0.25\n",
-    "        guess += 0.05 * np.max(guess) * utils.generate_guess(max_neighbor, norbs, lattice, ks, ks, dummy_syst)\n",
+    "        guess += np.max(guess) * utils.generate_guess(nk, 2, deltas, ndof=4, scale=0.1)\n",
     "        # guess = guess\n",
+    "    \n",
     "    # Find groundstate Hamiltonian on the same grid\n",
     "    hk = hf.find_groundstate_ham(\n",
     "        H_int=H_int,\n",
+    "        nk=nk,\n",
     "        filling=filling,\n",
     "        hamiltonians_0=hamiltonians_0,\n",
     "        tol=tol,\n",
@@ -137,7 +164,7 @@
     "    ks_dense = np.linspace(0, 2 * np.pi, nk_dense, endpoint=False)\n",
     "    # Compute groundstate Hamiltonian on a dense grid\n",
     "    scf_ham = utils.syst2hamiltonian(\n",
-    "        kxs=ks_dense, kys=ks_dense, syst=scf_syst, params={}\n",
+    "        ks=ks_dense, syst=scf_syst, params={}\n",
     "    )\n",
     "    # Diagonalize groundstate Hamiltonian\n",
     "    vals, vecs = np.linalg.eigh(scf_ham)\n",
@@ -188,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 205,
+   "execution_count": 29,
    "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793",
    "metadata": {
     "tags": []
@@ -198,63 +225,29 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/50 [00:00<?, ?it/s]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=2.50001e-17): result may not be accurate.\n",
+      " 22%|██▏       | 11/50 [02:33<07:34, 11.66s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.86112e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.6988e-17): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.11881e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.47968e-17): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=6.6988e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.40439e-18): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.04075e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "  2%|▏         | 1/50 [00:58<48:01, 58.81s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=8.73276e-17): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.03848e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=8.6841e-17): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.08015e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      " 12%|█▏        | 6/50 [06:47<1:00:32, 82.57s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.91398e-17): result may not be accurate.\n",
+      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.07054e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=3.42637e-17): result may not be accurate.\n",
+      " 32%|███▏      | 16/50 [03:37<06:44, 11.89s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=6.43375e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.66412e-17): result may not be accurate.\n",
+      " 34%|███▍      | 17/50 [03:58<08:05, 14.71s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=7.90352e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      " 22%|██▏       | 11/50 [11:20<37:26, 57.59s/it] /opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=6.0485e-17): result may not be accurate.\n",
+      " 54%|█████▍    | 27/50 [07:18<09:45, 25.48s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=3.27211e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.06243e-16): result may not be accurate.\n",
+      " 58%|█████▊    | 29/50 [09:18<15:24, 44.03s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=5.90338e-17): result may not be accurate.\n",
       "  gamma = solve(self.a, df_f)\n",
-      " 44%|████▍     | 22/50 [22:44<23:29, 50.35s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=2.39166e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.33283e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.93204e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=5.56129e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=3.71127e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 46%|████▌     | 23/50 [23:30<22:04, 49.06s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.10112e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=4.01573e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 48%|████▊     | 24/50 [24:35<23:20, 53.86s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=2.73759e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=2.66533e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=8.2465e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 50%|█████     | 25/50 [26:04<26:49, 64.39s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=8.44437e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.68657e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=5.20015e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 54%|█████▍    | 27/50 [30:07<35:47, 93.36s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=3.61553e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 58%|█████▊    | 29/50 [40:58<1:12:24, 206.88s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=2.72304e-18): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=1.25632e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      " 76%|███████▌  | 38/50 [1:09:16<36:56, 184.69s/it]/opt/conda/lib/python3.11/site-packages/scipy/optimize/_nonlin.py:1074: LinAlgWarning: Ill-conditioned matrix (rcond=8.63078e-17): result may not be accurate.\n",
-      "  gamma = solve(self.a, df_f)\n",
-      "100%|██████████| 50/50 [1:29:09<00:00, 107.00s/it]\n"
+      "100%|██████████| 50/50 [22:03<00:00, 26.47s/it]\n"
      ]
     }
    ],
@@ -264,82 +257,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 206,
-   "id": "fe2837d4-9590-4ea9-8a8e-18ec76c50f0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# from dask_quantumtinkerer import Cluster\n",
-    "# !ssh hpc05 -C \"killall dask-quantumtinkerer-server\"\n",
-    "# cluster = Cluster(extra_path=\"Work/kwant-scf/test\", nodes=20)\n",
-    "# cluster.launch_cluster()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 207,
-   "id": "7ae6858b-928e-499a-bda1-f77bc8199ecc",
+   "execution_count": 30,
+   "id": "39edbf19",
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# client = cluster.get_client()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 208,
-   "id": "2c7feca5-0cb8-474a-88a9-cce0ea303195",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# def wrapped_fun(xy):\n",
-    "#     U, V = xy\n",
-    "#     return compute_phase_diagram(U, V, nk=15, tol=1e-5, mixing=0.1, order=3)\n",
-    "\n",
-    "# Us = np.linspace(0, 3)\n",
-    "# Vs = np.linspace(0, 3)\n",
-    "\n",
-    "# import itertools as it\n",
-    "# values = list([Us, Vs])\n",
-    "# args = np.array(list(it.product(*values)))\n",
-    "# shapes = [len(value) for value in values]\n",
-    "\n",
-    "# result_ungathered = client.map(wrapped_fun, args)\n",
-    "# result = client.gather(result_ungathered)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 210,
-   "id": "d988ce2e-b830-4234-83ed-4e6115ada377",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# plt.plot(Us, gap.T)\n",
-    "# plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 211,
-   "id": "a04563c8-81a1-4fd2-9bf3-817224fefe48",
-   "metadata": {
-    "tags": []
-   },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7feadc629c50>"
+       "<matplotlib.colorbar.Colorbar at 0x7f12eff193d0>"
       ]
      },
-     "execution_count": 211,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -355,25 +289,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 212,
-   "id": "46a0fc12-e273-412b-9a90-306163d225ff",
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 31,
+   "id": "27f9d0d8",
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7feadc4a9410>"
+       "<matplotlib.colorbar.Colorbar at 0x7f12effcd650>"
       ]
      },
-     "execution_count": 212,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -383,14 +315,14 @@
     }
    ],
    "source": [
-    "plt.imshow(gap.T, origin='lower', extent=(Us.min(), Us.max(), Vs.min(), Vs.max()), vmin=0)\n",
+    "plt.imshow((gap).T, origin='lower', extent=(Us.min(), Us.max(), Vs.min(), Vs.max()), vmin=0)\n",
     "plt.colorbar()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 215,
-   "id": "73f2398b-f0b2-4368-8ae2-dcdce9be296e",
+   "execution_count": 32,
+   "id": "e17fc96c-c463-4e1f-8250-c254d761b92a",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -400,12 +332,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "1e25512d-720b-4a20-a457-9b8a2638094a",
+   "execution_count": 33,
+   "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0",
    "metadata": {},
    "outputs": [],
    "source": [
-    "gap."
+    "gap_da.to_netcdf('./data/graphene_example.nc')"
    ]
   }
  ],
diff --git a/codes/utils.py b/codes/utils.py
index 6d629c8d375a9cb1bd259ce615867819b9d853e3..5b07c07cca1e7aac94976ae49420b9c678701334 100644
--- a/codes/utils.py
+++ b/codes/utils.py
@@ -1,6 +1,10 @@
+# %%
 import numpy as np
 import kwant
+from itertools import product
 
+
+# %%
 def get_fermi_energy(vals, filling):
     norbs = vals.shape[-1]
     vals_flat = np.sort(vals.flatten())
@@ -14,12 +18,26 @@ def get_fermi_energy(vals, filling):
         fermi = (vals_flat[ifermi - 1] + vals_flat[ifermi]) / 2
         return fermi
 
-def syst2hamiltonian(kxs, kys, syst, params={}):
-    def h_k(kx, ky):
-        return syst.hamiltonian_submatrix(params={**params, **dict(k_x=kx, k_y=ky)})
-    return np.array(
-        [[h_k(kx, ky) for kx in kxs] for ky in kys]
-    )
+
+def syst2hamiltonian(ks, syst, params={}, coordinate_names='xyz'):
+    momenta = ['k_{}'.format(coordinate_names[i])
+                   for i in range(len(syst._wrapped_symmetry.periods))]
+
+    def h_k(k):
+        _k_dict = {}
+        for i, k_n in enumerate(momenta):
+            _k_dict[k_n] = k[i]
+        return syst.hamiltonian_submatrix(params={**params, **_k_dict})
+
+    k_pts = np.tile(ks, len(momenta)).reshape(len(momenta),len(ks))
+
+    ham = []
+    for k in product(*k_pts):
+        ham.append(h_k(k))
+    ham = np.array(ham)
+    shape = (*np.repeat(k_pts.shape[1], k_pts.shape[0]), ham.shape[-1], ham.shape[-1])
+
+    return ham.reshape(*shape)
 
 def potential2hamiltonian(
     syst, lattice, func_onsite, func_hop, ks, params={}, max_neighbor=1
@@ -29,33 +47,67 @@ def potential2hamiltonian(
     for neighbors in range(max_neighbor):
         V[lattice.neighbors(neighbors + 1)] = func_hop
     wrapped_V = kwant.wraparound.wraparound(V).finalized()
-    return syst2hamiltonian(kxs=ks, kys=ks, syst=wrapped_V, params=params)
-
-def generate_guess(max_neighbor, norbs, lattice, kxs, kys, dummy_syst):
-    n_sub = len(lattice.sublattices)
-    guess = np.zeros((n_sub + max_neighbor, 2, norbs, norbs))
-    for i in range(n_sub):
-        # Real part
-        guess[i, 0] = np.random.rand(norbs, norbs) - 0.5
-        guess[i, 0] += guess[i, 0].T
-        # Imag part
-        guess[i, 1] = np.random.rand(norbs, norbs) - 0.5
-        guess[i, 1] -= guess[i, 1].T
-    for neighbor in range(max_neighbor):
-        # Real part
-        guess[n_sub + neighbor, 0] = np.random.rand(norbs, norbs) - 0.5
-        # Imag part
-        guess[n_sub + neighbor, 1] = np.random.rand(norbs, norbs) - 0.5
-    guess_k = syst2hamiltonian(
-        kxs=kxs, kys=kys, syst=dummy_syst, params=dict(mat=guess)
+    return syst2hamiltonian(ks=ks, syst=wrapped_V, params=params)
+
+
+def assign_kdependence(
+    nk, dim, ndof, hopping_vecs, content
+):  # goal and content are bad names, suggestions welcome
+    klenlist = [nk for i in range(dim)]
+    goal = np.zeros((klenlist + [ndof, ndof]), dtype=complex)
+    reshape_order = [1 for i in range(dim)]  # could use a better name
+    kgrid = (
+        np.asarray(np.meshgrid(*[np.linspace(-np.pi, np.pi, nk) for i in range(dim)]))
+        .reshape(dim, -1)
+        .T
     )
-    return guess_k
+
+    for hop, hop2 in zip(hopping_vecs, content):
+        k_dependence = np.exp(1j * np.dot(kgrid, hop)).reshape(klenlist + [1, 1])
+        goal += hop2.reshape(reshape_order + [ndof, ndof]) * k_dependence
+
+    return goal
+
+
+def generate_guess(nk, dim, hopping_vecs, ndof, scale=0.1):
+    """
+    nk : int
+        number of k points
+    dim : int
+        dimension of the system
+    hopping_vecs : np.array
+                hopping vectors as obtained from extract_hopping_vectors
+    ndof : int
+        number of degrees of freedom
+    scale : float
+            scale of the guess. If scale=1 then the guess is random around 0.5
+            Smaller values of the guess significantly slows down convergence but
+            does improve the result at phase instability points.
+
+    Notes:
+    -----
+    Assumes that the desired max nearest neighbour distance is included in the hopping_vecs information.
+    Creates a square grid by definition, might still want to change that
+    """
+    all_rand_hermitians = []
+    for n in hopping_vecs:
+        amplitude = np.random.rand(ndof, ndof)
+        phase = 2 * np.pi * np.random.rand(ndof, ndof)
+        rand_hermitian = amplitude * np.exp(1j * phase)
+        rand_hermitian += rand_hermitian.T.conj()
+        rand_hermitian /= 2
+        all_rand_hermitians.append(rand_hermitian)
+    all_rand_hermitians = np.asarray(all_rand_hermitians)
+
+    guess = assign_kdependence(nk, dim, ndof, hopping_vecs, all_rand_hermitians)
+    return guess * scale
+
 
 def extract_hopping_vectors(builder):
-    keep=None
-    deltas=[]
+    keep = None
+    deltas = []
     for hop, val in builder.hopping_value_pairs():
-        a, b=hop
+        a, b = hop
         b_dom = builder.symmetry.which(b)
         # Throw away part that is in the remaining translation direction, so we get
         # an element of 'sym' which is being wrapped
@@ -63,8 +115,10 @@ def extract_hopping_vectors(builder):
         deltas.append(b_dom)
     return np.asarray(deltas)
 
+
 def generate_scf_syst(max_neighbor, syst, lattice):
     subs = np.array(lattice.sublattices)
+
     def scf_onsite(site, mat):
         idx = np.where(subs == site.family)[0][0]
         return mat[idx, 0] + 1j * mat[idx, 1]
@@ -72,6 +126,7 @@ def generate_scf_syst(max_neighbor, syst, lattice):
     scf = kwant.Builder(kwant.TranslationalSymmetry(*lattice.prim_vecs))
     scf[syst.sites()] = scf_onsite
     for neighbor in range(max_neighbor):
+
         def scf_hopping(site1, site2, mat):
             return (
                 mat[len(lattice.sublattices) + neighbor, 0]
@@ -83,24 +138,31 @@ def generate_scf_syst(max_neighbor, syst, lattice):
     wrapped_scf = kwant.wraparound.wraparound(scf).finalized()
     return wrapped_scf, deltas
 
+
 def hk2hop(hk, deltas, ks, dk):
-    kxx, kyy = np.meshgrid(ks, ks)
-    kxy = np.array([kxx, kyy])
-    hopps = (
-        np.sum(
-            np.einsum(
-                "ijk,jklm->ijklm",
-                np.exp(1j * np.einsum("ij,jkl->ikl", deltas, kxy)),
-                hk,
-            ),
-            axis=(1, 2),
-        )
-        * (dk) ** 2
-        / (2 * np.pi) ** 2
-    )
+    ndim = len(hk.shape) - 2
+    k_pts = np.tile(ks, ndim).reshape(ndim,len(ks))
+    k_grid = np.array(np.meshgrid(*k_pts))
+    k_grid = k_grid.reshape(k_grid.shape[0], np.prod(k_grid.shape[1:]))
+    # Can probably flatten this object to make einsum simpler
+    hk = hk.reshape(np.prod(hk.shape[:ndim]), *hk.shape[-2:])
+
+    hopps = np.einsum(
+        "ij,jkl->ikl",
+        np.exp(1j * np.einsum("ij,jk->ik", deltas, k_grid)),
+        hk,
+    ) * (dk / (2 * np.pi)) ** ndim
+
     return hopps
 
 
+def hktohamiltonian(hk, nk, ks, dk, dim, hopping_vecs, ndof):
+    """function is basically tiny so maybe don't separapetly create it"""
+    hops = hk2hop(hk, hopping_vecs, ks, dk)
+    hamil = assign_kdependence(nk, dim, ndof, hopping_vecs, hops)
+    return hamil
+
+
 def hk2syst(deltas, hk, ks, dk, max_neighbor, norbs, lattice):
     hopps = hk2hop(hk, deltas, ks, dk)
     bulk_scf = kwant.Builder(kwant.TranslationalSymmetry(*lattice.prim_vecs))
@@ -125,7 +187,8 @@ def hk2syst(deltas, hk, ks, dk, max_neighbor, norbs, lattice):
     wrapped_scf_syst = kwant.wraparound.wraparound(bulk_scf).finalized()
     return wrapped_scf_syst
 
+
 def calc_gap(vals, E_F):
     emax = np.max(vals[vals <= E_F])
     emin = np.min(vals[vals > E_F])
-    return np.abs(emin - emax)
\ No newline at end of file
+    return np.abs(emin - emax)