phase_diagram.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile learners_file.py\n",
    "\n",
    "import adaptive\n",
    "from functools import partial\n",
    "\n",
    "import phase_diagram\n",
    "\n",
    "lead_pars = dict(\n",
    "    a=10, r1=50, r2=70, coverage_angle=135, angle=45, with_shell=True, which_lead=\"\"\n",
    ")\n",
    "\n",
    "params = dict(\n",
    "    alpha=20,\n",
    "    B_x=0,\n",
    "    B_y=0,\n",
    "    B_z=0,\n",
    "    Delta=110,\n",
    "    g=50,\n",
    "    orbital=True,\n",
    "    mu_sc=100,\n",
    "    c_tunnel=3 / 4,\n",
    "    V_r=-50,\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",
    "    mu_wire=None,\n",
    "    r1=None,\n",
    "    sigma=None,\n",
    "    x0=None,\n",
    "    **phase_diagram.constants.__dict__\n",
    ")\n",
    "\n",
    "\n",
    "def pf(xy, params=params, lead_pars=lead_pars):\n",
    "    import phase_diagram\n",
    "\n",
    "    params[\"B_x\"], params[\"mu_lead\"] = xy\n",
    "    lead = phase_diagram.make_lead(**lead_pars).finalized()\n",
    "    return phase_diagram.calculate_pfaffian(lead, params)\n",
    "\n",
    "\n",
    "def smallest_gap(xy, params=params, lead_pars=lead_pars):\n",
    "    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",
    "\n",
    "fnames = [\n",
    "#     \"phase_diagram_gap.pickle\",\n",
    "#     \"phase_diagram_gap_no_orbital.pickle\",\n",
    "#     \"phase_diagram_gap_sc_inside.pickle\",\n",
    "    \"phase_diagram_gap_sc_inside_no_orbital.pickle\",\n",
    "]\n",
    "loss = adaptive.learner.learnerND.curvature_loss_function()\n",
    "\n",
    "learners = []\n",
    "for sc_inside_wire, orbital, Delta in (\n",
    "#     [False, True, 110],\n",
    "#     [False, False, 110],\n",
    "#     [True, True, 0.25],\n",
    "    [True, False, 0.25],\n",
    "):\n",
    "    f = partial(\n",
    "        smallest_gap,\n",
    "        params=dict(params, orbital=orbital, Delta=Delta),\n",
    "        lead_pars=dict(\n",
    "            lead_pars, sc_inside_wire=sc_inside_wire, with_shell=(not sc_inside_wire)\n",
    "        ),\n",
    "    )\n",
    "    learners.append(adaptive.Learner2D(f, bounds=[(0, 2), (0, 35)]))\n",
    "learner = adaptive.BalancingLearner(learners, strategy=\"npoints\")\n",
    "\n",
    "learner.load(fnames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from learners_file import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import adaptive\n",
    "\n",
    "adaptive.notebook_extension()\n",
    "runner = adaptive.Runner(learner, goal=lambda l: l.learners[-1].npoints > 20000)\n",
    "runner.live_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import kwant\n",
    "%matplotlib inline\n",
    "kwant.plot(phase_diagram.make_lead(**f.keywords['lead_pars']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "runner.start_periodic_saving(dict(fname=fnames), 900)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learners[0].plot(n=200, tri_alpha=0.2).Image.I[:, 6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%output size=100\n",
    "%%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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for l, f in zip(learners, fnames):\n",
    "    l.save(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import adaptive_scheduler\n",
    "\n",
    "def goal(learner):\n",
    "    return learner.npoints > 200\n",
    "\n",
    "scheduler = adaptive_scheduler.scheduler.DefaultScheduler(\n",
    "    cores=40,\n",
    "    executor_type=\"ipyparallel\",\n",
    ")  # PBS or SLURM\n",
    "\n",
    "run_manager = adaptive_scheduler.server_support.RunManager(\n",
    "    scheduler=scheduler,\n",
    "    learners_file=\"learners_file.py\",\n",
    "    goal=goal,\n",
    "    log_interval=30,\n",
    "    save_interval=30,\n",
    "    job_name='phase-diagram'\n",
    ")\n",
    "run_manager.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from learners_file import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "adaptive.notebook_extension()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = learners[0]\n",
    "learner.plot(n=100)"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}