use param parsing

Author: basnijholt

phase_diagram.ipynb

@@ -9,6 +9,7 @@
     "%%writefile learners_file.py\n",
     "\n",
     "import adaptive\n",
+    "from functools import partial\n",
     "\n",
     "import phase_diagram\n",
     "lead_pars = dict(\n",
@@ -27,8 +28,8 @@
     "    c_tunnel=3 / 4,\n",
     "    V_r=-50,\n",
     "    intrinsic_sc=False,\n",
-    "    mu_=lambda x0, sigma, mu_lead, mu_wire: mu_lead,\n",
-    "    V_=lambda z, V_0, V_r, V_l, x0, sigma, r1: 0,\n",
+    "    mu_=\"lambda x0, sigma, mu_lead, mu_wire: mu_lead\",\n",
+    "    V_=\"lambda z, V_0, V_r, V_l, x0, sigma, r1: 0\",\n",
     "    V_0=None,\n",
     "    V_l=None,\n",
     "    mu_lead=10,\n",
@@ -52,21 +53,29 @@
     "    import phase_diagram\n",
     "\n",
     "    params[\"B_x\"], params[\"mu_lead\"] = xy\n",
+    "    params = phase_diagram.parse_params(params)\n",
     "    lead = phase_diagram.make_lead(**lead_pars).finalized()\n",
     "    pf = phase_diagram.calculate_pfaffian(lead, params)\n",
     "    gap = phase_diagram.gap_from_modes(lead, params)\n",
     "    return pf * gap\n",
     "\n",
-    "fname = 'phase_diagram_gap.pickle'\n",
-    "# fname = 'phase_diagram.pickle'\n",
     "\n",
+    "fnames = ['phase_diagram_gap.pickle', 'phase_diagram_gap_no_orbital.pickle']\n",
     "loss = adaptive.learner.learnerND.curvature_loss_function()\n",
-    "learner = adaptive.LearnerND(smallest_gap, bounds=[(0, 2), (0, 35)], loss_per_simplex=loss)\n",
     "\n",
-    "# learner.load(fname)\n",
-    "\n",
-    "learners = [learner]\n",
-    "fnames = [fname]"
+    "learners = []\n",
+    "for orbital in [True, False]:\n",
+    "    f = partial(smallest_gap, params=dict(params, orbital=orbital))\n",
+    "    learners.append(adaptive.Learner2D(f, bounds=[(0, 2), (0, 35)],\n",
+    "#                                        loss_per_simplex=loss,\n",
+    "                                      ))\n",
+    "learner = adaptive.BalancingLearner(learners, strategy='npoints')\n",
+    "# fname = 'phase_diagram_gap.pickle'\n",
+    "# learner = adaptive.LearnerND(smallest_gap, bounds=[(0, 2), (0, 35)], loss_per_simplex=loss)\n",
+    "# learners = [learner]\n",
+    "# fnames = [fname]\n",
+    "\n",
+    "learner.load(fnames)"
    ]
   },
   {
@@ -76,19 +85,48 @@
    "outputs": [],
    "source": [
     "import adaptive\n",
+    "\n",
     "adaptive.notebook_extension()\n",
-    "runner = adaptive.Runner(learner, goal=lambda l: l.npoints > 60000)\n",
+    "runner = adaptive.Runner(learner, goal=lambda l: l.learners[1].npoints > 60000)\n",
     "runner.live_info()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adap"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "%%output size=100\n",
-    "learner.plot(tri_alpha=0.4, n=None)"
+    "%%opts Image [colorbar=True clim=(-0.1, 0)] \n",
+    "learners[1].plot(tri_alpha=0.4).Image.I[:, 10:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "runner.live_info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "learners[1].npoints"
    ]
   },
   {
@@ -97,7 +135,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "learner.save(fname)"
+    "learners[1].save(fnames[1])"
    ]
   },
   {
@@ -112,7 +150,7 @@
     "    return learner.npoints > 200\n",
     "\n",
     "scheduler = adaptive_scheduler.scheduler.DefaultScheduler(\n",
-    "    cores=100,\n",
+    "    cores=40,\n",
     "    executor_type=\"ipyparallel\",\n",
     ")  # PBS or SLURM\n",
     "\n",

phase_diagram.py

@@ -100,6 +100,16 @@ def memoizer(*args, **kwargs):
     return memoizer
 
 
+def parse_params(params):
+    for k, v in params.items():
+        if isinstance(v, str):
+            try:
+                params[k] = eval(v)
+            except NameError:
+                pass
+    return params
+
+
 @memoize
 def discretized_hamiltonian(a, which_lead=None):
     ham = (