2017-12-20_mg_method_comparison_dicke2_noise.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:32.292352Z",
     "start_time": "2017-12-30T04:20:28.056516Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "1"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from os.path import join\n",
    "from io import StringIO\n",
    "from glob import glob\n",
    "from textwrap import dedent\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "import pandas as pd\n",
    "from collections import defaultdict\n",
    "\n",
    "import QDYN\n",
    "from src.single_sided_network_v1 import network_slh\n",
    "from src.dicke_single_model_v2 import write_dicke_single_model\n",
    "\n",
    "from doit.tools import register_doit_as_IPython_magic\n",
    "import clusterjob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:32.309988Z",
     "start_time": "2017-12-30T04:20:32.297982Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "2"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "DOIT_CONFIG = {\n",
    "    'backend': 'json',\n",
    "    'dep_file': '.doit_db/2017-12-20_mg_method_comparison_dicke2_noise.json',\n",
    "}\n",
    "register_doit_as_IPython_magic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:32.356201Z",
     "start_time": "2017-12-30T04:20:32.314818Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "3"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "clusterjob.JobScript.read_defaults('./config/mlhpc_cluster.ini')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:32.547636Z",
     "start_time": "2017-12-30T04:20:32.360145Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "4"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QDYN 2.0dev revision dfd21683b898e790985b519daac35aeef7721f6c (master)\r\n",
      "  features: no-check-cheby, no-check-newton, no-parallel-ham, use-mkl=sequential, use-mpi=intel, parallel-oct, backtraces, no-debug, no-no-ipo\r\n",
      "  compiled with ifort on Mon Nov 13 14:54:23 2017 on host mlhpc2\r\n"
     ]
    }
   ],
   "source": [
    "! qdyn_version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "\\newcommand{ket}[1]{\\vert #1 \\rangle}\n",
    "\\newcommand{bra}[1]{\\langle #1 \\vert}\n",
    "\\newcommand{Op}[1]{\\hat{#1}}\n",
    "$\n",
    "\n",
    "# Compare variants of Krotov's method for optimization of a two-node Dicke state\n",
    "\n",
    "This does some extra calculations to get better statistics on the behavior of scaling of the noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.523619Z",
     "start_time": "2017-12-30T04:20:32.552746Z"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We'll use different runfolders, but we want to re-use any data from the\n",
    "# earlier calculations, which only did powers of two in the number of\n",
    "# trajectories\n",
    "! rsync -a ./data/method_comparison_dicke2/ ./data/method_comparison_dicke2_noise/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.547036Z",
     "start_time": "2017-12-30T04:20:34.529303Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "5"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def runfolder(row):\n",
    "    int_part, frac_part = (\"%.2f\" % row['T']).split('.')\n",
    "    root = './data/method_comparison_dicke2_noise/'\n",
    "    if frac_part == '00':\n",
    "        T_str = \"%s\" % int_part\n",
    "    else:\n",
    "        T_str = '%s_%s' % (int_part, frac_part)\n",
    "    rf = \"T%s_%s_ntrajs%s\" % (T_str, row['variant'], row['n_trajs'])\n",
    "    return join(root, rf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## action wrappers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.636570Z",
     "start_time": "2017-12-30T04:20:34.552067Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "6"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from src.doit_actions_v2 import (\n",
    "    run_traj_prop, update_config, wait_for_clusterjob,\n",
    "    write_rho_prop_custom_config, collect_rho_prop_errors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.679094Z",
     "start_time": "2017-12-30T04:20:34.639609Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "7"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def submit_optimization(rf, n_trajs, variant, task):\n",
    "    \"\"\"Asynchronously run optimization, using either the\n",
    "    standard QDYN implementation (variant = 'normal') or the 'crossoct' QDYN\n",
    "    implementation at a particular revision (variant='cross')\n",
    "\n",
    "    Does not support use of MPI, so this should only run on a workstation with\n",
    "    more cores than the total number of trajectories\n",
    "    \"\"\"\n",
    "    if os.path.isfile(join(rf, 'oct.job.dump')):\n",
    "        return\n",
    "    bodies = {\n",
    "        'normal': dedent(r'''\n",
    "    {module_load}\n",
    "    cd $CLUSTERJOB_WORKDIR\n",
    "    pwd\n",
    "    OMP_NUM_THREADS={threads} qdyn_optimize --n-trajs={n_trajs} --J_T=J_T_ss .\n",
    "    '''),\n",
    "        'cross': dedent(r'''\n",
    "    {module_load}\n",
    "    module load prefix/crossoct\n",
    "\n",
    "    qdyn_version | grep 66f6d24d2b07b9cc || {cancel_cmd}\n",
    "\n",
    "    cd $CLUSTERJOB_WORKDIR\n",
    "    pwd\n",
    "    OMP_NUM_THREADS={threads} qdyn_optimize --n-trajs={n_trajs} --J_T=J_T_cross .\n",
    "    ''')}\n",
    "    body = bodies[variant]\n",
    "    taskname = \"oct_%s\" % task.name.split(\":\")[-1]\n",
    "    jobscript = clusterjob.JobScript(\n",
    "        body=body, jobname=taskname, workdir=rf,\n",
    "        stdout='oct.log')\n",
    "    jobscript.n_trajs = str(int(n_trajs))\n",
    "    jobscript.resources['ppn'] = 1 # not using MPI\n",
    "    jobscript.resources['threads'] = min(int(n_trajs), 78)\n",
    "    jobscript.threads = str(jobscript.resources['threads'])\n",
    "    run = jobscript.submit(cache_id=taskname)\n",
    "    run.dump(join(rf, 'oct.job.dump'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## custom uptodate routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.713110Z",
     "start_time": "2017-12-30T04:20:34.681913Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "8"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from src.qdyn_model_v2 import pulses_uptodate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OCT task definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.778151Z",
     "start_time": "2017-12-30T04:20:34.715670Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "9"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def task_create_runfolder():\n",
    "    \"\"\"Create all necessary runfolders for the runs defined in params_df\"\"\"\n",
    "    jobs = {}\n",
    "    slh_models = {}\n",
    "    n_nodes = 2\n",
    "    for ind, row in params_df.iterrows():\n",
    "        rf = runfolder(row)\n",
    "        try:\n",
    "            slh = slh_models[n_nodes]\n",
    "        except KeyError:\n",
    "            slh = network_slh(\n",
    "                n_cavity=2, n_nodes=n_nodes, topology='driven_bs_fb')\n",
    "            slh_models[n_nodes] = slh\n",
    "        if rf in jobs:\n",
    "            continue\n",
    "        mcwf = {  #   variant => whether to use MCWF\n",
    "            'rho': False, 'nonherm': False, 'independent': True,\n",
    "            'cross': True}\n",
    "        jobs[rf] = {\n",
    "            'name': str(rf),\n",
    "            'actions': [\n",
    "                # write the density matrix propagation data\n",
    "                (write_dicke_single_model, [slh, ], dict(\n",
    "                    rf=rf, T=row['T'], theta=0, nt=500,\n",
    "                    kappa=1.0, E0_cycles=2,\n",
    "                    mcwf=False, non_herm=False, # this defines rho-prop\n",
    "                    config='config_rho')),\n",
    "                # write the data for the optimization\n",
    "                (write_dicke_single_model, [slh, ], dict(\n",
    "                    rf=rf, T=row['T'], theta=0, nt=500,\n",
    "                    kappa=1.0, E0_cycles=2, mcwf=mcwf[row['variant']],\n",
    "                    non_herm=(row['variant'] != 'rho'),\n",
    "                    lambda_a=row['lambda_a'], keep_pulses='all',\n",
    "                    iter_stop=int(row['iter_stop']), J_T_conv=row['J_T_conv'],\n",
    "                    config='config'))],\n",
    "            'targets': [join(rf, 'config_rho'), join(rf, 'config')],\n",
    "            'uptodate': [True, ] # up to date if targets exist\n",
    "        }\n",
    "    for job in jobs.values():\n",
    "        yield job"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.832318Z",
     "start_time": "2017-12-30T04:20:34.780748Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "10"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def task_update_runfolder():\n",
    "    \"\"\"For every row in params_df, update the config file in the appropriate\n",
    "    runfolder with the value in that row\n",
    "    (adjusting lambda_a, iter_stop and J_T_conv only)\"\"\"\n",
    "    rf_jobs = defaultdict(list)\n",
    "    for ind, row in params_df.iterrows():\n",
    "        rf = runfolder(row)\n",
    "        # we only update the config after any earlier optimization has finished\n",
    "        task_dep = ['wait_for_optimization:%s' % ind2 for ind2 in rf_jobs[rf]]\n",
    "        rf_jobs[rf].append(ind)\n",
    "        yield {\n",
    "            'name': str(ind),\n",
    "            'actions': [\n",
    "                (update_config, [], dict(\n",
    "                    rf=rf, lambda_a=row['lambda_a'],\n",
    "                    iter_stop=int(row['iter_stop']),\n",
    "                    J_T_conv=row['J_T_conv']))],\n",
    "            'file_dep': [join(rf, 'config')],\n",
    "            'uptodate': [False, ],  # always run task\n",
    "            'task_dep': task_dep}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.888962Z",
     "start_time": "2017-12-30T04:20:34.834782Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "11"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def task_submit_optimization():\n",
    "    \"\"\"Run optimization for every runfolder from params_df\"\"\"\n",
    "    rf_jobs = defaultdict(list)\n",
    "    optimization_variant = {\n",
    "        'rho': 'normal',\n",
    "        'nonherm': 'normal',\n",
    "        'independent': 'normal',\n",
    "        'cross': 'cross',\n",
    "    }\n",
    "    for ind, row in params_df.iterrows():\n",
    "        rf = runfolder(row)\n",
    "        task_dep = ['wait_for_optimization:%s' % ind2 for ind2 in rf_jobs[rf]]\n",
    "        task_dep.append('update_runfolder:%s' % ind)\n",
    "        yield {\n",
    "            'name': str(ind),\n",
    "            'actions': [\n",
    "                (submit_optimization, [rf, ],\n",
    "                 dict(n_trajs=row['n_trajs'],\n",
    "                      variant=optimization_variant[row['variant']]))],\n",
    "                # 'task' keyword arg is added automatically\n",
    "            'task_dep': task_dep,\n",
    "            'uptodate': [(pulses_uptodate, [], {'rf': rf}), ],\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.936917Z",
     "start_time": "2017-12-30T04:20:34.891313Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "12"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def task_wait_for_optimization():\n",
    "    for ind, row in params_df.iterrows():\n",
    "        rf = runfolder(row)\n",
    "        yield {\n",
    "            'name': str(ind),\n",
    "            'task_dep': ['submit_optimization:%d' % ind],\n",
    "            'actions': [\n",
    "                (wait_for_clusterjob, [join(rf, 'oct.job.dump')], {}),]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additional tasks for evaluating the optimization success through a propagation\n",
    "in Liouville space are defined farther below\n",
    "\n",
    "##  OCT Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:34.996961Z",
     "start_time": "2017-12-30T04:20:34.942820Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "13"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "params_data_str = r'''\n",
    "# T  lambda_a      variant  n_trajs   iter_stop   J_T_conv\n",
    "  5     0.001  independent        1        5000       1e-8\n",
    "  5     0.001  independent        2        5000       1e-8\n",
    "  5     0.001  independent        3        5000       1e-8\n",
    "  5     0.001  independent        4        5000       1e-8\n",
    "  5     0.001  independent        5        5000       1e-8\n",
    "  5     0.001  independent        8        5000       1e-8\n",
    "  5     0.001  independent       10        5000       1e-8\n",
    "  5     0.001  independent       15        5000       1e-8\n",
    "  5     0.001  independent       20        5000       1e-8\n",
    "  5     0.001  independent       25        5000       1e-8\n",
    "  5     0.001  independent       30        5000       1e-8\n",
    "  5     0.001  independent       32        5000       1e-8\n",
    "  5     0.001  independent       35        5000       1e-8\n",
    "  5     0.001  independent       40        5000       1e-8\n",
    "  5     0.001  independent       45        5000       1e-8\n",
    "  5     0.001  independent       50        5000       1e-8\n",
    "  5     0.001  independent       55        5000       1e-8\n",
    "  5     0.001  independent       60        5000       1e-8\n",
    "  5     0.001  independent       64        5000       1e-8\n",
    "  5     0.001  independent       70        5000       1e-8\n",
    "  5     0.001  independent       75        5000       1e-8\n",
    "  5     0.001  independent       80        5000       1e-8\n",
    "  5     0.001  independent       85        5000       1e-8\n",
    "  5     0.001  independent       90        5000       1e-8\n",
    "  5     0.001  independent      100        5000       1e-8\n",
    "  5     0.001  independent      110        5000       1e-8\n",
    "  5     0.001  independent      120        5000       1e-8\n",
    "  5     0.001  independent      128        5000       1e-8\n",
    "  5     0.001  cross              2        5000       1e-8\n",
    "  5     0.001  cross              3        5000       1e-8\n",
    "  5     0.001  cross              4        5000       1e-8\n",
    "  5     0.001  cross              5        5000       1e-8\n",
    "  5     0.001  cross              8        5000       1e-8\n",
    "  5     0.001  cross             10        5000       1e-8\n",
    "  5     0.001  cross             15        5000       1e-8\n",
    "  5     0.001  cross             20        5000       1e-8\n",
    "  5     0.001  cross             25        5000       1e-8\n",
    "  5     0.001  cross             30        5000       1e-8\n",
    "  5     0.001  cross             32        5000       1e-8\n",
    "  5     0.001  cross             35        5000       1e-8\n",
    "  5     0.001  cross             40        5000       1e-8\n",
    "  5     0.001  cross             45        5000       1e-8\n",
    "  5     0.001  cross             50        5000       1e-8\n",
    "  5     0.001  cross             55        5000       1e-8\n",
    "  5     0.001  cross             60        5000       1e-8\n",
    "  5     0.001  cross             64        5000       1e-8\n",
    "  5     0.001  cross             70        5000       1e-8\n",
    "  5     0.001  cross             75        5000       1e-8\n",
    "  5     0.001  cross             80        5000       1e-8\n",
    "  5     0.001  cross             85        5000       1e-8\n",
    "  5     0.001  cross             90        5000       1e-8\n",
    "  5     0.001  cross            100        5000       1e-8\n",
    "  5     0.001  cross            110        5000       1e-8\n",
    "  5     0.001  cross            120        5000       1e-8\n",
    "  5     0.001  cross            128        5000       1e-8\n",
    "'''\n",
    "params_df = pd.read_fwf(\n",
    "        StringIO(params_data_str), comment='#', header=1,\n",
    "        names=['T', 'lambda_a', 'variant', 'n_trajs', 'iter_stop', 'J_T_conv'],\n",
    "        converters={\n",
    "            'T': float, 'lambda_a': float, 'variant': str,\n",
    "            'n_trajs': int, 'iter_stop': int, 'J_T_conv': float})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:35.070284Z",
     "start_time": "2017-12-30T04:20:35.001105Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "14"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      T  lambda_a      variant  n_trajs  iter_stop      J_T_conv\n",
      "0   5.0     0.001  independent        1       5000  1.000000e-08\n",
      "1   5.0     0.001  independent        2       5000  1.000000e-08\n",
      "2   5.0     0.001  independent        3       5000  1.000000e-08\n",
      "3   5.0     0.001  independent        4       5000  1.000000e-08\n",
      "4   5.0     0.001  independent        5       5000  1.000000e-08\n",
      "5   5.0     0.001  independent        8       5000  1.000000e-08\n",
      "6   5.0     0.001  independent       10       5000  1.000000e-08\n",
      "7   5.0     0.001  independent       15       5000  1.000000e-08\n",
      "8   5.0     0.001  independent       20       5000  1.000000e-08\n",
      "9   5.0     0.001  independent       25       5000  1.000000e-08\n",
      "10  5.0     0.001  independent       30       5000  1.000000e-08\n",
      "11  5.0     0.001  independent       32       5000  1.000000e-08\n",
      "12  5.0     0.001  independent       35       5000  1.000000e-08\n",
      "13  5.0     0.001  independent       40       5000  1.000000e-08\n",
      "14  5.0     0.001  independent       45       5000  1.000000e-08\n",
      "15  5.0     0.001  independent       50       5000  1.000000e-08\n",
      "16  5.0     0.001  independent       55       5000  1.000000e-08\n",
      "17  5.0     0.001  independent       60       5000  1.000000e-08\n",
      "18  5.0     0.001  independent       64       5000  1.000000e-08\n",
      "19  5.0     0.001  independent       70       5000  1.000000e-08\n",
      "20  5.0     0.001  independent       75       5000  1.000000e-08\n",
      "21  5.0     0.001  independent       80       5000  1.000000e-08\n",
      "22  5.0     0.001  independent       85       5000  1.000000e-08\n",
      "23  5.0     0.001  independent       90       5000  1.000000e-08\n",
      "24  5.0     0.001  independent      100       5000  1.000000e-08\n",
      "25  5.0     0.001  independent      110       5000  1.000000e-08\n",
      "26  5.0     0.001  independent      120       5000  1.000000e-08\n",
      "27  5.0     0.001  independent      128       5000  1.000000e-08\n",
      "28  5.0     0.001        cross        2       5000  1.000000e-08\n",
      "29  5.0     0.001        cross        3       5000  1.000000e-08\n",
      "30  5.0     0.001        cross        4       5000  1.000000e-08\n",
      "31  5.0     0.001        cross        5       5000  1.000000e-08\n",
      "32  5.0     0.001        cross        8       5000  1.000000e-08\n",
      "33  5.0     0.001        cross       10       5000  1.000000e-08\n",
      "34  5.0     0.001        cross       15       5000  1.000000e-08\n",
      "35  5.0     0.001        cross       20       5000  1.000000e-08\n",
      "36  5.0     0.001        cross       25       5000  1.000000e-08\n",
      "37  5.0     0.001        cross       30       5000  1.000000e-08\n",
      "38  5.0     0.001        cross       32       5000  1.000000e-08\n",
      "39  5.0     0.001        cross       35       5000  1.000000e-08\n",
      "40  5.0     0.001        cross       40       5000  1.000000e-08\n",
      "41  5.0     0.001        cross       45       5000  1.000000e-08\n",
      "42  5.0     0.001        cross       50       5000  1.000000e-08\n",
      "43  5.0     0.001        cross       55       5000  1.000000e-08\n",
      "44  5.0     0.001        cross       60       5000  1.000000e-08\n",
      "45  5.0     0.001        cross       64       5000  1.000000e-08\n",
      "46  5.0     0.001        cross       70       5000  1.000000e-08\n",
      "47  5.0     0.001        cross       75       5000  1.000000e-08\n",
      "48  5.0     0.001        cross       80       5000  1.000000e-08\n",
      "49  5.0     0.001        cross       85       5000  1.000000e-08\n",
      "50  5.0     0.001        cross       90       5000  1.000000e-08\n",
      "51  5.0     0.001        cross      100       5000  1.000000e-08\n",
      "52  5.0     0.001        cross      110       5000  1.000000e-08\n",
      "53  5.0     0.001        cross      120       5000  1.000000e-08\n",
      "54  5.0     0.001        cross      128       5000  1.000000e-08\n"
     ]
    }
   ],
   "source": [
    "print(params_df.to_string())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:35.108929Z",
     "start_time": "2017-12-30T04:20:35.073341Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "15"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import logging\n",
    "root = logging.getLogger()\n",
    "for handler in root.handlers[:]:\n",
    "    root.removeHandler(handler)\n",
    "logging.basicConfig(\n",
    "    level=logging.DEBUG, filename='./data/method_comparison_dicke2_noise.log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:44.963705Z",
     "start_time": "2017-12-30T04:20:35.112490Z"
    },
    "attributes": {
     "classes": [],
     "id": "",
     "n": "16"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs1\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs2\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs3\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs4\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs5\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs8\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs10\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs15\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs20\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs25\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs30\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs32\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs35\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs40\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs45\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs50\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs55\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs60\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs64\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs70\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs75\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs80\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs85\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs90\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs100\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs110\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs120\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_independent_ntrajs128\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs2\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs3\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs4\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs5\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs8\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs10\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs15\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs20\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs25\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs30\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs32\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs35\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs40\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs45\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs50\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs55\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs60\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs64\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs70\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs75\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs80\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs85\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs90\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs100\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs110\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs120\n",
      "-- create_runfolder:./data/method_comparison_dicke2_noise/T5_cross_ntrajs128\n",
      ".  update_runfolder:0\n",
      ".  update_runfolder:1\n",
      ".  update_runfolder:3\n",
      ".  update_runfolder:2\n",
      ".  update_runfolder:4\n",
      ".  update_runfolder:6\n",
      ".  update_runfolder:5\n",
      ".  update_runfolder:8\n",
      ".  update_runfolder:7\n",
      ".  update_runfolder:10\n",
      ".  update_runfolder:13\n",
      ".  update_runfolder:11\n",
      ".  update_runfolder:9\n",
      ".  update_runfolder:12\n",
      ".  update_runfolder:14\n",
      ".  update_runfolder:16\n",
      ".  update_runfolder:15\n",
      ".  update_runfolder:17\n",
      ".  update_runfolder:18\n",
      "-- submit_optimization:2\n",
      "-- submit_optimization:3\n",
      "-- submit_optimization:0\n",
      "-- submit_optimization:4\n",
      "-- submit_optimization:5\n",
      "-- submit_optimization:6\n",
      "-- submit_optimization:9\n",
      "-- submit_optimization:7\n",
      "-- submit_optimization:1\n",
      "-- submit_optimization:8\n",
      "-- submit_optimization:10\n",
      "-- submit_optimization:12\n",
      "-- submit_optimization:11\n",
      "-- submit_optimization:13\n",
      "-- submit_optimization:15\n",
      "-- submit_optimization:16\n",
      ".  update_runfolder:19\n",
      ".  update_runfolder:20\n",
      ".  update_runfolder:21\n",
      ".  update_runfolder:22\n",
      ".  update_runfolder:24\n",
      ".  update_runfolder:23\n",
      ".  update_runfolder:25\n",
      ".  update_runfolder:27\n",
      ".  update_runfolder:26\n",
      ".  update_runfolder:29\n",
      ".  update_runfolder:28\n",
      ".  update_runfolder:30\n",
      ".  update_runfolder:31\n",
      ".  update_runfolder:33\n",
      ".  update_runfolder:32\n",
      ".  update_runfolder:34\n",
      ".  update_runfolder:35\n",
      "-- submit_optimization:14\n",
      "-- submit_optimization:18\n",
      "-- submit_optimization:17\n",
      "-- submit_optimization:19\n",
      "-- submit_optimization:20\n",
      "-- submit_optimization:22\n",
      "-- submit_optimization:21\n",
      "-- submit_optimization:24\n",
      "-- submit_optimization:23\n",
      "-- submit_optimization:27\n",
      "-- submit_optimization:25\n",
      "-- submit_optimization:26\n",
      "-- submit_optimization:29\n",
      "-- submit_optimization:28\n",
      "-- submit_optimization:31\n",
      "-- submit_optimization:30\n",
      ".  update_runfolder:36\n",
      ".  update_runfolder:37\n",
      ".  update_runfolder:38\n",
      ".  update_runfolder:39\n",
      ".  update_runfolder:41\n",
      ".  update_runfolder:40\n",
      ".  update_runfolder:44\n",
      ".  update_runfolder:47\n",
      ".  update_runfolder:42\n",
      ".  update_runfolder:53\n",
      ".  update_runfolder:50\n",
      ".  update_runfolder:51\n",
      ".  update_runfolder:49\n",
      ".  update_runfolder:52\n",
      ".  update_runfolder:54\n",
      ".  update_runfolder:46\n",
      ".  update_runfolder:45\n",
      "-- submit_optimization:33\n",
      "-- submit_optimization:34\n",
      "-- submit_optimization:32\n",
      "-- submit_optimization:35\n",
      "-- submit_optimization:37\n",
      "-- submit_optimization:36\n",
      "-- submit_optimization:38\n",
      "-- submit_optimization:50\n",
      "-- submit_optimization:45\n",
      "-- submit_optimization:41\n",
      "-- submit_optimization:54\n",
      "-- submit_optimization:40\n",
      "-- submit_optimization:39\n",
      "-- submit_optimization:47\n",
      "-- submit_optimization:42\n",
      "-- submit_optimization:51\n",
      ".  update_runfolder:43\n",
      ".  update_runfolder:48\n",
      ".  wait_for_optimization:3\n",
      ".  wait_for_optimization:2\n",
      ".  wait_for_optimization:0\n",
      ".  wait_for_optimization:5\n",
      ".  wait_for_optimization:4\n",
      ".  wait_for_optimization:6\n",
      ".  wait_for_optimization:7\n",
      ".  wait_for_optimization:1\n",
      ".  wait_for_optimization:9\n",
      "-- submit_optimization:53\n",
      "-- submit_optimization:49\n",
      "-- submit_optimization:46\n",
      "-- submit_optimization:52\n",
      "-- submit_optimization:48\n",
      "-- submit_optimization:44\n",
      "-- submit_optimization:43\n",
      ".  wait_for_optimization:10\n",
      ".  wait_for_optimization:12\n",
      ".  wait_for_optimization:11\n",
      ".  wait_for_optimization:8\n",
      ".  wait_for_optimization:15\n",
      ".  wait_for_optimization:16\n",
      ".  wait_for_optimization:13\n",
      ".  wait_for_optimization:18\n",
      ".  wait_for_optimization:14\n",
      ".  wait_for_optimization:20\n",
      ".  wait_for_optimization:17\n",
      ".  wait_for_optimization:22\n",
      ".  wait_for_optimization:21\n",
      ".  wait_for_optimization:19\n",
      ".  wait_for_optimization:24\n",
      ".  wait_for_optimization:23\n",
      ".  wait_for_optimization:27\n",
      ".  wait_for_optimization:25\n",
      ".  wait_for_optimization:26\n",
      ".  wait_for_optimization:29\n",
      ".  wait_for_optimization:28\n",
      ".  wait_for_optimization:31\n",
      ".  wait_for_optimization:30\n",
      ".  wait_for_optimization:33\n",
      ".  wait_for_optimization:32\n",
      ".  wait_for_optimization:34\n",
      ".  wait_for_optimization:37\n",
      ".  wait_for_optimization:35\n",
      ".  wait_for_optimization:36\n",
      ".  wait_for_optimization:38\n",
      ".  wait_for_optimization:50\n",
      ".  wait_for_optimization:45\n",
      ".  wait_for_optimization:54\n",
      ".  wait_for_optimization:40\n",
      ".  wait_for_optimization:39\n",
      ".  wait_for_optimization:41\n",
      ".  wait_for_optimization:47\n",
      ".  wait_for_optimization:42\n",
      ".  wait_for_optimization:51\n",
      ".  wait_for_optimization:49\n",
      ".  wait_for_optimization:46\n",
      ".  wait_for_optimization:52\n",
      ".  wait_for_optimization:48\n",
      ".  wait_for_optimization:53\n",
      ".  wait_for_optimization:44\n",
      ".  wait_for_optimization:43\n"
     ]
    }
   ],
   "source": [
    "%doit -n 40 wait_for_optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-30T04:20:44.974743Z",
     "start_time": "2017-12-30T04:20:44.967508Z"
    },
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.1"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}