setup_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis tutorial explains in detailed step how the qtune package is used to set up an automated fine-tuner. \\n\\nThe tutorial assumes that you have read the readme, which gives you a general overview of the classes.\\n\\nThe first step\\nis the connection to the experiment, which depends on your implementation of a specific Experiment class for the \\ninterface to voltages and an Evaluator subclass for each parameter. \\nIn this tutorial, these classes are substituted by simple simulations.\\n'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import qtune.basic_dqd\n",
    "from qtune.experiment import Measurement\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import qtune.evaluator\n",
    "import qtune.parameter_tuner\n",
    "import qtune.solver\n",
    "import qtune.gradient\n",
    "import qtune.kalman_gradient\n",
    "import qtune.autotuner\n",
    "from qtune import gui\n",
    "import qtune.history\n",
    "\n",
    "\"\"\"\n",
    "This tutorial explains in detailed step how the qtune package is used to set up an automated fine-tuner. \n",
    "\n",
    "The tutorial assumes that you have read the readme, which gives you a general overview of the classes.\n",
    "\n",
    "The first step\n",
    "is the connection to the experiment, which depends on your implementation of a specific Experiment class for the \n",
    "interface to voltages and an Evaluator subclass for each parameter. \n",
    "In this tutorial, these classes are substituted by simple simulations.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThe Simulator class simulates the dependence of the singlet reload time on two gate forming a tunnel barrier, which are \\nchosen to be the voltages on the gates T and SA. The simulating function is called \"load_simulation\" The corresponding \\nscan has the name \"load_scan\".  \\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "The important information is the use of the Measurement class. The Simulator will be replaced by an actual measurement.\n",
    "\"\"\"\n",
    "singlet_reload_simulation = qtune.basic_dqd.Simulator(qtune.basic_dqd.load_simulation, gate1=\"T\", gate2=\"SA\")\n",
    "default_reload_scan = Measurement(\"load_scan\")\n",
    "\"\"\"\n",
    "The Simulator class simulates the dependence of the singlet reload time on two gate forming a tunnel barrier, which are \n",
    "chosen to be the voltages on the gates T and SA. The simulating function is called \"load_simulation\" The corresponding \n",
    "scan has the name \"load_scan\".  \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The simulator for the inter-dot tunnel coupling by the transition broadening. The scan sweeps the detuning. A \n",
    "Measurement can be given any information keyword argument. They are all saved in the options dictionary.\n",
    "\"\"\"\n",
    "detune_sim = qtune.basic_dqd.Simulator(qtune.basic_dqd.detune_simulation, central_upper_gate=\"T\",\n",
    "                                       central_lower_gate=\"N\", left_gate=\"SB\", right_gate=\"SA\")\n",
    "default_detune_scan = Measurement('detune_scan', center=0., range=2e-3, N_points=100, ramptime=.02, N_average=10,\n",
    "                                  AWGorDecaDAC='AWG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The one dimensional scan of a sensing dot.\n",
    "\"\"\"\n",
    "ss1d_sim = qtune.basic_dqd.Simulator(qtune.basic_dqd.ss1d_simulation)\n",
    "sensing_dot_measurement = Measurement('line_scan', center=0., range=4e-3, gate=\"SDB2\", N_points=1280, ramptime=.0005,\n",
    "                                      N_average=1, AWGorDecaDAC='DecaDAC')\n",
    "\"\"\"\n",
    "The two dimensional scan of a sensing dot.\n",
    "\"\"\"\n",
    "ss2d_sim = qtune.basic_dqd.Simulator(qtune.basic_dqd.ss2d_simulation, gate1=\"SDB1\", gate2='SDB2')\n",
    "ss2d_measurement = Measurement(\"ss2d\", center=[0, 0], gate1='SDB1', gate2='SDB2', range=15e-3, n_lines=20, n_points=104)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Transitions in the charge diagram.\n",
    "\"\"\"\n",
    "rfa_trans_sim = qtune.basic_dqd.Simulator(qtune.basic_dqd.transition_simulation, gate_lead=\"SA\", gate_opposite=\"BA\")\n",
    "rfa_line_scan = Measurement('line_scan', center=0., range=4e-3, gate='RFA', N_points=1280, ramptime=.0005,\n",
    "                            N_average=3, AWGorDecaDAC='DecaDAC')\n",
    "\n",
    "\n",
    "rfb_trans_sim = qtune.basic_dqd.Simulator(qtune.basic_dqd.transition_simulation, gate_lead=\"SB\", gate_opposite=\"BB\")\n",
    "rfb_line_scan = Measurement('line_scan', center=0., range=4e-3, gate='RFB', N_points=1280, ramptime=.0005,\n",
    "                            N_average=3, AWGorDecaDAC='DecaDAC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The initialisation of the simulated experiment. This will be replaced by the actual experiment.\n",
    "\"\"\"\n",
    "initial_voltages = pd.Series({\"SA\": -3., \"T\": -1., \"SDB1\": 0., \"SDB2\": 0., \"SB\": -2., \"N\": 0., \"BA\": -4., \"BB\": -2.,\n",
    "                              \"RFA\": 0., \"RFB\": 0.})\n",
    "\n",
    "exp = qtune.basic_dqd.TestExperiment(initial_voltages=initial_voltages,\n",
    "                                     measurements=(default_detune_scan, default_reload_scan, sensing_dot_measurement,\n",
    "                                                   ss2d_measurement, rfa_line_scan, rfb_line_scan),\n",
    "                                     simulator_dict={id(default_detune_scan): detune_sim, id(default_reload_scan): singlet_reload_simulation,\n",
    "                                                     id(sensing_dot_measurement): ss1d_sim, id(ss2d_measurement): ss2d_sim,\n",
    "                                                     id(rfa_line_scan): rfa_trans_sim, id(rfb_line_scan): rfb_trans_sim})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Now comes the actual setup of the automated tuner. We will have to repeat the following steps for each group of \n",
    "parameters. The first group is the sensing dot.\n",
    "\"\"\"\n",
    "test_ss1d_evaluator = qtune.evaluator.SensingDot1D(exp,\n",
    "                                                   measurements=(sensing_dot_measurement, ),\n",
    "                                                   parameters=(\"position_SDB2\", \"current_signal\", \"optimal_signal\"),\n",
    "                                                   name='SensingDot1D')\n",
    "test_ss2d_evaluator = qtune.evaluator.SensingDot2D(exp,\n",
    "                                                   measurements=(ss2d_measurement,),\n",
    "                                                   parameters=(\"position_SDB1\", \"position_SDB2\"),\n",
    "                                                   name='SensingDot2D'\n",
    "                                                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "For the sensing dot, two measurements are implemented: a one and a two dimensional scan of the Coulomb oscillations.\n",
    "The measurements are in each case a list containing only one scan. The keyword argument \"parameters\" contains a list\n",
    "of the parameter names. \n",
    "The one dimensional scan gives the current sensitivity (current_signal), the optimal sensitivity\n",
    "(optimal_signal), which can be achieved by adjusting the voltage on the sweeping gate and the position of the highest \n",
    "sensitivity (position_SDB2).\n",
    "The SensingDotTuner requires conditions to decide, when to use which scan. These conditions are specified in the target.\n",
    "The minimal threshold (min_threshold) defines the condition, under which no voltage needs to be changed. In this case\n",
    "a certain signal must be currently obtained. The cost threshold requires a certain sensitivity must be obtainable by \n",
    "changing only the gate voltage on the sweeping gate. If this condition is not met, the two dimensional scan is used.\n",
    "This requires more measurement time but should yield a better sensitivity.\n",
    "\"\"\"\n",
    "min_threshold = pd.Series(data=[2e-3, -np.inf, -np.inf], index=[\"current_signal\", \"optimal_signal\", \"position_SDB2\"])\n",
    "cost_threshold = pd.Series(data=[-np.inf, 2e-3, -np.inf], index=[\"current_signal\", \"optimal_signal\", \"position_SDB2\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The rescaling is implemented in the target as well. For each parameter can be given a number or NAN value.\n",
    "The conditions are combined into the target by the make_target function. It expects pandas Series and returns the target\n",
    "as pandas Dataframe.\n",
    "\"\"\"\n",
    "rescaling_factor = pd.Series(data=[1, 1, 1, 1],\n",
    "                             index=[\"current_signal\", \"optimal_signal\", \"position_SDB2\", \"position_SDB1\"])\n",
    "ss_target = qtune.solver.make_target(minimum=min_threshold, cost_threshold=cost_threshold,\n",
    "                                     rescaling_factor=rescaling_factor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The ForwardingSolver is trivial. It receives values and only changes names to return the expected results. The tuner\n",
    "implements the decision making on which scan to choose.\n",
    "\"\"\"\n",
    "fsolver = qtune.solver.ForwardingSolver(target=ss_target,\n",
    "                                        values_to_position=pd.Series(data=[\"SDB1\", \"SDB2\"],\n",
    "                                                                     index=[\"position_SDB1\", \"position_SDB2\"]),\n",
    "                                        current_position=exp.read_gate_voltages())\n",
    "ss_tuner = qtune.parameter_tuner.SensingDotTuner(cheap_evaluators=[test_ss1d_evaluator],\n",
    "                                                 expensive_evaluators=[test_ss2d_evaluator],\n",
    "                                                 gates=[\"SDB1\", \"SDB2\"], solver=fsolver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Lead Transition:\n",
    "We control the chemical potential in the dots by the position of the charge diagram. This position is defined by \n",
    "positions of lead transitions. These transitions occur when the chemical potential inside a dot is exactly as large as\n",
    "the chemical potential in a lead. By crossing over this transition an electron is pushed into the dot or pulled out.\n",
    "We implement one Evaluator for each transition. In principle they could be implemented in a single evaluator as they are\n",
    "always evaluated together.\n",
    "\"\"\"\n",
    "\n",
    "lta_evaluator = qtune.evaluator.LeadTransition(exp, shifting_gates=(\"RFB\", ), sweeping_gates=(\"RFA\", ),\n",
    "                                               parameters=(\"position_RFA\", ), measurements=(rfa_line_scan, ),\n",
    "                                               name='LeadTransitionRFA')\n",
    "ltb_evaluator = qtune.evaluator.LeadTransition(exp, shifting_gates=(\"RFA\", ), sweeping_gates=(\"RFB\", ),\n",
    "                                               parameters=(\"position_RFB\", ), measurements=(rfb_line_scan, ),\n",
    "                                               name='LeadTransitionRFB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Kalman filter:\n",
    "We want to optimize the positions of the lead transitions by a gradient based optimization algorithm combined with the\n",
    "Kalman filter. The KalmanGradient implements the Kalman filter. We set the number of gates (n_pos_dim) to 6 and the\n",
    "number of parameters (n_values) to 1. The initial covariance matrix and the process noise are chosen heuristically. \n",
    "\"\"\"\n",
    "\n",
    "rfa_kalman = qtune.kalman_gradient.KalmanGradient(n_pos_dim=6, n_values=1, initial_gradient=None,\n",
    "                                                  initial_covariance_matrix=1e4 * np.eye(6),\n",
    "                                                  process_noise=1e-2 * np.eye(6))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The GradientEstimator class administers the Gradient classes. In this case the KalmanGradientEstimator determines the \n",
    "maximal covariance. If any eigenvalue of the covariance matrix of the KalmanGradient is larger than maximum_covariance,\n",
    "and update step of length epsilon is performed in the direction of the corresponding eigenvector. \n",
    "\"\"\"\n",
    "\n",
    "voltages = exp.read_gate_voltages()[[\"BA\", \"BB\", \"N\", \"SA\", \"SB\", \"T\"]]\n",
    "voltages = voltages.sort_index()\n",
    "rfa_gradient_estimator = qtune.gradient.KalmanGradientEstimator(rfa_kalman,\n",
    "                                                                current_position=voltages,\n",
    "                                                                current_value=1., maximum_covariance=1., epsilon=.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "We proceed likewise for the second transition.\n",
    "\"\"\"\n",
    "\n",
    "rfb_kalman = qtune.kalman_gradient.KalmanGradient(n_pos_dim=6, n_values=1, initial_gradient=None,\n",
    "                                                  initial_covariance_matrix=1e4 * np.eye(6),\n",
    "                                                  process_noise=1e-2 * np.eye(6))\n",
    "rfb_gradient_estimator = qtune.gradient.KalmanGradientEstimator(rfb_kalman,\n",
    "                                                                current_position=voltages,\n",
    "                                                                current_value=1., maximum_covariance=1., epsilon=.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The targets are simply defined by target values for the positions and tolerances. All elements which are given a desired\n",
    "value NAN will be kept constant. This way, each solver respects also the parameter it does not tune directly.\n",
    "\"\"\"\n",
    "cd_target = qtune.solver.make_target(desired=pd.Series([0., 0., np.nan, np.nan],\n",
    "                                                       [\"position_RFA\", \"position_RFB\", \"parameter_tunnel_coupling\",\n",
    "                                                        \"parameter_time_load\"]),\n",
    "                                     tolerance=pd.Series([.01, .01, np.nan, np.nan],\n",
    "                                                         [\"position_RFA\", \"position_RFB\", \"parameter_tunnel_coupling\",\n",
    "                                                          \"parameter_time_load\"]),\n",
    "                                     rescaling_factor=pd.Series([1, 1, 1, 1],\n",
    "                                                                [\"position_RFA\", \"position_RFB\",\n",
    "                                                                 \"parameter_tunnel_coupling\", \"parameter_time_load\"]))\n",
    "par_target = qtune.solver.make_target(\n",
    "    desired=pd.Series([np.nan, np.nan, 2.20, 1.5],\n",
    "                      [\"position_RFA\", \"position_RFB\", \"parameter_tunnel_coupling\", \"parameter_time_load\"]),\n",
    "    tolerance=pd.Series([np.nan, np.nan, .05, .5],\n",
    "                        [\"position_RFA\", \"position_RFB\", \"parameter_tunnel_coupling\", \"parameter_time_load\"]),\n",
    "    rescaling_factor=pd.Series([1, 1, 100, 10],\n",
    "                               [\"position_RFA\", \"position_RFB\",\n",
    "                                \"parameter_tunnel_coupling\",\n",
    "                                \"parameter_time_load\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Now we consider the remaining parameters, which are the width of the inter dot transition and the singlet reload time.\n",
    "Here we use again the simulators.\n",
    "\"\"\"\n",
    "\n",
    "test_line_evaluator = qtune.evaluator.InterDotTCByLineScan(experiment=exp, measurements=(default_detune_scan, ))\n",
    "test_load_evaluator = qtune.evaluator.NewLoadTime(experiment=exp, measurements=(default_reload_scan,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "We want to tune them as well with the Kalman filter so that we proceed as we did for the lead transitions.\n",
    "\"\"\"\n",
    "\n",
    "line_kalman = qtune.kalman_gradient.KalmanGradient(n_pos_dim=6, n_values=1, initial_gradient=None,\n",
    "                                                   initial_covariance_matrix=1e4 * np.eye(6))\n",
    "line_gradient_estimator = qtune.gradient.KalmanGradientEstimator(line_kalman,\n",
    "                                                                 current_position=voltages,\n",
    "                                                                 current_value=1., maximum_covariance=1., epsilon=.1)\n",
    "load_kalman = qtune.kalman_gradient.KalmanGradient(n_pos_dim=6, n_values=1, initial_gradient=None,\n",
    "                                                   initial_covariance_matrix=1e4 * np.eye(6))\n",
    "load_gradient_estimator = qtune.gradient.KalmanGradientEstimator(load_kalman,\n",
    "                                                                 current_position=voltages,\n",
    "                                                                 current_value=1., maximum_covariance=1., epsilon=.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd_solver = qtune.solver.NewtonSolver(target=cd_target,\n",
    "                                      current_position=voltages,\n",
    "                                      gradient_estimators=[rfa_gradient_estimator, rfb_gradient_estimator,\n",
    "                                                           line_gradient_estimator, load_gradient_estimator])\n",
    "par_solver = qtune.solver.NewtonSolver(target=par_target,\n",
    "                                       current_position=voltages,\n",
    "                                       gradient_estimators=[rfa_gradient_estimator, rfb_gradient_estimator,\n",
    "                                                            line_gradient_estimator, load_gradient_estimator])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The SubsetTuner use only a specific set of gates to tune their parameters.\n",
    "\"\"\"\n",
    "\n",
    "cd_tuner = qtune.parameter_tuner.SubsetTuner(evaluators=[lta_evaluator, ltb_evaluator],\n",
    "                                             gates=[\"BA\", \"BB\", \"N\", \"SA\", \"SB\", \"T\"], solver=cd_solver)\n",
    "par_tuner = qtune.parameter_tuner.SubsetTuner(evaluators=[test_line_evaluator, test_load_evaluator],\n",
    "                                              gates=[\"BA\", \"BB\", \"N\", \"SA\", \"SB\", \"T\"], solver=par_solver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The AutoTuner stores its information in the folder given by storage_path. The tuning_hierarchy is given as list. It\n",
    "describes the order, in which the parameters are tuned. In this case we tune first the sensing dot, then the position \n",
    "of the lead transitions and then the singlet reload time and the inter dot transition width. Any time a voltage is \n",
    "changed an Autotuner restarts with the first element of the hierarchy. In this case, it is the sensing dot.\n",
    "\"\"\"\n",
    "\n",
    "storage_path = r\"Y:\\GaAs\\Autotune\\Data\\UsingPython\\DryRunsRefactored\"\n",
    "auto_tuner = qtune.autotuner.Autotuner(exp, tuning_hierarchy=[ss_tuner, cd_tuner, par_tuner],\n",
    "                                       hdf5_storage_path=storage_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "We initialize an empty history to store the analyse the Autotuner during the runtime. You can use the GUI for convenient\n",
    "tuning. Just press start in the emerging GUI window. You can press the button  labeled \"Real Time Plot\" for plotting \n",
    "voltages, parameters and gradient during the tuning. \n",
    "\"\"\"\n",
    "\n",
    "hist = qtune.history.History(None)\n",
    "w = gui.setup_default_gui(auto_tuner, hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "To reload the data of a tuning run, you can simply initialize a History object with the path to the storage folder (by\n",
    "default labeled with the time of the execution of the tuning).\n",
    "\"\"\"\n",
    "loading_path = storage_path + r\"\\2018_09_16_15_57_31_299648\"\n",
    "hist = qtune.history.History(loading_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}