Trap Depth Calculation (2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "OLD!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# Trap Depth Calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Mark Brown  \n",
    "Notebook Base Version 1.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:33.126876Z",
     "start_time": "2017-06-17T14:33:33.123871Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "#YearMonthDay\n",
    "date = \"170617\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "## Goals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "This notebook is roughly based on the data notebook from 160908."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# General Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Imports and Settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Miscellaneous Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:38.247314Z",
     "start_time": "2017-06-17T14:33:33.272451Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import array as arr\n",
    "import pandas as pd\n",
    "import collections\n",
    "import math as m\n",
    "from mpl_toolkits.mplot3d import axes3d\n",
    "from astropy.io import fits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:38.912118Z",
     "start_time": "2017-06-17T14:33:38.247314Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import scipy\n",
    "from scipy.optimize import curve_fit as fit\n",
    "import scipy.special as special"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Matplotlib Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:39.092335Z",
     "start_time": "2017-06-17T14:33:38.912118Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "from matplotlib.pyplot import *\n",
    "### set matplotlib plot defaults :D\n",
    "%matplotlib inline\n",
    "# Style controls many default colors in matplotlib plots.\n",
    "# Change the following if you don't like dark backgrounds. Many other options.\n",
    "style.use(['dark_background'])\n",
    "mpl.rcParams['axes.facecolor'] = '#0a0a0a'\n",
    "# the default cycling of colors in this mode isn't very good.\n",
    "mpl.rcParams['axes.prop_cycle'] = cycler('color', ['r','c','g','#FFFFFF','y','m','b'])\n",
    "mpl.rcParams['figure.figsize'] = (18.0, 8.0)\n",
    "mpl.rcParams['axes.grid'] = True\n",
    "mpl.rcParams['axes.formatter.useoffset'] = False\n",
    "mpl.rcParams['grid.alpha'] = 0.3\n",
    "mpl.rcParams['axes.formatter.limits'] = (0,1)\n",
    "# jet is awful.\n",
    "mpl.rcParams['image.cmap'] = 'inferno'\n",
    "# to see all available options, decomment this line.\n",
    "# print(mpl.rcParams)\n",
    "mpl.rcParams['font.size'] = 14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### SymPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.570869Z",
     "start_time": "2017-06-17T14:33:39.092335Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import sympy as sp\n",
    "sp.init_printing(use_latex=True)\n",
    "# see the constants section for some constants set in sympy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "hide_input": false,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Javascript Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.578807Z",
     "start_time": "2017-06-17T14:33:41.570869Z"
    },
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "// the above line makes this entire cell run javascript commands.\n",
       "// this gets rid of scroll bars on the output by default. It's in javascript because javascript is used \n",
       "// by Jupyter to actually render the notebook display.\n",
       "IPython.OutputArea.auto_scroll_threshold = 9999;"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "    %%javascript\n",
    "    // the above line makes this entire cell run javascript commands.\n",
    "    // this gets rid of scroll bars on the output by default. It's in javascript because javascript is used \n",
    "    // by Jupyter to actually render the notebook display.\n",
    "    IPython.OutputArea.auto_scroll_threshold = 9999;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Physics & Math Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:31:50.870539Z",
     "start_time": "2017-06-18T14:31:50.859537Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# all in mks\n",
    "# planck's constant\n",
    "h = 6.6260700e-34\n",
    "# reduced planck's constant\n",
    "hbar = 1.0545718e-34\n",
    "# boltzman's constant\n",
    "k_B = 1.3806488e-23;\n",
    "# speed of light (exact)\n",
    "c = 299792458\n",
    "# Stephan-Boltzman constant\n",
    "sigma = 5.6704e-8\n",
    "# atomic mass unit\n",
    "amu = 1.6605390e-27\n",
    "# rubidium 87 mass\n",
    "Rb87_M = 86.909180527 * amu\n",
    "# use numpy\n",
    "pi = np.pi\n",
    "# gravity constant\n",
    "g = 9.80665\n",
    "\n",
    "# linewidths\n",
    "Rb87_D1Gamma = 36.1e6\n",
    "Rb87_D2Gamma = 38.11e6\n",
    "\n",
    "Rb87_AvgGamma = (Rb87_D1Gamma + Rb87_D2Gamma)/2\n",
    "\n",
    "Rb87_I_Sat = 3.576\n",
    "### should refine... for rubidium 87\n",
    "# in m\n",
    "Rb87_D2LineWavelength = 780e-9\n",
    "# in Hz (1/s)\n",
    "Rb87_D2LineFrequency = 377.1e12\n",
    "# etc.\n",
    "Rb87_D1LineWavelength = 795e-9\n",
    "Rb87_D1LineFrequency = 384.2e12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Lab Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.646868Z",
     "start_time": "2017-06-17T14:33:41.610805Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "andorDataRepository = \"\\\\\\\\andor\\\\share\\\\Data and documents\\\\Data repository\\\\\"\n",
    "rawDataLoc = date + \"\\\\Raw Data\\\\\"\n",
    "\n",
    "opBeamDacToVoltageConversionConstants = [8.5, -22.532, -1.9323, -0.35142]\n",
    "# 7.4 x 7.4 micron mixel size\n",
    "baslerScoutCcdPixelSize = 7.4e-6\n",
    "# baslerAceCMosPixelSize = ???\n",
    "# 16 micron pixels\n",
    "andorPixelSize = 16e-6\n",
    "\n",
    "dataRayPixelSize = 4.4e-6\n",
    "\n",
    "### basler conversion... joules incident per greyscale count.\n",
    "# number from theory of camera operation\n",
    "cameraConversion = 117*10**-18 \n",
    "# number from measurement. I suspect this is a little high because I think I underestimated the attenuation \n",
    "# of the signal by the 780nm filter.\n",
    "# C = 161*10**-18 \n",
    "\n",
    "# note: I don't know what the limiting aperture is, but I believe that it's a bit larger than either of these. \n",
    "# This parameter could probably be extracted from zeemax calculations.\n",
    "# (in meters)\n",
    "sillLensInputApertureDiameter = 40e-3\n",
    "sillLensExitApertureDiameter = 40e-3\n",
    "\n",
    "# need to look these up.\n",
    "# tweezerBeamGaussianWaist = 4\n",
    "# probeBeamGaussianWaist = ???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Lab Volatile Constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Constants that can easily change day to day depending on drifts, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.678878Z",
     "start_time": "2017-06-17T14:33:41.646868Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# Calibration of length (in meters) that atoms in the cell move vs pixels that the atoms move.\n",
    "# this changes when the imaging system for the basler changes. there's a notebook for calculating this. \n",
    "baslerMetersPer4x4Pixel = 61.7818944758e-6\n",
    "baslerMetersPerPixel = baslerMetersPer4x4Pixel / 4\n",
    "\n",
    "### TODO: normalize these units to my standard units...\n",
    "\n",
    "# in mW\n",
    "sidemotPower = 0.75\n",
    "# in mW\n",
    "diagonalMPower = 9.3\n",
    "# in cm\n",
    "motRadius = 5 * baslerMetersPer4x4Pixel * 100\n",
    "# in hertz\n",
    "imagingDetuning = 10*10**6\n",
    "\n",
    "baslerRawGain = 260\n",
    "\n",
    "# in cm\n",
    "axialImagingLensDiameter = 2.54\n",
    "# in cm\n",
    "axialImagingLensFocalLength = 10\n",
    "\n",
    "# these obviously focus when we change iris diameters.\n",
    "tweezerBeamApertureDiameter = 1.2*25.4e-3\n",
    "probeBeamApertureDiameter = 25.4e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.706870Z",
     "start_time": "2017-06-17T14:33:41.678878Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# Calibration of length (in meters) that atoms in the cell move vs pixels that the atoms move.\n",
    "# this changes when the imaging system for the basler changes. there's a notebook for calculating this. \n",
    "baslerMetersPer4x4Pixel = 61.7818944758e-6\n",
    "baslerMetersPerPixel = baslerMetersPer4x4Pixel / 4\n",
    "\n",
    "### TODO: normalize these units to my standard units...\n",
    "\n",
    "# in mW\n",
    "sidemotPower = 0.75\n",
    "# in mW\n",
    "diagonalMPower = 9.3\n",
    "# in cm\n",
    "motRadius = 5 * baslerMetersPer4x4Pixel * 100\n",
    "# in hertz\n",
    "imagingDetuning = 10*10**6\n",
    "\n",
    "baslerRawGain = 260\n",
    "\n",
    "# in cm\n",
    "axialImagingLensDiameter = 2.54\n",
    "# in cm\n",
    "axialImagingLensFocalLength = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Sympy Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.737906Z",
     "start_time": "2017-06-17T14:33:41.718878Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# Pauli Matrices\n",
    "X = sigma_x = sp.Matrix([[0,1],[1,0]])\n",
    "Y = sigma_y = sp.Matrix([[0,-1j],[1j,0]])\n",
    "Z = sigma_z = sp.Matrix([[1,0],[0,-1]])\n",
    "# Hadamard\n",
    "H = hadamard = sp.Matrix([[1,1],[1,-1]])\n",
    "# Phase Gate\n",
    "S = phaseGate = sp.Matrix([[1,0],[0,1j]])\n",
    "# Phase Shift gate\n",
    "def phaseShiftGate(phi):\n",
    "    return sp.Matrix([[1,0],[[0,sp.exp(1j*phi)]]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Random Useful Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.786930Z",
     "start_time": "2017-06-17T14:33:41.746932Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def what(obj, callingLocals=locals()):\n",
    "    \"\"\"\n",
    "        quick function to print name of input and value. \n",
    "        If not for the default-Valued callingLocals, the function would always\n",
    "        get the name as \"obj\", which is not what I want.    \n",
    "    \"\"\"\n",
    "    name = \"name not found\"\n",
    "    for k, v in list(callingLocals.items()):\n",
    "         if v is obj:\n",
    "            name = k\n",
    "    print(name,\"=\", obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.806926Z",
     "start_time": "2017-06-17T14:33:41.790925Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def round_sig(x, sig=3):\n",
    "    return round(x, sig-int(m.floor(m.log10(abs(x)+np.finfo(float).eps)))-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Generic functions for fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.910755Z",
     "start_time": "2017-06-17T14:33:41.806926Z"
    },
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def linear(x, a, b):\n",
    "    return a * x + b\n",
    "    \n",
    "def quadraticDip(x,a,b,x0):\n",
    "    # This assumes downward facing. Best to write another function for upward facing if need be, I think.\n",
    "    if a < 0:\n",
    "        return 10**10\n",
    "    if b < 0:\n",
    "        return 10**10\n",
    "    return a + b*(x-x0)**2    \n",
    "    \n",
    "def quadraticBump(x,a,b,x0):\n",
    "    # This assumes downward facing. Best to write another function for upward facing if need be, I think.\n",
    "    if a < 0:\n",
    "        return 10**10\n",
    "    if b > 0:\n",
    "        return 10**10\n",
    "    return a + b*(x-x0)**2\n",
    "\n",
    "\n",
    "def gaussian(x, A1, x01, sig1, offset):\n",
    "    if (offset < 0):\n",
    "        return 10**10\n",
    "    return offset + A1 * np.exp(-(x-x01)**2/(2*sig1**2))\n",
    "\n",
    "\n",
    "def doubleGaussian(x, A1, x01, sig1, A2, x02, sig2, offset):\n",
    "    if (A1 < 0 or A2 < 0):\n",
    "        # Penalize negative fits.\n",
    "        return 10**10\n",
    "    if (offset < 0):\n",
    "        return 10**10\n",
    "    return offset + A1 * np.exp(-(x-x01)**2/(2*sig1**2)) + A2 * np.exp(-(x-x02)**2/(2*sig2**2))\n",
    "\n",
    "def tripleGaussian(x, A1, x01, sig1, A2, x02, sig2, A3, x03, sig3, offset ):\n",
    "    if (A1 < 0 or A2 < 0 or A3 < 0):\n",
    "        # Penalize negative fits.\n",
    "        return 10**10\n",
    "    if (offset < 0):\n",
    "        return 10**10\n",
    "    return (offset + A1 * np.exp(-(x-x01)**2/(2*sig1**2)) + A2 * np.exp(-(x-x02)**2/(2*sig2**2)) \n",
    "            + A3 * np.exp(-(x-x03)**2/(2*sig3**2)))\n",
    "\n",
    "# Stolen from \"http://stackoverflow.com/questions/21566379/fitting-a-2d-gaussian\n",
    "#-function-using-scipy-optimize-curve-fit-valueerror-and-m\"\n",
    "def gaussian_2D(coordinates, amplitude, xo, yo, sigma_x, sigma_y, theta, offset):\n",
    "    # limit the angle to a small range to prevent unncecessary flips of the axes. The 2D gaussian has two axes of symmetry,\n",
    "    # so only a quarter of the 2pi is needed.\n",
    "    if theta > pi/4 or theta < -pi/4:\n",
    "        return 10e10\n",
    "    x = coordinates[0]\n",
    "    y = coordinates[1]\n",
    "    xo = float(xo)\n",
    "    yo = float(yo)    \n",
    "    a = (np.cos(theta)**2)/(2*sigma_x**2) + (np.sin(theta)**2)/(2*sigma_y**2)\n",
    "    b = -(np.sin(2*theta))/(4*sigma_x**2) + (np.sin(2*theta))/(4*sigma_y**2)\n",
    "    c = (np.sin(theta)**2)/(2*sigma_x**2) + (np.cos(theta)**2)/(2*sigma_y**2)\n",
    "    g = offset + amplitude*np.exp( - (a*((x-xo)**2) + 2*b*(x-xo)*(y-yo) + c*((y-yo)**2)))\n",
    "    return g.ravel()\n",
    "\n",
    "def decayingCos(x, A, tau, f, phi, offset):\n",
    "    # Just for sanity. Keep some numbers positive.\n",
    "    if (A < 0):\n",
    "        return x * 10**10\n",
    "    if (phi < 0):\n",
    "        return x * 10**10\n",
    "    if (offset < 0):\n",
    "        return x * 10**10\n",
    "    # no growing fits.\n",
    "    if (tau > 0):\n",
    "        return x * 10**10\n",
    "    return offset + (1 - A/2 * np.exp(-x/tau) * np.cos(2 * np.pi * f * x + phi))\n",
    "\n",
    "def sincSquared(x, A, center, scale, offset):\n",
    "    if (offset < 0):\n",
    "        return x * 10**10\n",
    "    if (A < 0):\n",
    "        return x * 10**10\n",
    "    return (A * np.sinc((x - center)/scale)**2 + offset)\n",
    "\n",
    "\n",
    "def lorentzian(x, A, center, width, offset):\n",
    "    if (offset < 0):\n",
    "        return x * 10**10\n",
    "    if (A < 0):\n",
    "        return x * 10**10\n",
    "    return (A /((x - center)**2 + (width/2)**2))\n",
    "\n",
    "\n",
    "def poissonian(x, k, weight):    \n",
    "    \"\"\"\n",
    "    This function calculates p_k{x} = weight * e^(-k) * k^x / x!.\n",
    "    :param x: argument of the poissonian\n",
    "    :param k: order or (approximate) mean of the poissonian.\n",
    "    :param weight: a weight factor, related to the maximum data this is supposed to be fitted to, but typically over-\n",
    "    weighted for the purposes of this function.\n",
    "    :return: the poissonian evaluated at x given the parametes.\n",
    "    \"\"\"\n",
    "    import numpy as np\n",
    "    term = 1\n",
    "    # calculate the term k^x / x!. Can't do this directly, x! is too large.\n",
    "    for n in range(0, int(x)):\n",
    "        term *= k / (x - n)\n",
    "    return np.exp(-k) * term * weight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# Data Analysis Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "This section can be safely removed if not doing data analysis, e.g. if just doing some other calculation or some numerical work or something."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Miscellaneous Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Random Useful Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.926762Z",
     "start_time": "2017-06-17T14:33:41.910755Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def orderData(data, key):\n",
    "    key, data = zip(*sorted(zip(key, data)))\n",
    "    return arr(data), arr(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.946517Z",
     "start_time": "2017-06-17T14:33:41.928774Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def getLabels(plotType):\n",
    "    if plotType == \"Detuning\":\n",
    "        xlabel = \"Detuning (dac value)\"\n",
    "        title = \"Detuning Scan\"\n",
    "    elif plotType == \"Field\":\n",
    "        xlabel = \"Differential Field Change / 2 (dac value)\"\n",
    "        title = \"Differential Magnetic Field Scan\"\n",
    "    elif plotType == \"Time(ms)\":\n",
    "        xlabel =\"Time(ms)\"\n",
    "        title = \"Time Scan\"\n",
    "    elif plotType == \"Power\":\n",
    "        xlabel =\"Power (dac units)\"\n",
    "        title = \"Power Scan\"\n",
    "    else:\n",
    "        xlabel = plotType\n",
    "        title = \"\"\n",
    "    return xlabel, title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:41.970518Z",
     "start_time": "2017-06-17T14:33:41.954510Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def combineData(data, key):\n",
    "    \"\"\"\n",
    "    combines similar key value data entries. data will be in order that unique key items appear in key. \n",
    "    For example, if key = [1,3,5,3,7,1], returned key and corresponding data will be newKey = [1, 3, 5, 7]\n",
    "    \"\"\"\n",
    "    items = {}\n",
    "    newKey = []\n",
    "    newData = []\n",
    "    for elem in key:\n",
    "        #print(elem)\n",
    "        if str(elem) not in items:\n",
    "            indexes = [i for i, x in enumerate(key) if x == elem]\n",
    "            # don't get it again\n",
    "            items[str(elem)] = \"!\"\n",
    "            newKey.append(elem)\n",
    "            newItem = np.zeros((data.shape[1], data.shape[2]))\n",
    "            # average together the corresponding data.\n",
    "            for index in indexes:\n",
    "                newItem += data[index]\n",
    "            newItem /= len(indexes)\n",
    "            newData.append(newItem)\n",
    "    return arr(newData), arr(newKey)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-03-31T10:55:52.589000Z",
     "start_time": "2017-03-31T10:55:52.579474"
    },
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Loading Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.010509Z",
     "start_time": "2017-06-17T14:33:41.982510Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def loadDataRay(num):\n",
    "    fileName = andorDataRepository + rawDataLoc + \"dataRay_\" + str(num) + \".wct\"\n",
    "    file = pd.read_csv(fileName, header=None, skiprows=[0,1,2,3,4])\n",
    "    data = file.as_matrix()\n",
    "    for row in data:\n",
    "        row[-1] = float(row[-1][:-2])\n",
    "        for elem in row:\n",
    "            elem = float(elem)\n",
    "    return data.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.041065Z",
     "start_time": "2017-06-17T14:33:42.014510Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def loadBasler(num):\n",
    "    path = andorDataRepository + rawDataLoc + \"Run\" + str(num) + \".txt\"\n",
    "    return pd.read_csv(path, sep='\\t', header=None).as_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.098680Z",
     "start_time": "2017-06-17T14:33:42.044077Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def loadCompoundBasler(num):\n",
    "    path = andorDataRepository + rawDataLoc + \"AceData_\" + str(num) + \".txt\"\n",
    "    with open(path) as file:\n",
    "        original=file.read()\n",
    "        pics = original.split(\";\")\n",
    "        dummy = os.linesep.join([s for s in pics[0].splitlines() if s]);\n",
    "        dummy2 = dummy.split('\\n')\n",
    "        dummy2[0] = dummy2[0].replace(' \\r','')\n",
    "        data = np.zeros((len(pics), len(dummy2), len(arr(dummy2[0].split(' ')))))\n",
    "        picInc = 0\n",
    "        for pic in pics:\n",
    "            # remove extra empty lines\n",
    "            pic = os.linesep.join([s for s in pic.splitlines() if s])\n",
    "            lines = pic.split('\\n')\n",
    "            lineInc = 0\n",
    "            for line in lines:\n",
    "                line = line.replace(' \\r','')\n",
    "                picLine = arr(line.split(' '))\n",
    "                picLine = arr(list(filter(None, picLine)))\n",
    "                data[picInc][lineInc] = picLine\n",
    "\n",
    "                lineInc += 1\n",
    "            picInc+=1\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.118684Z",
     "start_time": "2017-06-17T14:33:42.098680Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def loadFits(num):\n",
    "    # Get the array from the fits file. That's all I care about.\n",
    "    path = andorDataRepository + rawDataLoc + \"data_\" + str(num) + \".fits\"\n",
    "    with fits.open(path, \"append\") as fitsInfo:\n",
    "        rawData = arr(fitsInfo[0].data);\n",
    "    return rawData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.141211Z",
     "start_time": "2017-06-17T14:33:42.122679Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def loadKey(num):\n",
    "    key = np.array([]);\n",
    "    path = andorDataRepository + rawDataLoc + \"key_\" + str(num) + \".txt\"\n",
    "    with open(path) as keyFile:\n",
    "        for line in keyFile:\n",
    "            key = np.append(key, float(line.strip('\\n')))\n",
    "        keyFile.close()            \n",
    "    return key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Specialty functions for fits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Coming from various theoretical calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.158755Z",
     "start_time": "2017-06-17T14:33:42.142712Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def ballisticMotExpansion(t, sigma_y0, sigma_vy, sigma_I):\n",
    "    \"\"\"\n",
    "    You can see a derivation of this in a different notebook for temperature calculations. I don't know why, but\n",
    "    this function seems somewhat unstable as a fitting function. It doesn't always work very sensibly.\n",
    "    \"\"\"\n",
    "    return sigma_I*np.sqrt((sigma_y0**2 + sigma_vy**2 * t**2)/(sigma_y0**2+sigma_vy**2*t**2+sigma_I**2))\n",
    "\n",
    "def simpleMotExpansion(t, sigma_y0, sigma_vy):\n",
    "    \"\"\"\n",
    "    For some reason calculations involving this tend to be wildly off... I need to look into this more the next time \n",
    "    I need to calculate a temperature.\n",
    "    \n",
    "    this simpler version ignores the size of the beam waist of the atoms. \n",
    "    It should generally behave better with noisy data.    \n",
    "    \"\"\"\n",
    "    return sigma_y0 + sigma_vy * t\n",
    "\n",
    "def beamWaistExpansion(z, w0, z0, wavelength):\n",
    "    \"\"\" assuming gaussian intensity profile of I~exp{-2z^2/w{z}^2} \"\"\"\n",
    "    return w0 * np.sqrt(1+(wavelength*(z-z0)/(pi*w0**2))**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Fitting Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Functions that take data as an input and implement some standardized techniques to guess parameters and\n",
    "to try to fit the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.234287Z",
     "start_time": "2017-06-17T14:33:42.158755Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def fitPic(picture, show=True, guessSigma_x=1, guessSigma_y=1):\n",
    "    pos = np.unravel_index(np.argmax(picture), picture.shape)\n",
    "    pic = picture.flatten()\n",
    "    x = np.linspace(1, picture.shape[1], picture.shape[1])\n",
    "    y = np.linspace(1, picture.shape[0], picture.shape[0])\n",
    "    x, y = np.meshgrid(x, y)\n",
    "    initial_guess = (np.max(pic) - np.min(pic),pos[1], pos[0],guessSigma_x,guessSigma_y,0,np.min(pic))\n",
    "    try:        \n",
    "        popt, pcov = fit(gaussian_2D, (x, y), pic, p0=initial_guess);\n",
    "    except RuntimeError:\n",
    "        popt = np.zeros(len(initial_guess))\n",
    "        pcov = np.zeros((len(initial_guess), len(initial_guess)))\n",
    "        raise RuntimeError('Fit Failed!')\n",
    "    if show:\n",
    "        data_fitted = gaussian_2D((x, y), *popt)\n",
    "        fig, ax = subplots(1, 1)\n",
    "        grid('off')\n",
    "        im = ax.pcolormesh(picture, extent=(x.min(), x.max(), y.min(), y.max()))\n",
    "        ax.contour(x, y, data_fitted.reshape(picture.shape[0],picture.shape[1]), 4, colors='w', alpha=0.2)\n",
    "        fig.colorbar(im)\n",
    "    return popt, np.sqrt(np.diag(pcov))\n",
    "\n",
    "\n",
    "def fitPictures(pictures, dataRange, show=True):\n",
    "    fitParameters = []\n",
    "    fitErrors = []\n",
    "    count = 0\n",
    "    warningHasBeenThrown = False\n",
    "    for picture in pictures:\n",
    "        if count not in dataRange:\n",
    "            count += 1\n",
    "            fitParameters.append(np.zeros(7))\n",
    "            fitErrors.append(np.zeros(7))\n",
    "        try:\n",
    "            parameters, errors = fitPic(picture, show=False)\n",
    "        except RuntimeError:\n",
    "            if not warningHasBeenThrown:\n",
    "                print(\"Warning! Not all picture fits were able to fit the picture signal to a 2D Gaussian.\\n\"\n",
    "                      \"When the fit fails, the fit parameters are all set to zero.\")\n",
    "                warningHasBeenThrown = True\n",
    "            parameters = np.zeros(7)\n",
    "            errors = np.zeros(7)\n",
    "        # append things regardless of whether the fit succeeds or not in order to keep things the right length.\n",
    "        fitParameters.append(parameters)\n",
    "        fitErrors.append(errors)\n",
    "        count += 1\n",
    "    return np.array(fitParameters), np.array(fitErrors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.267323Z",
     "start_time": "2017-06-17T14:33:42.243313Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def fitGaussianBeamWaist(data, key, wavelength):\n",
    "    # expects waists as inputs\n",
    "    initial_guess = [min(data.flatten()), key[int(3*len(key)/4)]]\n",
    "    what(initial_guess)\n",
    "    try:        \n",
    "        # fix the wavelength\n",
    "        # beamWaistExpansion(z, w0, wavelength)\n",
    "        popt, pcov = fit(lambda x, a, b: beamWaistExpansion(x, a, b, wavelength), key, data, p0=initial_guess)\n",
    "    except RuntimeError:\n",
    "        popt = 0\n",
    "        pcov = 0\n",
    "        raise RuntimeError('Fit Failed!')\n",
    "    return popt, pcov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "Collapsed": "false",
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Data Analysis & Plotters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Plotters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.519472Z",
     "start_time": "2017-06-17T14:33:42.271342Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def plotPoints(key, majorPlot, minorPlot={}, circleLoc=(-1,-1), picture = arr([[]]), picTitle=\"\"):\n",
    "    \"\"\"\n",
    "    This plotter plots a scatter plot on the main axis from majorPlot,\n",
    "    a scatter on the minor axis using minorPlot, and a picture using picture.\n",
    "    \n",
    "    Parameters:\n",
    "    key: this is used for the x values of both the major plot and the minor plot.\n",
    "    majorPlot: a dictionary with the following elements containing info for the main plot of the figure (REQUIRED):\n",
    "        - \"ax1\": A dictionary containing info for plotting on the first axis (main axis) \n",
    "            with the following elements (REQUIRED):\n",
    "            - \"data\": a 1 or 2-dimensional array with data to be plotted with key (REQUIRED)\n",
    "            - \"ylabel\": label for axis 1 (on the left)\n",
    "            - \"legendLabels\": an array with labels for each data set\n",
    "        - \"ax2\": An optional dictionary containing info for plotting on the second axis, elements similar to ax1\n",
    "        - \"xlabel\": label for the x axis\n",
    "        - \"title\": title\n",
    "        - \"altKey\": another key to plot on the other x-axis (above the plot).\n",
    "    minorPlot: a dictionary with info for the minor plot. Same structure as majorPlotData, but optional.    \n",
    "    \"\"\"\n",
    "    # Setup grid\n",
    "    figure()\n",
    "    grid1 = mpl.gridspec.GridSpec(12, 16)\n",
    "    grid1.update(left=0.05, right=0.95, wspace=1.2, hspace=1000)   \n",
    "    # ### Main Plot\n",
    "    fillPlotDataDefaults(majorPlot)\n",
    "    majorAx1 = subplot(grid1[:, :11])\n",
    "    colors = ['r','c','g','#FFFFFF','y','m','b']\n",
    "    majorLineCount = 0\n",
    "    lines = []\n",
    "    if majorPlot['ax1']['data'].ndim == 1:\n",
    "        lines += majorAx1.plot(key, majorPlot['ax1']['data'], 'o', label=majorPlot['ax1']['legendLabels'], \n",
    "                               color=colors[majorLineCount])\n",
    "        majorLineCount += 1\n",
    "    else:\n",
    "        for data in majorPlot['ax1']['data']:\n",
    "            lines += majorAx1.plot(key, data, 'o', label=majorPlot['ax1']['legendLabels'][majorLineCount], \n",
    "                                   color=colors[majorLineCount])\n",
    "            majorLineCount += 1\n",
    "    if 'fitYData' in majorPlot['ax1']:\n",
    "        for fitCount in range(len(majorPlot['ax1']['fitYData'])):\n",
    "            lines += majorAx1.plot(majorPlot['ax1']['fitXData'][fitCount], majorPlot['ax1']['fitYData'][fitCount], \n",
    "                                   label=majorPlot['ax1']['legendLabels'][majorLineCount], color=colors[fitCount])\n",
    "            majorLineCount += 1\n",
    "        \n",
    "    majorAx1.set_ylabel(majorPlot['ax1']['ylabel'])\n",
    "    majorAx1.grid(which='both', color='#FFFFFF')\n",
    "    \n",
    "    if 'ax2' in majorPlot:\n",
    "        majorAx2 = majorAx1.twinx()\n",
    "        if majorPlot['ax1']['data'].ndim == 1:\n",
    "            lines += majorAx2.plot(key, majorPlot['ax2']['data'], 'o', label=majorPlot['ax2']['legendLabels'], \n",
    "                                   color=colors[majorLineCount])\n",
    "            majorLineCount += 1\n",
    "        else:\n",
    "            count = 0\n",
    "            for data in majorPlot['ax2']['data']:\n",
    "                lines += majorAx2.plot(key, data, 'o', label=majorPlot['ax2']['legendLabels'][count],\n",
    "                                       color=colors[majorLineCount])\n",
    "                count += 1\n",
    "                majorLineCount += 1\n",
    "        majorAx2.set_ylabel(majorPlot['ax2']['ylabel'])\n",
    "        majorAx2.spines['right'].set_color('m')\n",
    "        majorAx2.spines['top'].set_color('m')\n",
    "        majorAx2.yaxis.label.set_color('m')\n",
    "        majorAx2.tick_params(axis='y', colors='m')\n",
    "        #majorAx2.grid(color='m')\n",
    "        majorAx2.grid(which='both', color='m')\n",
    "        #majorAx2.set_yticklabels([round_sig(tick) for tick in arr(majorAx2.get_yticks().tolist())], rotation=70)\n",
    "    \n",
    "    majorAx1.legend(lines, [l.get_label() for l in lines], loc='best', fancybox=True, framealpha=0.4)\n",
    "    majorAx1.set_xlabel(majorPlot['xlabel'])\n",
    "    majorAx1.set_title(majorPlot['title'])\n",
    "\n",
    "    #todo, maybe modify this if I want to use it in the future.\n",
    "    if 'majorAltKey' in majorPlot:\n",
    "        ax2 = majorAx1.twiny()\n",
    "        ticks = majorAx1.get_xticks()\n",
    "        ax2.plot(majorPlot['majorAltKey'], majorPlot['ax1']['data'], 'o')\n",
    "        ax2.grid(color='c')\n",
    "        ax2.spines['top'].set_color('c')\n",
    "        ax2.xaxis.label.set_color('c')\n",
    "        ax2.tick_params(axis='x', colors='c')\n",
    "        ax2.set_xlabel(\"DAC Values\")\n",
    "        ax2.set_xlim(reversed(ax2.get_xlim()))\n",
    "    \n",
    "    # Minor Data Plot\n",
    "    lines = []\n",
    "    if 'ax1' in minorPlot:\n",
    "        fillPlotDataDefaults(minorPlot)\n",
    "        minorAx1 = subplot(grid1[0:6, 12:16])\n",
    "        minorLineCount = 0\n",
    "        if minorPlot['ax1']['data'].ndim == 1:\n",
    "            lines += minorAx1.plot(key, minorPlot['ax1']['data'], 'o', label=minorPlot['ax1']['legendLabels'],\n",
    "                                   color=colors[minorLineCount])\n",
    "            minorLineCount += 1\n",
    "        else:\n",
    "            count = 0\n",
    "            for data in minorPlot['ax1']['data']:\n",
    "                lines += minorAx1.plot(key, data, 'o', label=minorPlot['ax1']['legendLabels'][count], \n",
    "                                       color=colors[minorLineCount])\n",
    "                count += 1\n",
    "                minorLineCount += 1\n",
    "        minorAx1.set_ylabel(minorPlot['ax1']['ylabel'])\n",
    "        \n",
    "        if 'ax2' in minorPlot:\n",
    "            minorAx2 = twinx(minorAx1)\n",
    "            if minorPlot['ax1']['data'].ndim == 1:\n",
    "                lines += minorAx2.plot(key, minorPlot['ax2']['data'], 'o', label=minorPlot['ax2']['legendLabels'],\n",
    "                                       color=colors[minorLineCount])\n",
    "                minorLineCount += 1\n",
    "            else:\n",
    "                count = 0\n",
    "                for data in minorPlot['ax2']['data']:\n",
    "                    lines += minorAx2.plot(key, data, 'o', label=minorPlot['ax2']['legendLabels'][count], \n",
    "                                           color=colors[minorLineCount], alpha=0.4)\n",
    "                    count += 1\n",
    "                    minorLineCount += 1\n",
    "            minorAx2.set_ylabel(minorPlot['ax2']['ylabel'])\n",
    "            minorAx2.spines['right'].set_color('m')\n",
    "            minorAx2.spines['top'].set_color('m')\n",
    "            minorAx2.yaxis.label.set_color('m')\n",
    "            minorAx2.tick_params(axis='y', colors='m')\n",
    "            minorAx2.grid(color='m')\n",
    "        minorAx1.legend(lines, [l.get_label() for l in lines], loc='best', fancybox=True, framealpha=0.4)\n",
    "        minorAx1.set_xlabel(minorPlot['xlabel'])\n",
    "        minorAx1.set_title(minorPlot['title'])\n",
    "        \n",
    "    # Image\n",
    "    if picture.size!=0:\n",
    "        image = subplot(grid1[7:12, 12:16])\n",
    "        im = image.pcolormesh(picture)\n",
    "        image.grid(0)\n",
    "        image.axis('off')\n",
    "        image.set_title(picTitle)\n",
    "        colorbar(im, ax=image)\n",
    "        if (circleLoc!=(-1,-1)):\n",
    "            circ = Circle(circleLoc, 0.2, color='r')\n",
    "            image.add_artist(circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.551528Z",
     "start_time": "2017-06-17T14:33:42.519472Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def plotHist(picture, data, xLabel=\"?\", circLoc=(-1,-1), plotTitle='Histogram Data', binCount=100):\n",
    "    # Setup grid\n",
    "    grid1 = mpl.gridspec.GridSpec(12, 16)\n",
    "    grid1.update(left=0.05, right=0.95, wspace=1.2, hspace=1000)\n",
    "    gridLeft = mpl.gridspec.GridSpec(12, 16)\n",
    "    gridLeft.update(left=0.001, right=0.95, hspace=1000)\n",
    "    gridRight = mpl.gridspec.GridSpec(12, 16)\n",
    "    gridRight.update(left=0.2, right=0.946, wspace=0, hspace=1000)\n",
    "    # ### Main Plot\n",
    "    mainPlot = subplot(grid1[:, :12])\n",
    "    # the bins should be of integer width, because poisson is an integer distribution\n",
    "    mainPlot.hist(data, bins=binCount)\n",
    "    mainPlot.set_xlabel(xLabel)\n",
    "    mainPlot.set_ylabel('Occurances')\n",
    "    title(plotTitle)\n",
    "    image = subplot(grid1[6:12, 12:16])\n",
    "    im = image.imshow(picture)\n",
    "    image.grid(0)\n",
    "    image.axis('off')\n",
    "    colorbar(im, ax=image);\n",
    "    if (circLoc!=(-1,-1)):\n",
    "        circ = Circle(circLoc, 0.2, color='r')\n",
    "        image.add_artist(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Crunchers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.567534Z",
     "start_time": "2017-06-17T14:33:42.551528Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def integrateData(pictures):\n",
    "    if len(pictures.shape) == 3:\n",
    "        integratedData=np.zeros(pictures.shape[0])\n",
    "        picNum=0\n",
    "        for pic in pictures:\n",
    "            for row in pic:\n",
    "                for elem in row:\n",
    "                    integratedData[picNum] += elem\n",
    "            picNum+=1\n",
    "    else:\n",
    "        integratedData=0\n",
    "        for row in pictures:\n",
    "            for elem in row:\n",
    "                integratedData += elem\n",
    "    return integratedData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.651665Z",
     "start_time": "2017-06-17T14:33:42.575529Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def processImageData(key, rawData, bg, window, xMin, xMax, yMin, yMax, accumulations, dataRange, zeroCorners):\n",
    "    \"\"\"\n",
    "    Process the orignal data, giving back data that has been ordered and windowed as well as two other versions that \n",
    "    have either the background or the average of the pictures subtracted out.\n",
    "    \n",
    "    This is a helper function that is expected to be embedded in a package. As such, many parameters are simply \n",
    "    passed through some other function in order to reach this function, and all parameters are required.\n",
    "    \"\"\"\n",
    "    # normalize for accumulations\n",
    "    accumulationNormalizedData = rawData / accumulations\n",
    "    # handle windowing defaults\n",
    "    if window != (0,0,0,0):\n",
    "        xMin = window[0]\n",
    "        xMax = window[1]\n",
    "        yMin = window[2]\n",
    "        yMax = window[3]\n",
    "    else:\n",
    "        if xMax == 0:\n",
    "            xMax = len(rawData[0])\n",
    "        if yMax == 0:\n",
    "            yMax = len(rawData[0][0])        \n",
    "    # combine and order data.\n",
    "    rawData, key = combineData(rawData, key)\n",
    "    rawData, key = orderData(rawData, key)\n",
    "    \n",
    "    # window images.\n",
    "    rawData = np.copy(arr(rawData[:,yMin:yMax, xMin:xMax]))\n",
    "    # pull out the images to be used for analysis.\n",
    "    if not dataRange == (0,0):\n",
    "        rawData = rawData[dataRange[0]:dataRange[-1]]\n",
    "        key = key[dataRange[0]:dataRange[-1]]\n",
    "    \n",
    "    # ### -Background Analysis\n",
    "    # if user just entered a number, assume that it's a file number.\n",
    "    if type(bg) == int and not bg == 0:\n",
    "        bg = loadFits(bg)[0] / accumulations\n",
    "    # window the background\n",
    "    if not bg.size == 1:\n",
    "        bg = np.copy(arr(bg[yMin:yMax, xMin:xMax]))\n",
    "    dataMinusBg = np.copy(rawData)\n",
    "    for pic in dataMinusBg:\n",
    "        pic -= bg\n",
    "    # ### -Average Analysis\n",
    "    # make a picture which is an average of all pictures over the run.\n",
    "    avgPic = 0;\n",
    "    for pic in rawData:\n",
    "        avgPic += pic\n",
    "    avgPic /= len(rawData)\n",
    "    \n",
    "    dataMinusAvg = np.copy(rawData)\n",
    "    for pic in dataMinusAvg:\n",
    "        pic -= avgPic\n",
    "    \n",
    "    # it's important and consequential that the zeroing here is done after the background / corner is subtracted.\n",
    "    if zeroCorners:\n",
    "        for pic in dataMinusBg:\n",
    "            cornerAvg = (pic[0,0] + pic[0,-1] + pic[-1, 0] + pic[-1,-1])/4     \n",
    "            pic -= cornerAvg\n",
    "        for pic in dataMinusAvg:\n",
    "            cornerAvg = (pic[0,0] + pic[0,-1] + pic[-1, 0] + pic[-1,-1])/4     \n",
    "            pic -= cornerAvg\n",
    "        for pic in rawData:\n",
    "            cornerAvg = (pic[0,0] + pic[0,-1] + pic[-1, 0] + pic[-1,-1])/4     \n",
    "            pic -= cornerAvg\n",
    "    \n",
    "    return key, rawData, dataMinusBg, dataMinusAvg, avgPic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.679619Z",
     "start_time": "2017-06-17T14:33:42.651665Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def fillPlotDataDefaults(plotData):\n",
    "    if 'ax1' not in plotData:\n",
    "        raise RuntimeError('plot data must have ax1 defined!')\n",
    "    else:\n",
    "        if 'data' not in plotData['ax1']:\n",
    "            raise RuntimeError('ax1 of plot data must contain data!')        \n",
    "        if 'ylabel' not in plotData['ax1']:\n",
    "            plotData['ax1']['ylabel'] = ''\n",
    "        if 'legendLabels' not in plotData['ax1']:\n",
    "            if plotData['ax1']['data'].ndim == 2:\n",
    "                # create empty labels\n",
    "                plotData['ax1']['legendLabels'] = ['' for x in range(plotData['ax1']['data'].shape[0])]\n",
    "            else:\n",
    "                plotData['ax1']['legendLabels'] = ''\n",
    "    if 'ax2' in plotData:\n",
    "        if 'data' not in plotData['ax2']:\n",
    "            raise RuntimeError('if ax2 is defined, it must contain data!')\n",
    "        if 'ylabel' not in plotData['ax2']:\n",
    "            plotData['ax2']['ylabel'] = ''\n",
    "        if 'legendLabels' not in plotData['ax2']:\n",
    "            if plotData['ax2']['data'].ndim == 2:\n",
    "                # create empty labels\n",
    "                plotData['ax2']['legendLabels'] = ['' for x in range(plotData['ax2']['data'].shape[0])]\n",
    "            else:\n",
    "                plotData['ax2']['legendLabels'] = ''\n",
    "    if 'xlabel' not in plotData:\n",
    "        plotData['xlabel']=\"\"\n",
    "    if 'title' not in plotData:\n",
    "        plotData['title']=\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.787659Z",
     "start_time": "2017-06-17T14:33:42.679619Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def assemblePlotData(rawData, dataMinusBg, dataMinusAverage, positions, waists, plottedData, scanType, \n",
    "                     xLabel, title, location, waistFits=[], key=[]):\n",
    "    \"\"\"\n",
    "    take the data and organize it into the appropriate structures.\n",
    "    \n",
    "    returns: countData, fitData\n",
    "    \"\"\"\n",
    "    countData = {}\n",
    "    countData['xlabel'], countData['title'] = getLabels(scanType)\n",
    "    if not xLabel==\"\":\n",
    "        countData['xlabel'] = xLabel\n",
    "    if not title==\"\":\n",
    "        countData['title'] = title\n",
    "    ax1 = {}\n",
    "    \n",
    "    if location==(-1,-1):\n",
    "        data = []\n",
    "        legendLabels = []\n",
    "        if \"raw\" in plottedData:\n",
    "            data.append(integrateData(rawData))\n",
    "            legendLabels.append(['Int(Raw Data)'])\n",
    "        if \"-bg\" in plottedData:\n",
    "            data.append(integrateData(dataMinusBg))\n",
    "            legendLabels.append('Int(Data - Background)')\n",
    "        if \"-avg\" in plottedData:\n",
    "            data.append(integrateData(dataMinusAverage))\n",
    "            legendLabels.append('Int(Data - Average)')\n",
    "        ax1['data'] = arr(data)\n",
    "        ax1['legendLabels'] = arr(legendLabels)\n",
    "        ax1['ylabel'] = 'Camera Counts (Integrated over Picture)'        \n",
    "\n",
    "        ax2 = {}\n",
    "        data = []\n",
    "        legendLabels = []\n",
    "        if \"raw\" in plottedData:\n",
    "            data.append([np.max(pic, axis=(1,0)) for pic in rawData])\n",
    "            legendLabels.append(['Max Value in Raw Data'])\n",
    "        if \"-bg\" in plottedData:\n",
    "            data.append([np.max(pic, axis=(1,0)) for pic in dataMinusBg])\n",
    "            legendLabels.append('Max Value in Data Without Background')\n",
    "        if \"-avg\" in plottedData:\n",
    "            data.append([np.max(pic, axis=(1,0)) for pic in dataMinusAverage])\n",
    "            legendLabels.append('Max Value in Data Without Average')\n",
    "        ax2['data'] = arr(data)\n",
    "        ax2['legendLabels'] = arr(legendLabels)\n",
    "        ax2['ylabel'] = 'Maximum count in picture'\n",
    "        countData['ax2'] = ax2\n",
    "    else:\n",
    "        ax1['data'] = arr([rawData[:,location[0], location[1]]])\n",
    "        ax1['ylabel'] = 'Camera Counts (single pixel)'\n",
    "    countData['ax1'] = ax1\n",
    "    \n",
    "    fitData = {}\n",
    "    ax1 = {}\n",
    "    \n",
    "    ax1['data'] = waists\n",
    "    ax1['ylabel'] = \"Waist ($2\\sigma$) (pixels)\"\n",
    "    if len(waistFits) == 0:\n",
    "        ax1['legendLabels'] = [\"fit $w_x$\", \"fit $w_y$\"]\n",
    "    else:\n",
    "        print('...')\n",
    "        ax1['legendLabels'] = [\"fit $w_x$\", \"fit $w_y$\", 'Fitted X: ' + str(waistFits[0]), 'Fitted Y: ' + str(waistFits[1])]\n",
    "        fitYData = []\n",
    "        for fitParams in waistFits:\n",
    "            xpts = np.linspace(min(key), max(key), 1000)\n",
    "            fitYData.append(beamWaistExpansion(xpts, fitParams[0], fitParams[1], 850e-9))\n",
    "        ax1['fitYData'] = fitYData\n",
    "        ax1['fitXData'] = [xpts, xpts]\n",
    "    fitData['ax1'] = ax1\n",
    "    ax2 = {}\n",
    "    ax2['data'] = positions\n",
    "    ax2['ylabel'] = \"position (pixels)\"\n",
    "    ax2['legendLabels'] = [\"Center x\", \"Center y\"]   \n",
    "    fitData['ax2'] = ax2\n",
    "    fitData['title'] = \"Fit Information\"\n",
    "    fitData['xlabel'] = countData['xlabel']\n",
    "    \n",
    "    return countData, fitData"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### Picture Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:42.999819Z",
     "start_time": "2017-06-17T14:33:42.787659Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def showPicComparisons(data, key, fitParameters=np.array([]), colormax=-1):\n",
    "    \"\"\"\n",
    "    formerly the \"individualPics\" option.\n",
    "    expects structure:\n",
    "    data[key value number][raw, -background, -average][2d pic]\n",
    "    \"\"\"\n",
    "    if data.ndim != 4:\n",
    "        raise ValueError(\"Incorrect dimensions for data input to show pics if you want individual pics.\")\n",
    "    titles = ['Raw Picture', 'Background Subtracted', 'Average Subtracted']\n",
    "    for inc in range(len(data)):\n",
    "        figure()\n",
    "        fig, plts = subplots(1, len(data[inc]), figsize=(15,6))\n",
    "        count = 0\n",
    "        for pic in data[inc]:\n",
    "            x = np.linspace(1, pic.shape[1], pic.shape[1])\n",
    "            y = np.linspace(1, pic.shape[0], pic.shape[0])\n",
    "            x, y = np.meshgrid(x, y)\n",
    "            im = plts[count].pcolormesh(pic, extent=(x.min(), x.max(), y.min(), y.max()))\n",
    "            fig.colorbar(im, ax=plts[count], fraction=0.046, pad=0.04)\n",
    "            plts[count].set_title(titles[count])\n",
    "            plts[count].axis('off')\n",
    "            if fitParameters.size!=0:\n",
    "                if (fitParameters[count] != np.zeros(len(fitParameters[count]))).all():\n",
    "                    data_fitted = gaussian_2D((x, y), *fitParameters[count])\n",
    "                    try:\n",
    "                        plts[count].contour(x, y, data_fitted.reshape(picture.shape[0],picture.shape[1]), \n",
    "                                        2, colors='w', alpha=0.35, linestyles=\"dashed\")\n",
    "                    except ValueError:\n",
    "                        pass\n",
    "            count += 1\n",
    "        fig.suptitle(str(key[inc]))\n",
    "\n",
    "\n",
    "def showBigPics(data, key, fitParameters=np.array([]), individualColorBars=False, colormax=-1):\n",
    "    \"\"\"\n",
    "    formerly the \"bigPictures\" option.\n",
    "    \"\"\"\n",
    "    if data.ndim != 3:\n",
    "        raise ValueError(\"Incorrect dimensions for data input showBigPics.\")\n",
    "    num = len(data)\n",
    "    count = 0\n",
    "    maximum = sorted(data.flatten())[colormax]\n",
    "    minimum = min(data.flatten())\n",
    "    # get picture fits & plots\n",
    "    for picture in data:\n",
    "        fig = figure()\n",
    "        grid(0)\n",
    "        if individualColorBars:\n",
    "            maximum = max(picture.flatten())\n",
    "            minimum = min(picture.flatten())\n",
    "        x = np.linspace(1, picture.shape[1], picture.shape[1])\n",
    "        y = np.linspace(1, picture.shape[0], picture.shape[0])\n",
    "        x, y = np.meshgrid(x, y)\n",
    "        im = pcolormesh(picture, vmin = minimum, vmax=maximum)\n",
    "        axis('off')\n",
    "        title(str(round_sig(key[count], 4)), fontsize=8)\n",
    "        if fitParameters.size!=0:\n",
    "            if (fitParameters[count] != np.zeros(len(fitParameters[count]))).all():\n",
    "                data_fitted = gaussian_2D((x, y), *fitParameters[count])\n",
    "                try:\n",
    "                    contour(x, y, data_fitted.reshape(picture.shape[0], picture.shape[1]), \n",
    "                            2, colors='w', alpha=0.35, linestyles=\"dashed\")\n",
    "                except ValueError:\n",
    "                    pass\n",
    "        count += 1              \n",
    "        # final touches\n",
    "        cax = fig.add_axes([0.95, 0.1, 0.03, 0.8])\n",
    "        fig.colorbar(im, cax=cax)\n",
    "\n",
    "def showPics(data, key, fitParameters=np.array([]), individualColorBars=False, colormax=-1):  \n",
    "    \"\"\"\n",
    "    formerly the default option.\n",
    "    \"\"\"\n",
    "    #if data.ndim != 3:\n",
    "    #    raise ValueError(\"Incorrect dimensions for data input to show pics if you don't want individual pics.\")\n",
    "    num = len(data)\n",
    "    gridsize1 = 0\n",
    "    gridsize2 = 0\n",
    "    for i in range(100):\n",
    "        if i*i >= num:\n",
    "            gridsize1 = i;\n",
    "            if i*(i-1) >= num:\n",
    "                gridsize2 = i-1\n",
    "            else:\n",
    "                gridsize2 = i\n",
    "            break\n",
    "    fig, plts = subplots(gridsize2, gridsize1, figsize=(15,10))\n",
    "    count = 0\n",
    "    rowCount = 0\n",
    "    picCount = 0\n",
    "    maximum = sorted(data.flatten())[colormax]\n",
    "    minimum = min(data.flatten())\n",
    "    # get picture fits & plots\n",
    "    for row in plts:\n",
    "        for pic in row:\n",
    "            plts[rowCount, picCount].grid(0)\n",
    "            if count >= len(data):\n",
    "                count += 1\n",
    "                picCount += 1\n",
    "                continue\n",
    "            picture = data[count]\n",
    "            if individualColorBars:\n",
    "                maximum = max(picture.flatten())\n",
    "                minimum = min(picture.flatten())\n",
    "            x = np.linspace(1, picture.shape[1], picture.shape[1])\n",
    "            y = np.linspace(1, picture.shape[0], picture.shape[0])\n",
    "            x, y = np.meshgrid(x, y)\n",
    "            im = plts[rowCount, picCount].imshow(picture, origin='bottom', extent=(x.min(), x.max(), y.min(), y.max()),\n",
    "                                                 vmin = minimum, vmax=maximum)\n",
    "            plts[rowCount, picCount].axis('off')\n",
    "            plts[rowCount, picCount].set_title(str(round_sig(key[count], 4)), fontsize=8)\n",
    "            if fitParameters.size!=0:\n",
    "                if (fitParameters[count] != np.zeros(len(fitParameters[count]))).all():\n",
    "                    data_fitted = gaussian_2D((x, y), *fitParameters[count])\n",
    "                    try:\n",
    "                        plts[rowCount, picCount].contour(x, y, \n",
    "                                                         data_fitted.reshape(picture.shape[0], picture.shape[1]), \n",
    "                                                         2, colors='w', alpha=0.35, linestyles=\"dashed\")\n",
    "                    except ValueError:\n",
    "                        pass\n",
    "\n",
    "\n",
    "            count += 1\n",
    "            picCount += 1                \n",
    "        picCount = 0\n",
    "        rowCount += 1\n",
    "    # final touches\n",
    "    fitParameters = np.array(fitParameters)\n",
    "    cax = fig.add_axes([0.95, 0.1, 0.03, 0.8])\n",
    "    fig.colorbar(im, cax=cax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### MOT Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.088000Z",
     "start_time": "2017-06-17T14:33:42.999819Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def beamIntensity(power, waist, radiusOfInterest):\n",
    "    return power * (1 - np.exp(-2*radiusOfInterest**2/waist**2)) / (np.pi*radiusOfInterest**2);\n",
    "# Gain (NOT currently used in fluorescence calc...)\n",
    "def computeBaslerGainDB(rawGain):\n",
    "    G_c = 20 * np.log10((658 + rawGain)/(658 - rawGain))\n",
    "    if rawGain>= 110 and rawGain <= 511:\n",
    "        gainDB = 20 * np.log10((658 + rawGain)/(658 - rawGain)) - G_c\n",
    "    elif rawgain >= 511 and rawGain <= 1023:\n",
    "        gainDB = 0.0354 * rawGain - G_c\n",
    "    return gainDB\n",
    "\n",
    "def computeScatterRate(totalIntensity, Detuning):\n",
    "    rate = (Rb87_AvgGamma/2) * (totalIntensity / Rb87_I_Sat) / (1 + 4 * (Detuning / Rb87_AvgGamma)**2 + totalIntensity / Rb87_I_Sat)\n",
    "    return rate\n",
    "\n",
    "# TODO: incorporate gain into the calculation, currently assumes gain = X1... need to check proper conversion \n",
    "# from basler software. I'd expect a power conversion so a factor of 20,\n",
    "# Fluorescence\n",
    "def computeFlorescence(greyscaleReading, rbD2LineWavelength, imagingLoss, imagingLensDiameter, imagingLensFocalLength, exposure):\n",
    "    term1 = greyscaleReading * cameraConversion / (h * c / rbD2LineWavelength)\n",
    "    term2 = 1 * imagingLoss * (imagingLensDiameter**2 / (16 * imagingLensFocalLength**2)) * exposure\n",
    "    fluorescence = term1 / term2\n",
    "    return fluorescence\n",
    "\n",
    "# mot radius is in cm\n",
    "def computeMotNumber(sidemotPower, diagonalPower, motRadius, exposure, imagingLoss, greyscaleReading):\n",
    "    \"\"\"\n",
    "    here with sideMOT power in mW assuming 3.3mm radius waist and a very rough estimation of main MOT diameter one inch,\n",
    "    motRadius using the sigma of the MOT size but should not matter if it's small enough, and exposure in sec,\n",
    "    typically 0.8 for the imaging loss accounting for the line filter, greyscaleReading is the integrated gray \n",
    "    scale count with 4by4 binning on the Basler camera, and assuming gain set to 260 which is  unity gain for Basler\n",
    "\n",
    "    \"\"\"\n",
    "    # in cm\n",
    "    sidemotWaist = .33 / (2*np.sqrt(2))\n",
    "    # in cm\n",
    "    diagonalWaist = 2.54 / 2\n",
    "\n",
    "    #intensities\n",
    "    sidemotIntensity = beamIntensity(sidemotPower, sidemotWaist, motRadius)\n",
    "    diagonalIntensity = beamIntensity(diagonalPower, diagonalWaist, motRadius)\n",
    "    totalIntensity = sidemotIntensity + 2 * diagonalIntensity\n",
    "    detuning = 10e6\n",
    "    rate = computeScatterRate(totalIntensity, detuning) \n",
    "    imagingLensDiameter = 2.54\n",
    "    imagingLensFocalLength = 10\n",
    "    fluorescence = computeFlorescence(greyscaleReading, Rb87_D2LineWavelength, imagingLoss, imagingLensDiameter, \n",
    "                                      imagingLensFocalLength, exposure)\n",
    "    motNumber = fluorescence / rate\n",
    "    return motNumber\n",
    "\n",
    "# TODO: for some reason this fitting si currently very finicky with respect to sigma_I. Don't understand why. should\n",
    "# fix this.\n",
    "def calcMotTemperature(times, sigmas, show=True):\n",
    "    guess = [0.001, 0.1]\n",
    "    # in cm\n",
    "    #sidemotWaist = .33 / (2*np.sqrt(2))\n",
    "    sidemotWaist = 8 / (2*np.sqrt(2))\n",
    "    # sidemotWaist^2/2 = 2 sigma_sidemot^2\n",
    "    # different gaussian definitions\n",
    "    sigma_I = sidemotWaist / 2\n",
    "    # convert to m\n",
    "    sigma_I /= 100\n",
    "    # modify roughly for angle of beam\n",
    "    #sigma_I /= np.cos(2*pi/3)\n",
    "    sigma_I /= np.cos(pi/4)\n",
    "    sigma_I = 100\n",
    "    fitVals, fitCovariances = fit(lambda x, a, b: ballisticMotExpansion(x, a, b, sigma_I), times, sigmas, p0=guess )\n",
    "    simpleVals, simpleCovariances = fit(simpleMotExpansion, times, sigmas, p0=guess )\n",
    "    temperature = Rb87_M / k_B * fitVals[1]**2\n",
    "    tempFromSimple = Rb87_M / k_B * simpleVals[1]**2\n",
    "    return temperature, tempFromSimple, fitVals, fitCovariances, simpleVals, simpleCovariances\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "In principle, most data runs should just require running a single function from this area of the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### singleImage()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.148070Z",
     "start_time": "2017-06-17T14:33:43.088000Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def singleImage(data, accumulations=1, loadType='andor', bg=arr(0), title='Single Picture', window=(0,0,0,0), \n",
    "                xMin=0, xMax=0, yMin=0, yMax=0, zeroCorners=False, smartWindow=False):\n",
    "    # if integer or 1D array\n",
    "    if type(data) == int or (type(data) == np.array and type(data[0]) == int):\n",
    "        if loadType == 'andor':\n",
    "            rawData = loadFits(data)\n",
    "        elif loadType == 'scout':\n",
    "            rawRawData = [ [ [] for y in range(accumulations) ] for x in range(len(key))]\n",
    "            dataInc = 0\n",
    "            for keyInc in range(len(key)):\n",
    "                for repInc in range(accumulations):                    \n",
    "                    rawRawData[keyInc][repInc] = loadBasler(initDataNum + dataInc)\n",
    "                    dataInc += 1\n",
    "            rawRawData = arr(rawRawData)\n",
    "                # average all the pics for a given key value\n",
    "            rawData = [ [] for x in range(len(key))]\n",
    "            variationInc = 0\n",
    "            singleAvgPic = 0\n",
    "            for variationPics in rawRawData:\n",
    "                avgPic = 0;\n",
    "                for pic in variationPics:\n",
    "                    avgPic += pic\n",
    "                avgPic /= accumulations\n",
    "                rawData[variationInc] = avgPic\n",
    "                singleAvgPic += avgPic\n",
    "                variationInc += 1\n",
    "            rawData = arr(rawData)\n",
    "        elif loadType == 'ace':\n",
    "            rawData = loadCompoundBasler(data)\n",
    "        elif loadType == 'dataray':\n",
    "            rawData = [ [] for x in range(data)]\n",
    "            # assume user inputted an array of ints.\n",
    "            for dataNum in data:\n",
    "                rawData[keyInc][repInc] = loadDataRay(data)\n",
    "        else:\n",
    "            raise ValueError(\"Bad argument for LoadType.\")\n",
    "    else:\n",
    "        rawData = data\n",
    "    \n",
    "    rawData, dataMinusBg = processSingleImage(rawData, bg, window, xMin, xMax, yMin, yMax, accumulations, zeroCorners, smartWindow)\n",
    "    if not bg == arr(0):\n",
    "        imshow(dataMinusBg[0])\n",
    "    else:\n",
    "        imshow(rawData[0])\n",
    "    colorbar()\n",
    "    grid('off')\n",
    "    return rawData, dataMinusBg\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### standardImages()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.428018Z",
     "start_time": "2017-06-17T14:33:43.150410Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def standardImages(data, \n",
    "                 ### Optional Parameters\n",
    "                 # Cosmetic Parameters\n",
    "                 scanType=\"\", xLabel=\"\", yLabel=\"\", title=\"\", convertKey=False, showPictures=True, show=True,\n",
    "                 allThePics=False,\n",
    "                 bigPics=False, colorMax=-1, individualColorBars=False, majorData='counts',\n",
    "                 # Global Data Manipulation Options\n",
    "                  loadType='fits', window=(0,0,0,0), smartWindow=False, xMin=0, xMax=0, yMin=0, yMax=0, accumulations=1, key=arr([]), \n",
    "                  normData=np.array([]), zeroCorners=False, dataRange=(0,0), initDataNum=0,\n",
    "                 # Local Data Manipulation Options\n",
    "                 plottedData=[\"raw\"], bg=arr(0), location=(-1,-1), fitBeamWaist=False, fitPics=False, \n",
    "                cameraType='dataray'\n",
    "                ):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function analyzes and plots fits pictures. It does not know anything about atoms, \n",
    "    it just looks at pixels or integrates regions of the picture.\n",
    "    \n",
    "    **************\n",
    "    *** Parameters:\n",
    "    **************\n",
    "    \n",
    "    ***\n",
    "    Required parameters\n",
    "    ***\n",
    "    \n",
    "    :data: the number of the fits file and (by default) the number of the key file. The function knows where to look\n",
    "        for the file with the corresponding name. Alternatively, an array of pictures to be used directly.\n",
    "    \n",
    "    ***\n",
    "    optional parameters\n",
    "    ***\n",
    "    \n",
    "    *** Cosmetic parameters\n",
    "    * Change the way the data is diplayed, but not how it is analyzed.\n",
    "    \n",
    "    :scanType: a string which characterizes what was scanned during the run. Depending on this string, axis names\n",
    "        are assigned to the axis of the plots produced by this function. This parameter, if it is to do anything, must\n",
    "        be one of a defined list of types, which can be looked up in the getLabels function.\n",
    "        \n",
    "    :xLabel: Specify the xlabel that appears on the plots. Will override an xlabel specified by the scan type, \n",
    "        but leave other scanType options un-marred.\n",
    "        \n",
    "    :title: Specify the title that appears on the plots. Will override a title specified by the scan type, \n",
    "        but leave other scanType options un-marred.\n",
    "    \n",
    "    :convertKey: For frequency scans. If this is true, use the dacToFrequency conversion constants declared in the \n",
    "        constants section of the base notebook to convert the key into frequency units instead of voltage units.\n",
    "        This should probably eventually be expanded to handle other conversions as well.\n",
    "        \n",
    "    :showPictures: if this is True, show all of the pictures taken during the experiment.\n",
    "        \n",
    "    :show: if this is true, the function plots the integrated or point data. This would only be false if you just \n",
    "        want the data arrays to do data visualization yourself.\n",
    "        \n",
    "    :allThePics: If this is true, then when the pictures are shown, the raw, -bg, and -avg pictures will all be\n",
    "        plotted side-by-side for comparison. showPictures must also be true.\n",
    "    \n",
    "    :bigPics: if this is true, then when the pictures are shown, instead of compressing the pictures to all fit in a \n",
    "        reasonably sized figure, each picture gets its own figure. allThePics must be false, showPictures must be true.\n",
    "    \n",
    "    :colorMax: by default the colorbars in the displayed pictures are chosen to range from the minimum value in the pic\n",
    "        to the maximum value. If this is set, then instead you can specify an offset for the maximum (e.g. -5 for 5th\n",
    "        highest value in the picture). This is usefull, e.g. if cosmic rays are messing with your pictures.\n",
    "\n",
    "    :individualColorBars: by default, the pictures are all put on the same colorbar for comparison. If this is true, \n",
    "        each picture gets its own colorbar, which can make it easier to see features in each individual picture, but \n",
    "        generally makes comparison between pictures harder.\n",
    "\n",
    "    :majorData: (expects one of 'counts', 'fits') Identifies the data to appear in the big plot, the other gets shown\n",
    "        in the small plot.\n",
    "    \n",
    "    *** GLOBAL Data Manipulation Options\n",
    "    * these manipulate all the data that is analyzed and plotted.\n",
    "    \n",
    "    :loadType: (expects one of 'fits', 'dataray', 'basler') determines the loading function used to load the image data.\n",
    "    \n",
    "    :window: (expects format (xMin, xMax, yMin, xMax)). Specifies a window of the picture to be analyzed in lieu of the \n",
    "        entire picture. This command overrides the individual arguments (e.g. xMin) if both are present. The rest of\n",
    "        the picture is completely discarded and not used for any data analysis, e.g. fitting. This defaults to cover\n",
    "        the entire picture\n",
    "    \n",
    "    :xMin, xMax, yMin, and yMax: Specify a particular bound on the image to be analyzed; other parameters are left\n",
    "        untouched. See above description of the window parameter. These default to cover the entire picture.\n",
    "    \n",
    "    :accumulations: If using accumulation mode on the Andor, set this parameter to the number of accumulations per\n",
    "        image so that the data can be properly normalized for comparison to other pictures, backgrounds, etc. \n",
    "        Defaults to 1.\n",
    "        \n",
    "    :key: give the function a custom key. By default, the function looks for a key in the raw data file, but sometimes\n",
    "        scans are done without the master code specifying the key.\n",
    "    \n",
    "    :normData: This can be used to normalize each picture individually, e.g. normalizing for the size of the MOT during\n",
    "        a picture. I don't think that this is actually working well yet, so check how this is beign used.\n",
    "        \n",
    "    :zeroCorners: If this is true, average the four corners of the picture and subtract this average from every picture.\n",
    "        This applies to the raw, -bg, and -avg data. for the latter two, the average is calculated and subtracted after\n",
    "        the bg or avg is subtracted.\n",
    "    \n",
    "    :dataRange: Specify which key values to analyze. By default, analyze all of them. (0,-1) will drop the last \n",
    "        key value, etc.\n",
    "\n",
    "    :initDataNum: for basler scout analysis only right now. The offset of the data number so that the function can figure out\n",
    "        all of the data numbers that correspond to this run.\n",
    "        \n",
    "    *** LOCAL Data Manipulation Parameters\n",
    "    * These add extra analysis or change certain parts of the data analysis while leaving other parts intact.\n",
    "\n",
    "    :plottedData: (can include \"raw\", \"-bg\", and or \"-avg\") An array of strings which tells the function which data to \n",
    "        plot. Can be used to plot multiple sets of data simultaneously, if needed. Defaults to raw. If only a single set \n",
    "        is plotted, then that set is also shown in the pictures. In the case that multiple are shown, it's a bit funny\n",
    "        right now.\n",
    "\n",
    "    :bg: A background picture, or a constant value, which is subtracted from each picture.\n",
    "        defaults to subtracting nothing.\n",
    "\n",
    "    :location: Specify a specific pixel to be analyzed instead of the whole picture.\n",
    "    \n",
    "    :fitPics: Attempt a 2D gaussian fit to each picture.\n",
    "    \n",
    "    :fitBeamWaist: Don't think this works yet. The idea is that if gaussianFitPics is also true, then you can use this\n",
    "        to fit a gaussian beam profile to the expanding gaussian fits. This could be useful, e.g. when calibrating the \n",
    "        camera position.\n",
    "        \n",
    "    ***********\n",
    "    *** Returns\n",
    "    ***********\n",
    "    returns key, rawData, dataMinusBg, dataMinusAvg, avgPic, pictureFitParams\n",
    "    \n",
    "    \"\"\"\n",
    "    # Check for incompatible parameters.\n",
    "    if bigPics and allThePics:\n",
    "        print(\"ERROR: can't use both bigPics and allThePics.\")\n",
    "        return\n",
    "    if fitBeamWaist and not fitPics:\n",
    "        print(\"ERROR: Can't use fitBeamWaist and not fitPics! The fitBeamWaist attempts to use the fit values \"\n",
    "              \"found by the gaussian fits.\")\n",
    "        return\n",
    "    if bigPics and not showPics:\n",
    "        print(\"Can't show bigPics if not showPics!\")\n",
    "        return\n",
    "    if allThePics and not showPics:\n",
    "        print(\"Can't show allThePics if not showPics!\")\n",
    "        return\n",
    "    \n",
    "    # the key\n",
    "    if key.size == 0:\n",
    "        origKey = loadKey(data)\n",
    "    else:\n",
    "        origKey = key\n",
    "    \n",
    "    if convertKey:\n",
    "        a = opBeamDacToVoltageConversion\n",
    "        key = [a[0] + x*a[1] + x**2 * a[2] + x**3 * a[3] for x in origKey]\n",
    "    else:\n",
    "        # both keys the same. \n",
    "        key = origKey\n",
    "    \"\"\" ### Handle data ### \n",
    "    If the corresponding inputs are given, all data gets...\n",
    "    - normalized for accumulations\n",
    "    - normalized using the normData array\n",
    "    - like values in the key & data are averaged\n",
    "    - key and data is ordered in ascending order.\n",
    "    - windowed.\n",
    "    \"\"\"\n",
    "    if type(data) == int or (type(data) == np.array and type(data[0]) == int):\n",
    "        if loadType == 'andor':\n",
    "            rawData = loadFits(data)\n",
    "        elif loadType == 'scout':\n",
    "            rawData = loadCompoundBasler(data, 'scout')\n",
    "        elif loadType == 'ace':\n",
    "            rawData = loadCompoundBasler(data, 'ace')\n",
    "        elif loadType == 'dataray':\n",
    "            rawData = [ [] for x in range(data)]\n",
    "            # assume user inputted an array of ints.\n",
    "            for dataNum in data:\n",
    "                rawData[keyInc][repInc] = loadDataRay(data)\n",
    "        else:\n",
    "            raise ValueError('Bad value for LoadType.')\n",
    "    else:\n",
    "        rawData = data\n",
    "    \n",
    "    key, rawData, dataMinusBg, dataMinusAvg, avgPic = processImageData(key, rawData, bg, window, \n",
    "                                                               xMin, xMax, yMin, yMax, \n",
    "                                                               accumulations, dataRange, zeroCorners, smartWindow)\n",
    "    \n",
    "    if fitPics:\n",
    "        # should improve this to handle multiple sets.\n",
    "        if '-bg' in plottedData:\n",
    "            print('fitting background-subtracted data.')\n",
    "            pictureFitParams, pictureFitErrors = fitPictures(dataMinusBg, range(len(key)), guessSigma_x=2, guessSigma_y=2)\n",
    "        elif '-avg' in plottedData:\n",
    "            print('fitting average-subtracted data.')\n",
    "            pictureFitParams, pictureFitErrors = fitPictures(dataMinusAvg, range(len(key)), guessSigma_x=2, guessSigma_y=2)\n",
    "        else:\n",
    "            print('fitting raw data.')\n",
    "            pictureFitParams, pictureFitErrors = fitPictures(rawData, range(len(key)), guessSigma_x=2, guessSigma_y=2)\n",
    "    else:\n",
    "        pictureFitParams, pictureFitErrors = np.zeros((len(key), 7)), np.zeros((len(key), 7))\n",
    "    \n",
    "    # convert to normal optics convention. the equation uses gaussian as exp(x^2/2sigma^2), I want the waist, \n",
    "    # which is defined as exp(2x^2/waist^2):\n",
    "    waists = 2 * arr([pictureFitParams[:,3], pictureFitParams[:,4]])\n",
    "    positions = arr([pictureFitParams[:,1],pictureFitParams[:,2] ])\n",
    "    amplitudes = pictureFitParams[:,0]\n",
    "    if cameraType=='dataray':\n",
    "        waists *= dataRayPixelSize\n",
    "        positions *= dataRayPixelSize\n",
    "    elif cameraType=='andor':\n",
    "        waists *= andorPixelSize\n",
    "        positions *= andorPixelSize\n",
    "    elif cameraType=='basler':\n",
    "        pass\n",
    "        # TODO:\n",
    "        # waists *= balser\n",
    "        # ...\n",
    "    # average of the two dimensions\n",
    "    avgWaists = []\n",
    "    for pair in np.transpose(arr(waists)):\n",
    "        avgWaists.append((pair[0] + pair[1])/2)\n",
    "    print(arr(avgWaists).shape)\n",
    "    print(arr(amplitudes).shape)\n",
    "    figure()\n",
    "    plot(key, avgWaists,'o',label='avg waist')\n",
    "    legend()\n",
    "    figure()\n",
    "    plot(key, amplitudes, 'o',label='fit amplitudes')\n",
    "    legend()\n",
    "        \n",
    "        \n",
    "    if fitBeamWaist:\n",
    "        try:\n",
    "            waistFitParamsX, waistFitErrsX = fitGaussianBeamWaist(waists[0], key, 850e-9);\n",
    "            waistFitParamsY, waistFitErrsY = fitGaussianBeamWaist(waists[1], key, 850e-9);\n",
    "            waistFitParams = [waistFitParamsX,waistFitParamsY]\n",
    "            # assemble the data structures for plotting.\n",
    "            countData, fitData = assemblePlotData(rawData, dataMinusBg, dataMinusAvg, positions, waists,\n",
    "                                          plottedData, scanType, xLabel, title, location, waistFits=waistFitParams, key=key)\n",
    "        except RuntimeError:\n",
    "            print('gaussian waist fit failed!')\n",
    "                # assemble the data structures for plotting.\n",
    "            countData, fitData = assemblePlotData(rawData, dataMinusBg, dataMinusAvg, positions, waists,\n",
    "                                          plottedData, scanType, xLabel, title, location)\n",
    "    else:\n",
    "        # assemble the data structures for plotting.\n",
    "        countData, fitData = assemblePlotData(rawData, dataMinusBg, dataMinusAvg, positions, waists,\n",
    "                                          plottedData, scanType, xLabel, title, location)\n",
    "\n",
    "\n",
    "    if majorData == 'counts':\n",
    "        majorPlotData, minorPlotData = countData, fitData\n",
    "    elif majorData == 'fits':\n",
    "        minorPlotData, majorPlotData = countData, fitData\n",
    "    else:\n",
    "        raise ValueError(\"incorect 'majorData' argument\")\n",
    "\n",
    "    if show:\n",
    "        plotPoints(key, majorPlotData, minorPlot=minorPlotData, picture=avgPic, picTitle=\"Average Picture\")\n",
    "    \n",
    "    if show and showPictures:\n",
    "        if allThePics:\n",
    "            data = []\n",
    "            for inc in range(len(rawData)):\n",
    "                data.append([rawData[inc], dataWithoutBg[inc], dataWithoutAverage[inc]])\n",
    "            showPicComparisons(arr(data), key, fitParameters=pictureFitParams, colormax=colorMax)\n",
    "        else:\n",
    "            if \"raw\" in plottedData:\n",
    "                if bigPics:\n",
    "                    showBigPics(rawData, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "                else:\n",
    "                    showPics(rawData, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "            if \"-bg\" in plottedData:\n",
    "                if bigPics:\n",
    "                    showBigPics(dataMinusBg, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "                else:\n",
    "                    showPics(dataMinusBg, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "            if \"-avg\" in plottedData:\n",
    "                if bigPics:\n",
    "                    showBigPics(dataMinusAvg, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "                else:\n",
    "                    showPics(dataMinusAvg, key, fitParameters=pictureFitParams, colormax=colorMax, individualColorBars=individualColorBars)\n",
    "    return key, rawData, dataMinusBg, dataMinusAvg, avgPic, pictureFitParams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### motTemperature()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.468080Z",
     "start_time": "2017-06-17T14:33:43.429527Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def motTemperature(data, showPictures=False, show=False, scanType=\"Time(ms)\", xLabel=\"\", yLabel=\"\", title=\"\", majorData='fits',\n",
    "                  loadType='scout', window=(0,0,0,0), xMin=0, xMax=0, yMin=0, yMax=0, accumulations=1, key=arr(0), \n",
    "                  dataRange=arr(0), initDataNum=0, fitPics=True):\n",
    "    \"\"\"\n",
    "    new version of old \"baslerTemperature()\" function.\n",
    "    \"\"\"\n",
    "    key, rawData, dataMinusBg, \\\n",
    "        dataMinusAvg, avgPic, pictureFitParams = standardImages(data, showPictures=False, show=False, scanType=\"Time(ms)\", \n",
    "                                                                xLabel=xLabel, yLabel=yLabel, title=title, majorData='fits',\n",
    "                                                                loadType='scout', window=window, xMin=xMin, xMax=xMax, \n",
    "                                                                yMin=yMin, yMax=yMax, accumulations=accumulations, key=key, \n",
    "                                                                dataRange=dataRange, initDataNum=initDataNum, fitPics=True)\n",
    "   # convert to meters\n",
    "    waists = 2*baslerMetersPer4x4Pixel*analyzedPictureFitParams[:,3]\n",
    "    # convert to s\n",
    "    times = keyForAnalysis / 1000\n",
    "    temp, simpleTemp, fitVals, fitCov, simpleFitVals, simpleFitCov = calcMotTemperature(times, waists/2)\n",
    "    figure()\n",
    "    # plot(times, ballisticMotExpansion(times, *guess, sigma_I))\n",
    "    plot(times, waists, 'o', label='Raw Data Waist')\n",
    "    plot(times, ballisticMotExpansion(times, *fitVals, 100), label='balistic MOT expansion Fit')\n",
    "    plot(times, simpleMotExpansion(times, *simpleFitVals), label='simple MOT expansion Fit ')\n",
    "    title('Measured atom cloud size over time')\n",
    "    xlabel('time (s)')\n",
    "    ylabel('gaussian fit waist (m)')\n",
    "    legend()\n",
    "    \n",
    "    showPics(windowedData, key, fitParameters=pictureFitParams)\n",
    "    \n",
    "    print(\"PGC Temperture (full ballistic):\", temp*1e6, 'uK')\n",
    "    #print(\"MOT Temperature (simple):\", simpleTemp*1e6, 'uK') # \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### baslerTemperature()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.584292Z",
     "start_time": "2017-06-17T14:33:43.472087Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def baslerTemperature(keyNum, initDataNum, repetitions, xmin=0, xmax=0, ymin=0, ymax=0, dataRange=np.array([])):\n",
    "    \"\"\"\n",
    "    A function for calculating the temperature of the MOT. Expects data that corresponds to pictures taken of the mot at different time\n",
    "    increments after the MOT has been dropped (i.e. all lasers turned off, fields zerod).\n",
    "    \n",
    "    \"\"\"\n",
    "    key = loadKey(keyNum)\n",
    "    if dataRange.size == 0:\n",
    "        dataRange = np.array(range(key.size))\n",
    "    data = [ [ [] for y in range(repetitions) ] for x in range(len(key))]\n",
    "    dataInc = 0\n",
    "    for keyInc in range(len(key)):\n",
    "        for repInc in range(repetitions):                    \n",
    "            data[keyInc][repInc] = loadBasler(initDataNum + dataInc)\n",
    "            dataInc += 1\n",
    "    data = np.array(data)\n",
    "    # average all the pics for a given key value\n",
    "    avgData = [ [] for x in range(len(key))]\n",
    "    variationInc = 0\n",
    "    singleAvgPic = 0\n",
    "    for variationPics in data:\n",
    "        avgPic = 0;\n",
    "        for pic in variationPics:\n",
    "            avgPic += pic\n",
    "        avgPic /= repetitions\n",
    "        avgData[variationInc] = avgPic\n",
    "        singleAvgPic += avgPic\n",
    "        variationInc += 1\n",
    "    singleAvgPic /= variationInc\n",
    "    avgData = np.array(avgData)\n",
    "    avgData, key = orderData(avgData, key)\n",
    "    \n",
    "    if xmax==0:\n",
    "        xmax=avgData.shape[1]\n",
    "    if ymax==0:\n",
    "        ymax=avgData.shape[2]   \n",
    "    \n",
    "    windowedData = []\n",
    "    dataForAnalysis = []\n",
    "    keyForAnalysis = []\n",
    "    for pic in range(len(avgData)):\n",
    "        windowedData.append(avgData[pic,xmin:xmax,ymin:ymax])\n",
    "        if pic in dataRange:\n",
    "            dataForAnalysis.append(avgData[pic,xmin:xmax,ymin:ymax])\n",
    "            keyForAnalysis.append(key[pic])\n",
    "    windowedData = arr(windowedData)\n",
    "    dataForAnalysis = arr(dataForAnalysis)\n",
    "    keyForAnalysis = arr(keyForAnalysis)\n",
    "    \n",
    "    pictureFitParams, pictureFitErrors = fitPictures(windowedData, range(len(key)))\n",
    "    analyzedPictureFitParams = []\n",
    "    for params in range(len(pictureFitParams)):\n",
    "        if params in dataRange:\n",
    "            analyzedPictureFitParams.append(pictureFitParams[params])\n",
    "    analyzedPictureFitParams = arr(analyzedPictureFitParams)\n",
    "    # convert to meters\n",
    "    sigmas = baslerMetersPer4x4Pixel*analyzedPictureFitParams[:,3]\n",
    "    # convert to s\n",
    "    times = keyForAnalysis / 1000\n",
    "    temp, simpleTemp, fitVals, fitCov, simpleFitVals, simpleFitCov = calcMotTemperature(times, sigmas)\n",
    "    figure()\n",
    "    #plot(times, ballisticMotExpansion(times, *guess, sigma_I))\n",
    "    plot(times, sigmas, 'o', label='Raw Data')\n",
    "    plot(times, ballisticMotExpansion(times, *fitVals, 100), label='balistic expansion Fit')\n",
    "    plot(times, simpleMotExpansion(times, *simpleFitVals), label='balistic expansion Fit')\n",
    "    title('Measured atom cloud size over time')\n",
    "    xlabel('time (s)')\n",
    "    ylabel('gaussian fit sigma (m)')\n",
    "    \n",
    "    showPics(windowedData, key, fitParameters=pictureFitParams)\n",
    "    \n",
    "    print(\"PGC Temperture (full ballistic):\", temp*1e6, 'uK')\n",
    "    #print(\"MOT Temperature (simple):\", simpleTemp*1e6, 'uK') # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### countHist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.616260Z",
     "start_time": "2017-06-17T14:33:43.584292Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def countHist(num, bg=0, location=(-1,-1), accumulations=1):\n",
    "    rawData = loadFits(num)\n",
    "    rawData /= accumulations\n",
    "    for pic in rawData:\n",
    "        pic -= bg\n",
    "    \n",
    "    avgPic = 0;\n",
    "    for pic in rawData:\n",
    "        avgPic += pic\n",
    "    avgPic /= len(rawData)\n",
    "    \n",
    "    if location==(-1,-1):\n",
    "        integratedData = integrateData(rawData)\n",
    "        plotHist(avgPic, integratedData, xLabel=\"Counts (Integrated)\")\n",
    "    else:\n",
    "        plotHist(avgPic, rawData[:,location[0], location[1]], circLoc=location, xLabel=\"Counts (1 location)\")\n",
    "    return avgPic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### motNumber()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.680277Z",
     "start_time": "2017-06-17T14:33:43.620169Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def motNumber(dataSetNumber, motKey, window=(0,0,0,0), cameraType='scout'):\n",
    "    #loadKey = np.arange(0,5000,500)\n",
    "    _, rawData, _, _, _, _ = standardImages(dataSetNumber, key=motKey, scanType=\"time (s)\", window=window, loadType='scout', show=False)\n",
    "    # intData = standardBasler(0, baslerDataOffset, repetitions=1, scanType=\"time (s)\", key=loadKey, window=window);\n",
    "    intRawData = integrateData(rawData)\n",
    "    def fitFunc(x, a, b, c):\n",
    "         return a * np.exp(-b * x) + c\n",
    "    xdata = motKey\n",
    "    popt, pcov = fit(fitFunc, xdata, intRawData, p0=[np.min(intRawData)-np.max(intRawData), 5, np.max(intRawData)])\n",
    "    \n",
    "    figure()\n",
    "    plot(xdata, intRawData, 'bo', label='data', color='r')\n",
    "    plot(xdata, fitFunc(xdata, *popt), 'r-', label='fit', color='r', linestyle=':')\n",
    "    xlabel('loading time (s)')\n",
    "    ylabel('integrated counts')\n",
    "    title('Mot Fill Curve')\n",
    "    print(\"integrated counts subtracting background = \", -popt[0])\n",
    "    print(\"loading time 1/e  = \", 1/popt[1], \" s\")\n",
    "    return computeMotNumber(2.05, 8, 8*8e-6, 0.001, 0.8, -popt[0])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### standardAtom()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.708277Z",
     "start_time": "2017-06-17T14:33:43.680277Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def determineIndividualSurvivalEvents(data, threshold, numberOfExperiments):\n",
    "    \"\"\"\n",
    "    This function assumes 2 pictures.\n",
    "    It returns a raw array that includes every survival data point, including points where the the atom doesn't get\n",
    "    loaded at all.\n",
    "    \"\"\"\n",
    "    import numpy as np\n",
    "    # this will include entries for when there is no atom in the first picture.\n",
    "    survivalData = np.array([])\n",
    "    survivalData.astype(int)\n",
    "    # this doesn't take into account loss, since these experiments are feeding-back on loss.\n",
    "    for experimentInc in range(0, numberOfExperiments):\n",
    "        if data[2 * experimentInc] > threshold and data[2 * experimentInc + 1] >= threshold:\n",
    "            # atom survived\n",
    "            survivalData = np.append(survivalData, 1)\n",
    "        elif data[2 * experimentInc] > threshold > data[2 * experimentInc + 1]:\n",
    "            # atom didn't survive \n",
    "            survivalData = np.append(survivalData, 0)\n",
    "        else:\n",
    "            # no atom in the first place\n",
    "            survivalData = np.append(survivalData, -1)\n",
    "    return survivalData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.752335Z",
     "start_time": "2017-06-17T14:33:43.712273Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def getSingleParticleSurvivalData(survivalData, repetitionsPerVariation):\n",
    "    # Take the previous data, which includes entries when there was no atom in the first picture, and convert it to\n",
    "    # an array of just loaded and survived or loaded and died.    \n",
    "    survivalAverages = np.array([])\n",
    "    loadingProbability = np.array([])\n",
    "    survivalErrors = np.array([])\n",
    "    for variationInc in range(0, int(survivalData.size / repetitionsPerVariation)):\n",
    "        survivalList = np.array([])\n",
    "        for repetitionInc in range(0, repetitionsPerVariation):\n",
    "            if survivalData[variationInc * repetitionsPerVariation + repetitionInc] != -1:\n",
    "                survivalList = np.append(survivalList,\n",
    "                                         survivalData[variationInc * repetitionsPerVariation + repetitionInc])\n",
    "        if survivalList.size == 0:\n",
    "            # catch the case where there's no relevant data, typically if laser becomes unlocked.\n",
    "            survivalErrors = np.append(survivalErrors, 0)\n",
    "            loadingProbability = np.append(loadingProbability, 0)\n",
    "            survivalAverages = np.append(survivalAverages, 0)\n",
    "        else:\n",
    "            # normal case\n",
    "            survivalErrors = np.append(survivalErrors, np.std(survivalList)/np.sqrt(survivalList.size))\n",
    "            loadingProbability = np.append(loadingProbability, survivalList.size / repetitionsPerVariation)\n",
    "            survivalAverages = np.append(survivalAverages, np.average(survivalList))\n",
    "\n",
    "    return survivalAverages, survivalErrors, loadingProbability\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:43.972823Z",
     "start_time": "2017-06-17T14:33:43.760365Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import uncertainties as unc\n",
    "import uncertainties.unumpy as unp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:44.319273Z",
     "start_time": "2017-06-17T14:33:43.972823Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def standardAtom( fileNumber, atomLocation, repetitions, show=True, accumulations=1, key=arr([]), \n",
    "                  picturesPerRepetition = 1, plotTogether=True, plotLoadingRate=False, hardThreshold=0, fitType='None',\n",
    "                  window=(0,0,0,0), xMin=0, xMax=0, yMin=0, yMax=0):\n",
    "    # the key\n",
    "    if key.size == 0:\n",
    "        key = loadKey(fileNumber)\n",
    "    #### Load Fits File & Get Dimensions\n",
    "    # Get the array from the fits file. That's all I care about.\n",
    "    rawData = loadFits(fileNumber)\n",
    "    \n",
    "    if window != (0,0,0,0):\n",
    "        xMin = window[0]\n",
    "        xMax = window[1]\n",
    "        yMin = window[2]\n",
    "        yMax = window[3]\n",
    "    else:\n",
    "        if xMax == 0:\n",
    "            xMax = len(rawData[0][0])\n",
    "        if yMax == 0:\n",
    "            yMax = len(rawData[0])        \n",
    "        if xMax < 0:\n",
    "            xMax = 0\n",
    "        if yMax < 0:\n",
    "            yMax = 0 \n",
    "            \n",
    "    # window images.\n",
    "    rawData = np.copy(arr(rawData[:,yMin:yMax, xMin:xMax]))\n",
    "\n",
    "    # the .shape member of an array gives an array of the dimesnions of the array.\n",
    "    numberOfPictures = int(rawData.shape[0])\n",
    "    numberOfRuns = int(numberOfPictures / picturesPerRepetition)\n",
    "    numberOfVariations = int(numberOfPictures / (repetitions * picturesPerRepetition))\n",
    "    \n",
    "    horizontalImageDimension = rawData.shape[1];\n",
    "    verticalImageDimension = rawData.shape[2];\n",
    "    \n",
    "    ### Initial Data Analysis\n",
    "    s = rawData.shape\n",
    "    #if plotTogether:\n",
    "    #    newShape = (1,s[0],s[1],s[2])\n",
    "    #else:\n",
    "    newShape = (numberOfVariations, repetitions * picturesPerRepetition,s[1],s[2])\n",
    "    groupedData = rawData.reshape(newShape)\n",
    "\n",
    "    pixelDataInTime = []\n",
    "    for var in groupedData:\n",
    "        for pic in var:\n",
    "            pixelDataInTime.append(pic[atomLocation[0],atomLocation[1]])\n",
    "    pixelDataInTime = arr(pixelDataInTime)\n",
    "    \n",
    "    groupedData, key = orderData(groupedData, key)\n",
    "    # my function here.\n",
    "    # grab the first picture of each repetition\n",
    "    atomPixelData = []\n",
    "    for var in groupedData:\n",
    "        for pic in var:\n",
    "            atomPixelData.append(pic[atomLocation[0],atomLocation[1]])\n",
    "    atomPixelData = arr(atomPixelData)\n",
    "    firstPictureData = normalizeData(rawData, atomLocation, 0, picturesPerRepetition);\n",
    "    #\n",
    "    avgPic = 0;\n",
    "    \n",
    "    for var in groupedData:\n",
    "        for pic in var:\n",
    "            avgPic += pic\n",
    "        \n",
    "    avgPic /= groupedData.shape[0] * groupedData.shape[1]\n",
    "    binCenters, binnedData = binData(10, firstPictureData);\n",
    "    guess1, guess2 = guessGaussianPeaks(binCenters, binnedData);\n",
    "\n",
    "    ### Calculate Atom Threshold\n",
    "    ### Code to calculate threshold\n",
    "    #define the fitting function\n",
    "    guess = arr([100, guess1, 30, 200, 600, 10]);\n",
    "    gaussianFitVals = fitDoubleGaussian(binCenters, binnedData, guess);\n",
    "    threshold, thresholdFidelity = calculateAtomThreshold(gaussianFitVals);\n",
    "    # threshold= 500\n",
    "    if picturesPerRepetition > 1:\n",
    "        # Get Data in final form for exporting\n",
    "        survivalList = determineIndividualSurvivalEvents(atomPixelData, threshold, numberOfRuns)\n",
    "        survivalData, survivalErrors, captureArray = getSingleParticleSurvivalData(survivalList, repetitions);\n",
    "\n",
    "    atomCount = 0;\n",
    "    \n",
    "    for experimentInc in range(0, firstPictureData.size):\n",
    "        if firstPictureData[experimentInc] > threshold:\n",
    "            atomCount += 1\n",
    "    if plotLoadingRate:\n",
    "        loadingRateList.append(atomCount/firstPictureData.size)\n",
    "\n",
    "    xFit = np.linspace(min(key), max(key), 1000)\n",
    "    if fitType=='Gaussian':\n",
    "        try:\n",
    "            widthGuess = np.std(key) / 2\n",
    "            # Get all the atoms\n",
    "            centerGuess = key[list(survivalData).index(min(survivalData))]\n",
    "            # def gaussian(x, A1, x01, sig1, offset)\n",
    "            fitValues, fitCovs = fit(gaussian, key, survivalData, p0=[-0.95, centerGuess, widthGuess, 0.95])\n",
    "            fitErrs = np.sqrt(np.diag(fitCovs))\n",
    "            \n",
    "            #fitData = gaussian(xFit, *fitValues);\n",
    "            a, b, c, d = unc.correlated_values(fitValues, fitCovs)\n",
    "\n",
    "            fitObject = uncGaussian(xFit, a,b,c,d)\n",
    "\n",
    "            fitNom = unp.nominal_values(fitObject)\n",
    "            fitStd = unp.std_devs(fitObject)\n",
    "        except RuntimeError:\n",
    "            print('Fit Failed!')\n",
    "            fitType='None'\n",
    "\n",
    "    if show:\n",
    "        # ### Plotting ### #########################\n",
    "\n",
    "        #myFigure, ((plot11, plot12, plot13), (plot21, plot22, plot23)) = subplots(2, 3, figsize = (25,12))\n",
    "        #myFigure.suptitle(\"Data for location {\" + str(atomLocation[0] + 1) + \",\" + str(atomLocation[1] + 1) + \"}, key Value = \" + str(key[dataInc]), fontsize = 24);        \n",
    "        #figObject = gcf()\n",
    "        #figObject.canvas.set_window_title(\"{\" + str(atomLocation[0] + 1) + \",\" + str(atomLocation[1] + 1) + \"}\")\n",
    "\n",
    "        # Make colormap. really only need len(locs) + 1 rgbs, but adding an extra makes the spacing of the colors\n",
    "        # on this colormap more sensible.\n",
    "        cmapRGB = mpl.cm.get_cmap('gist_rainbow', len(groupedData) + 2)\n",
    "        colormap = []\n",
    "        for colorInc in range(cmapRGB.N):\n",
    "            colormap.append(mpl.colors.rgb2hex(cmapRGB(colorInc)[:3]))\n",
    "        figure()\n",
    "        # Setup grid\n",
    "        grid1 = mpl.gridspec.GridSpec(12, 16)\n",
    "        grid1.update(left=0.05, right=0.95, wspace=1.2, hspace=1000)\n",
    "        gridLeft = mpl.gridspec.GridSpec(12, 16)\n",
    "        gridLeft.update(left=0.001, right=0.95, hspace=1000)\n",
    "        gridRight = mpl.gridspec.GridSpec(12, 16)\n",
    "        gridRight.update(left=0.2, right=0.946, wspace=0, hspace=1000)\n",
    "        \n",
    "        mainPlot = subplot(grid1[:, :12])\n",
    "        mainPlot.errorbar(key, survivalData, yerr=survivalErrors, ls='', marker='o', capsize=6, elinewidth=3, label='Raw Data')\n",
    "        if not fitType == 'None':\n",
    "            mainPlot.plot( xFit, fitNom, 'r:', label='Fit', linewidth=3 )\n",
    "            mainPlot.fill_between(xFit, fitNom - 2*fitStd, fitNom + 2*fitStd, alpha=0.1, label='2-sigma band')\n",
    "            mainPlot.axvspan(fitValues[1] - 2 * np.sqrt(fitCovs[1,1]),fitValues[1] + 2 * np.sqrt(fitCovs[1,1]),color='r', alpha=0.1)\n",
    "            mainPlot.axvline(fitValues[1], color='r',linestyle='-.', alpha=0.5,label='fit center $= '+str(round_sig(fitValues[1]))\n",
    "                                                                                                + '\\pm '+ str(round_sig(2*fitErrs[1])) \n",
    "                                                                                                + '$')\n",
    "        mainPlot.set_ylim({-0.02, 1.01})\n",
    "        mainPlot.set_xlim(left=min(key) - (max(key) - min(key)) / len(key), right=max(key) + (max(key) - min(key)) / len(key))\n",
    "        mainPlot.set_xticks(key)\n",
    "        mainPlot.set_title(\"Survival Data\", fontsize=30)\n",
    "        mainPlot.set_ylabel(\"Survival Probability\", fontsize=20)\n",
    "        mainPlot.set_xlabel(\"Key Values\", fontsize=20)\n",
    "        mainPlot.legend(loc=\"upper center\", bbox_to_anchor=(0.5,-0.1), fancybox=True, ncol=4)\n",
    "        legend()\n",
    "\n",
    "        capturePlot = subplot(grid1[0:3, 12:16])\n",
    "        capturePlot.plot(key, captureArray, ls='', marker='o', color='c')\n",
    "        capturePlot.axhline(np.mean(captureArray), color='c')\n",
    "        capturePlot.set_ylim({0, 1})\n",
    "        capturePlot.set_xlim(left=min(key) - (max(key) - min(key)) / len(key), right=max(key) + (max(key) - min(key)) / len(key))\n",
    "        capturePlot.set_xlabel(\"Key Values\")\n",
    "        capturePlot.set_ylabel(\"Capture %\")\n",
    "        capturePlot.set_title(\"Capture Probabilities\")\n",
    "        \n",
    "        # ### Count Series Plot\n",
    "        countDataPlot = subplot(gridRight[4:8, 12:15])\n",
    "        countDataPlot.plot(pixelDataInTime, color='g', ls='', marker='.', markersize=1)\n",
    "        countDataPlot.axhline(threshold, color='y')\n",
    "        countDataPlot.set_xlabel(\"Picture #\")\n",
    "        countDataPlot.set_ylabel(\"Camera Signal\")\n",
    "        countDataPlot.set_title(\"Camera Signal Over Time\")\n",
    "        ticksForVis = countDataPlot.xaxis.get_major_ticks()\n",
    "        ticksForVis[-1].label1.set_visible(False)\n",
    "        # Count Histogram Plot\n",
    "        countHistPlot = subplot(gridLeft[4:8, 15:16], sharey=countDataPlot)\n",
    "        # countHistPlot = plt.subplot2grid((16, 16), (4, 15), rowspan=4, sharey=countDataPlot)\n",
    "        countHistPlot.hist(atomPixelData, 50, color='g', orientation='horizontal', alpha=1)\n",
    "        countHistPlot.axhline(threshold, color='y')\n",
    "        ticks = countHistPlot.get_xticklabels()\n",
    "        for tickInc in range(len(ticks)):\n",
    "            ticks[tickInc].set_rotation(-45)\n",
    "        setp(countHistPlot.get_yticklabels(), visible=False)\n",
    "\n",
    "        # average image\n",
    "        plot11 = subplot(gridRight[9:12, 12:15])\n",
    "        plot11.imshow(avgPic);\n",
    "        plot11.set_title(\"Average Image\")\n",
    "        plot11.grid('off')\n",
    "        circ = Circle((atomLocation[1],atomLocation[0]), 0.2, color='r')\n",
    "        plot11.add_artist(circ)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true,
    "hidden": true,
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "### singlePictureAtom()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:33:44.477036Z",
     "start_time": "2017-06-17T14:33:44.319273Z"
    },
    "collapsed": true,
    "hidden": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def singlePictureAtom( fileNumber, atomLocation, repetitions, show=True, accumulations=1, key=arr([0]), \n",
    "                       picturesPerExperiment = 1, plotTogether=True, plotLoadingRate=False, picture=0 ):\n",
    "    \"\"\"\n",
    "    This routine is designed for analyzing experiments with only one picture per cycle. Typically\n",
    "    These are loading exeriments, for example. There's no survival calculation.\n",
    "    \"\"\"\n",
    "    # the key\n",
    "    if key.size == 0:\n",
    "        key = loadKey(fileNumber)\n",
    "    \n",
    "    #### Load Fits File & Get Dimensions\n",
    "    # Get the array from the fits file. That's all I care about.\n",
    "    rawData = loadFits(fileNumber)\n",
    "    # the .shape member of an array gives an array of the dimesnions of the array.\n",
    "    numberOfPictures = rawData.shape[0];\n",
    "    numberOfVariations = int(numberOfPictures / repetitions)\n",
    "    print('Total # of Pictures:', numberOfPictures)\n",
    "    print('Number of Variations:', numberOfVariations)\n",
    "    horizontalImageDimension = rawData.shape[1];\n",
    "    verticalImageDimension = rawData.shape[2];\n",
    "    ### Initial Data Analysis\n",
    "    s = rawData.shape\n",
    "    if plotTogether:\n",
    "        newShape = (1,s[0],s[1],s[2])\n",
    "    else:\n",
    "        newShape = (numberOfVariations,repetitions,s[1],s[2])\n",
    "    groupedData = rawData.reshape(newShape)\n",
    "    groupedData, key = orderData(groupedData, key)\n",
    "    print('Data Shape:', groupedData.shape)\n",
    "    \n",
    "    dataInc = 0\n",
    "    loadingRateList = []\n",
    "    for data in groupedData:\n",
    "        # my function here.\n",
    "        # grab the first picture of each repetition\n",
    "        firstPictureData = normalizeData(data, atomLocation, picture, picturesPerExperiment); \n",
    "        #\n",
    "        avgPic = 0;\n",
    "        for pic in data:\n",
    "            avgPic += pic\n",
    "        avgPic /= len(data)\n",
    "\n",
    "        binCenters, binnedData = binData(5, firstPictureData);\n",
    "        guess1, guess2 = guessGaussianPeaks(binCenters, binnedData);\n",
    "\n",
    "        ### Calculate Atom Threshold\n",
    "        ### Code to calculate threshold\n",
    "        #define the fitting function\n",
    "        guess = arr([numberOfPictures/100, guess1, 40,  numberOfPictures/100, guess2, 40]);\n",
    "        gaussianFitVals = fitDoubleGaussian(binCenters, binnedData, guess);\n",
    "        threshold, thresholdFidelity = calculateAtomThreshold(gaussianFitVals);\n",
    "        #       threshold= 500\n",
    " \n",
    "        atomCount = 0;\n",
    "        for experimentInc in range(0, firstPictureData.size):\n",
    "            if firstPictureData[experimentInc] > threshold:\n",
    "                atomCount += 1\n",
    "        if plotLoadingRate:\n",
    "            loadingRateList.append(atomCount/firstPictureData.size)            \n",
    "        if show:\n",
    "            # ### Plotting ### #########################\n",
    "\n",
    "            #myFigure, ((plot11, plot12, plot13), (plot21, plot22, plot23)) = subplots(2, 3, figsize = (25,12))\n",
    "            #myFigure.suptitle(\"Data for location {\" + str(atomLocation[0] + 1) + \",\" + str(atomLocation[1] + 1) + \"}, key Value = \" + str(key[dataInc]), fontsize = 24);        \n",
    "            #figObject = gcf()\n",
    "            #figObject.canvas.set_window_title(\"{\" + str(atomLocation[0] + 1) + \",\" + str(atomLocation[1] + 1) + \"}\")\n",
    "            \n",
    "            # Make colormap. really only need len(locs) + 1 rgbs, but adding an extra makes the spacing of the colors\n",
    "            # on this colormap more sensible.\n",
    "            cmapRGB = mpl.cm.get_cmap('gist_rainbow', len(groupedData) + 2)\n",
    "            colormap = []\n",
    "            for colorInc in range(cmapRGB.N):\n",
    "                colormap.append(mpl.colors.rgb2hex(cmapRGB(colorInc)[:3]))\n",
    "            figure()\n",
    "            # Setup grid\n",
    "            grid1 = mpl.gridspec.GridSpec(12, 16)\n",
    "            grid1.update(left=0.05, right=0.95, wspace=1.2, hspace=1000)\n",
    "            gridLeft = mpl.gridspec.GridSpec(12, 16)\n",
    "            gridLeft.update(left=0.001, right=0.95, hspace=1000)\n",
    "            gridRight = mpl.gridspec.GridSpec(12, 16)\n",
    "            gridRight.update(left=0.2, right=0.946, wspace=0, hspace=1000)\n",
    "            # ### Main Plot\n",
    "            mainPlot = subplot(grid1[:, :12])\n",
    "            # plot the fit on top of the histogram\n",
    "            mainPlot.bar(binCenters, binnedData, 5, color='r', alpha=0.5, label='Raw Data');\n",
    "            fineXData = np.linspace(min(firstPictureData),max(firstPictureData),500);\n",
    "            mainPlot.plot(fineXData, doubleGaussian(fineXData,*gaussianFitVals,0),color='r',linestyle=':', label='Double Gaussian Fit')\n",
    "            mainPlot.axvline(threshold, color='c', label='Threshold')\n",
    "            legend()\n",
    "            mainPlot.set_title(\"Gaussian Fits over Histogram, Key Value = \" + str(key[dataInc]) + \"\\nloading =\" + str(atomCount/firstPictureData.size) );\n",
    "            mainPlot.set_ylabel(\"Occurance Count\");\n",
    "            mainPlot.set_xlabel(\"Pixel Counts\");\n",
    "            mainPlot.set_xlim(left=0)\n",
    "\n",
    "            # ### Pixel Count Data Over Time\n",
    "            plot22 = subplot(grid1[0:6, 12:16])\n",
    "            plot22.plot(firstPictureData, \".\", markersize = 1);\n",
    "            plot22.set_title(\"Pixel Count Data Over Time\");\n",
    "            plot22.set_ylabel(\"Count on Pixel\");\n",
    "            plot22.set_xlabel(\"Picture Number\");\n",
    "            \n",
    "            # ### Count Series Plot\n",
    "            plot11 = subplot(gridRight[7:12, 12:16])\n",
    "            plot11.imshow(avgPic);\n",
    "            plot11.set_title(\"Average Image\")\n",
    "            plot11.grid('off')\n",
    "            circ = Circle((atomLocation[1],atomLocation[0]), 0.2, color='r')\n",
    "            plot11.add_artist(circ)\n",
    "        dataInc += 1\n",
    "        \n",
    "    if plotLoadingRate: \n",
    "        figure()\n",
    "        plot(key, loadingRateList, 'bo')\n",
    "        xlabel(\"key value\")\n",
    "        ylabel(\"loading rate\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# Work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-17T14:53:34.620366Z",
     "start_time": "2017-06-17T14:53:34.364718Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x22e8df7f0f0>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABC0AAAH2CAYAAABUTXZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niIiIiIjMS38ApVXfiNFmpOkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x22e8e5bc0b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dacValue = [-0.01, -0.05, 0, 0.005, 0.01, -0.02]#, -0.03]\n",
    "powerInRail = [238, 563, 151.6, 110.2, 67.7, 315]#, 396]\n",
    "#resonantDac = [0.527, 0.608, 0.515, 0.502, 0.487, 0.553, 0.544]\n",
    "resonantDac = [0.527, 0.608, 0.515, 0.502, 0.487, 0.553]#, 0.544]\n",
    "resonanceErr = [0.011, 0.0236, 0.0276, 0.0281, 0.0222, 0.0283 ]#, ...]\n",
    "fitVal, cov = fit(linear, powerInRail, resonantDac, sigma=arr(resonanceErr)/2)\n",
    "xpts = np.linspace(0,1000, 3500)\n",
    "fitData = linear(xpts, *fitVal)\n",
    "errorbar(powerInRail, resonantDac, yerr=resonanceErr, marker='o', linestyle='', label='Data')\n",
    "plot(xpts, fitData, ':', label='fit: y ='+str(round_sig(fitVal[0],3)) + ' x + '+str(round_sig(fitVal[1])))\n",
    "legend()\n",
    "xlabel('Power in Rail (uW)')\n",
    "ylabel('Resonance (Dac Value)')\n",
    "#errbar(powerInRail, resonantDac, 'o', yerr=resonanceerr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "Working backwards in the mathematica notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### some imports and definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:43:06.036772Z",
     "start_time": "2017-06-18T14:43:06.031761Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "from sympy.physics.wigner import wigner_6j\n",
    "def SixJSymbol(a,b,c,d,e,f):\n",
    "    return complex(wigner_6j(a,b,c,d,e,f))\n",
    "from scipy.interpolate import interp1d \n",
    "def Interpolation(data):\n",
    "    return interp1d(data[:,0],data[:,1],kind='cubic')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:43:06.036772Z",
     "start_time": "2017-06-18T14:43:06.031761Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def transpose(l):\n",
    "    # take transpose of list\n",
    "    return list(map(list, zip(*l)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### stuff.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "Note that the reduced dipole matrix values are taken from:\n",
    "\n",
    "Arora and Sahoo, Phys. Rev. A 86 033416 (2012)\n",
    "   \n",
    "And the level energies are taken from:\n",
    "\n",
    "M Safronova and U Safronova, Phys. Rev. A 83 052508 (2011)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T12:12:06.406928Z",
     "start_time": "2017-06-18T12:12:06.393895Z"
    }
   },
   "outputs": [],
   "source": [
    "# e2 here is to convert from cm^-1 to m^1\n",
    "ES12 = -33691e2;\n",
    "keyS12 = [ [\"Index\", \"Level\", \"Energy of Level (in m^-1)\", \"Reduced Dipole Matrix Element (e*a0)\", \"j\"],\n",
    "           [1, \"5p_(1/2)\", -21112e2, 4.227, 1/2],\n",
    "           [2, \"6p_(1/2)\", -9976e2, 0.342, 1/2],\n",
    "           [3, \"7p_(1/2)\", -5856e2, 0.118, 1/2],\n",
    "           [4, \"8p_(1/2)\", -3856e2, 0.061, 1/2],\n",
    "           [5, \"9p_(1/2)\", -2732e2, 0.046, 1/2],\n",
    "           [6, \"5p_(3/2)\", -20874e2, 5.977, 3/2],\n",
    "           [7, \"6p_(3/2)\", -9898e2, 0.553, 3/2],\n",
    "           [8, \"7p_(3/2)\", -5821e2, 0.207, 3/2],\n",
    "           [9, \"8p_(3/2)\", -3837e2, 0.114, 3/2],\n",
    "           [10, \"9p_(3/2)\", -2721e2, 0.074, 3/2]];\n",
    "\n",
    "def OmegaS12HigherLevels(level):\n",
    "    return 2 * pi * c * (np.abs(transpose(keyS12)[2][level + 1] - ES12));\n",
    "def dS12HigherLevels(level):\n",
    "    return (el*a0)*transpose(keyS12)[3][level + 1];\n",
    "def jS12HigherLevels(level): \n",
    "    return transpose(keyS12)[4][level + 1];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T12:11:57.232525Z",
     "start_time": "2017-06-18T12:11:57.212940Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "EP12 = -21112e2;\n",
    "\n",
    "keyP12 = [[\"Index\", \"Level\", \"E of Level (in m^-1)\", \"Reduced Dipole Matrix Element (e*a0)\", \"j\"],\n",
    "          [1, \"5s_(1/2)\",  -33691e2, 4.227, 1/2],\n",
    "          [2, \"6s_(1/2)\",  -13557e2, 4.144, 1/2],\n",
    "          [3, \"7s_(1/2)\",  -7379e2,  0.962, 1/2],\n",
    "          [4, \"8s_(1/2)\",  -4644e2,  0.507, 1/2],\n",
    "          [5, \"9s_(1/2)\",  -3192e2,  0.333, 1/2],\n",
    "          [6, \"10s_(1/2)\", -2321e2,  0.235, 1/2],\n",
    "          [8, \"4d_(3/2)\",  -14335e2, 8.069, 3/2],\n",
    "          [9, \"5d_(3/2)\",  -7990e2,  1.184, 3/2],\n",
    "          [10, \"6d_(3/2)\", -5004e2,  1.002, 3/2],\n",
    "          [11, \"7d_(3/2)\", -3411e2,  0.75,  3/2],\n",
    "          [12, \"8d_(3/2)\", -2469e2,  0.58,  3/2],\n",
    "          [13, \"9d_(3/2)\", -1869e2,  0.45,  3/2]];\n",
    "\n",
    "def OmegaP12HigherLevels(level):\n",
    "   return 2 * pi * c * (np.abs(transpose(keyP12)[2][level + 1] - EP12))\n",
    "\n",
    "def dP12HigherLevels(level):\n",
    "    return (el*a0)*transpose(keyP12)[3][level + 1]\n",
    "\n",
    "def jP12HigherLevels(level):\n",
    "    return transpose(keyP12)[4][level + 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T12:10:26.585974Z",
     "start_time": "2017-06-18T12:10:26.579982Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['j', 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5]"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transpose(keyP12)[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T12:10:05.843361Z",
     "start_time": "2017-06-18T12:10:05.827846Z"
    }
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-222-5a991ff0e7cd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjP12HigherLevels\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-221-6bf47171a230>\u001b[0m in \u001b[0;36mjP12HigherLevels\u001b[0;34m(level)\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mjP12HigherLevels\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlevel\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m     \u001b[1;32mreturn\u001b[0m \u001b[0mtranspose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkeyP12\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mlevel\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "jP12HigherLevels(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### Some Numbers I need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:21:36.314210Z",
     "start_time": "2017-06-18T14:21:36.308694Z"
    }
   },
   "outputs": [],
   "source": [
    "intFromPow = (3415.031398)/(1.0763662990168073e-8)\n",
    "Epsilon0 = 8.85418782e-12\n",
    "LambdaTrap = 852e-9\n",
    "# electron charge??\n",
    "el = 1.60217657e-19;\n",
    "# bohr radius\n",
    "a0 = 0.529e-10;\n",
    "\n",
    "#( 0 for Pi-polarized trapping light (E along quantization axis) *)\n",
    "EpsilonTrap = 0; \n",
    "\n",
    "#this is the complex spherical tensor representation of the trap polarization at the atom, the first\n",
    "# entry is the sigma plus polarization component, the second is the pi-polarized component, and \n",
    "# the third is the sigma minus polarization component.\n",
    "uTrap = [0, 1, 0];\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false",
    "heading_collapsed": true
   },
   "source": [
    "### data from before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T02:11:53.550058Z",
     "start_time": "2017-06-18T02:11:53.494411Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "powCal = [[0.600, 1.712],\n",
    "   [0.610, 1.794],\n",
    "   [0.620, 1.879],\n",
    "   [0.630, 1.968],\n",
    "   [0.640, 2.061],\n",
    "   [0.650, 2.159],\n",
    "   [0.660, 2.261],\n",
    "   [0.670, 2.367],\n",
    "   [0.68, 2.483],\n",
    "   [0.69, 2.602],\n",
    "   [0.70, 2.722],\n",
    "   [0.75, 3.439],\n",
    "   [0.80, 4.332],\n",
    "   [0.825, 4.871],\n",
    "   [0.850, 5.470],\n",
    "   [0.845, 5.342],\n",
    "   [0.875, 6.145],\n",
    "   [0.900, 6.906],\n",
    "   [0.95, 8.71],\n",
    "   [0.975, 9.80],\n",
    "   [1.00, 11.00],\n",
    "   [1.05, 13.89],\n",
    "   [1.10, 17.52],\n",
    "   [1.15, 22.09],\n",
    "   [1.20, 27.89],\n",
    "   [1.25, 35.14],\n",
    "   [1.3, 44.32],\n",
    "   [1.35, 55.81],\n",
    "   [1.40, 70.24],\n",
    "   [1.47, 97.1],\n",
    "   [1.5, 111.8],\n",
    "   [1.6, 176.7],\n",
    "   [1.7, 279.5],\n",
    "   [1.8, 443.1],\n",
    "   [1.9, 703.8],\n",
    "   [2.00, 1119.],\n",
    "   [2.05, 1414.],\n",
    "   [2.10, 1790.],\n",
    "   [2.15, 2263.],\n",
    "   [2.20, 2865.],\n",
    "   [2.25, 3626.],\n",
    "   [2.275, 4086.],\n",
    "   [2.300, 4600.],\n",
    "   [2.325, 5187.],\n",
    "   [2.350, 5837.],\n",
    "   [2.360, 6121.],\n",
    "   [2.375, 6575.],\n",
    "   [2.390, 7070.],\n",
    "   [2.395, 7240.],\n",
    "   [2.400, 7430.],\n",
    "   [2.405, 7610.],\n",
    "   [2.410, 7790],\n",
    "   [2.415, 7980.],\n",
    "   [2.425, 8360.],\n",
    "   [2.45, 9410.],\n",
    "   [2.50, 11970],\n",
    "   [2.55, 15220],\n",
    "   [2.60, 19280],\n",
    "   [2.65, 24500],\n",
    "   [2.70, 31170],\n",
    "   [2.73, 36030],\n",
    "   [2.75, 39660]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T02:14:28.227639Z",
     "start_time": "2017-06-18T02:14:28.220648Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.6  ,  0.61 ,  0.62 ,  0.63 ,  0.64 ,  0.65 ,  0.66 ,  0.67 ,\n",
       "        0.68 ,  0.69 ,  0.7  ,  0.75 ,  0.8  ,  0.825,  0.85 ,  0.845,\n",
       "        0.875,  0.9  ,  0.95 ,  0.975,  1.   ,  1.05 ,  1.1  ,  1.15 ,\n",
       "        1.2  ,  1.25 ,  1.3  ,  1.35 ,  1.4  ,  1.47 ,  1.5  ,  1.6  ,\n",
       "        1.7  ,  1.8  ,  1.9  ,  2.   ,  2.05 ,  2.1  ,  2.15 ,  2.2  ,\n",
       "        2.25 ,  2.275,  2.3  ,  2.325,  2.35 ,  2.36 ,  2.375,  2.39 ,\n",
       "        2.395,  2.4  ,  2.405,  2.41 ,  2.415,  2.425,  2.45 ,  2.5  ,\n",
       "        2.55 ,  2.6  ,  2.65 ,  2.7  ,  2.73 ,  2.75 ])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powCal = arr(powCal)\n",
    "powCal[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T02:14:38.061866Z",
     "start_time": "2017-06-18T02:14:38.055883Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "PowCalInt = Interpolation(powCal);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### Some Calibrations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T01:51:22.370105Z",
     "start_time": "2017-06-18T01:51:22.364622Z"
    }
   },
   "outputs": [],
   "source": [
    "def powOut(setP):\n",
    "    return PowCalInt(volt(setP*10**3)) / 10**3\n",
    "\n",
    "def PowCalInt(powCal):\n",
    "    return Interpolation(powCal)\n",
    "\n",
    "def freqCalInt(freqCal):\n",
    "    return Interpolation(Sort(freqCal));\n",
    "\n",
    "def volt(P):\n",
    "    return 0.479262 + 0.215003 * np.log(P - 0.018189)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### defining the transition..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T01:57:20.716915Z",
     "start_time": "2017-06-18T01:57:20.710900Z"
    },
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "#(*Setting this to 3/2 calculates light shifts of the F=2 -> F'=3 transition*)\n",
    "Je = 3/2\n",
    "\n",
    "if Je == 1/2:\n",
    "    def DeltaEtransition(I0, Fg, mFg, Fe, mFe):\n",
    "        return DeltaEP12(Fe, mFe, I0) - DeltaES12(Fg, mFg, I0)\n",
    "   \n",
    "if Je == 3/2:\n",
    "    def DeltaEtransition(I0, Fg, mFg, Fe, mFe):\n",
    "        # ??? This was in brians code...\n",
    "        print(\"Incorrect selection for J excited\")\n",
    "        return DeltaEP32(Fe, mFe, I0) - DeltaES12(Fg, mFg, I0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### Some Atomic Physics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:57:20.488316Z",
     "start_time": "2017-06-18T14:57:20.461247Z"
    }
   },
   "outputs": [],
   "source": [
    "def DeltaES12(Fg, mFg, I0):\n",
    "    first = -(1/4) * ((2 * I0)/(c * Epsilon0))\n",
    "    print(first)\n",
    "    second = AlphaScalarS12(Fg, mFg)\n",
    "    print(second)\n",
    "    third =  Ccoeff * AlphaVectorS12(Fg, mFg) * mFg / (2 * Fg)  \n",
    "    print(third)\n",
    "    fourth = - Dcoeff * AlphaTensorS12(Fg, mFg) * (3 *mFg**2 - Fg * (Fg + 1))/( 2 * Fg * (2 * Fg - 1)) \n",
    "    print(fourth)\n",
    "    return first * (second + third + fourth)\n",
    "\n",
    "def AlphaScalarS12(Fg, mFg): \n",
    "    return 1 / np.sqrt(3 * (2 * 1/2 + 1)) * AlphaReducedS12(0, (2 * pi * c) / LambdaTrap)\n",
    "\n",
    "def AlphaReducedS12(Kappa, OmegaTrap):\n",
    "    J = 1/2\n",
    "    #GammaJpJ = 6.1*MHz\n",
    "    GammaJpJ = 6.1e6\n",
    "    \n",
    "    const = (-1)**(J + Kappa + 1) * np.sqrt(2 * Kappa + 1)\n",
    "    print('reduced const', const)\n",
    "    sumTerm = 0\n",
    "    for i in range(0, len(keyS12)-1):\n",
    "        sumTerm += ((-1)**jS12HigherLevels(i) * SixJSymbol(1, Kappa, 1, J, jS12HigherLevels(i), J) \n",
    "                    * dS12HigherLevels(i)**2 * 1/hbar * np.real(1/(OmegaS12HigherLevels(i) - OmegaTrap - \n",
    "                    1j*GammaJpJ / 2) + (-1)**Kappa/(OmegaS12HigherLevels(i) + OmegaTrap + 1j*GammaJpJ/2)))\n",
    "    return  const * sumTerm\n",
    "            \n",
    "def AlphaVectorS12(Fg, mFg):\n",
    "    return ((-1)**(1/2 + 3/2 + Fg) * np.sqrt((2 * Fg * (2 * Fg + 1))/(Fg + 1)) * SixJSymbol(Fg, 1, Fg, 1/2, 3/2, 1/2)\n",
    "            * AlphaReducedS12(1, (2 * pi * c)/LambdaTrap))\n",
    "\n",
    "def AlphaTensorS12(Fg, mFg):\n",
    "    return ((-1)**(1/2 + 3/2 + Fg + 1) * np.sqrt((2 * Fg * (2 * Fg - 1) * (2 * Fg + 1))/(3 * (Fg + 1) * (2 * Fg + 3))) \n",
    "        * SixJSymbol(Fg, 2, Fg, 1/2, 3/2, 1/2) * AlphaReducedS12(2, (2 * pi * c)/LambdaTrap))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### Final Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:44:56.320297Z",
     "start_time": "2017-06-18T14:44:56.313278Z"
    }
   },
   "outputs": [],
   "source": [
    "Ccoeff = np.conj(uTrap[2]) * uTrap[2] - np.conj(uTrap[0]) * uTrap[0];\n",
    "\n",
    "Dcoeff = 1 - 3 * np.conj(uTrap[1]) * uTrap[1];\n",
    "\n",
    "def depthFin(Pin):\n",
    "    return trapDepth(intFromPow*(powOut(Pin)*1e-3)) # 1000 is for mw\n",
    "    \n",
    "def trapDepth(I0):\n",
    "    # this gives the trap depth in mK\n",
    "    # 1e-3 converts to mk\n",
    "    return DeltaES12(2, 2, I0)/(k_B * 1e-3)\n",
    "\n",
    "def CyclingShift(I0):\n",
    "    DeltaEtransition(I0, 2, 2, 3, 3) / (2 * Pi * hbar * MHz)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "Collapsed": "false"
   },
   "source": [
    "### testing area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:57:22.554376Z",
     "start_time": "2017-06-18T14:57:22.540337Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-417345434932.0\n",
      "reduced const (-1.8369701987210297e-16-1j)\n",
      "(3.40812366817e-38-1.08994811711e-53j)\n",
      "reduced const (5.302876193624535e-16+1.7320508075688772j)\n",
      "0j\n",
      "reduced const (-9.584377219623547e-16-2.23606797749979j)\n",
      "0j\n",
      "-1.0302148197244965\n"
     ]
    }
   ],
   "source": [
    "print(np.real(depthFin(7.15)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:43:26.857101Z",
     "start_time": "2017-06-18T14:43:26.752965Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAAASCAYAAADczdVTAAAABHNCSVQICAgIfAhkiAAABf1JREFU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\nAABJRU5ErkJggg==\n",
      "text/latex": [
       "$$6.98329657915$$"
      ],
      "text/plain": [
       "6.98329657915"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powOut(7.15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:38:20.390173Z",
     "start_time": "2017-06-18T14:38:20.384653Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2215619078.85\n"
     ]
    }
   ],
   "source": [
    "term = intFromPow * powOut(7.15) * 1e-3\n",
    "print(term)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:52:45.322457Z",
     "start_time": "2017-06-18T14:52:45.308918Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-417345434932.0\n",
      "(2.08474258558e-38-7.65813235739e-54j)\n",
      "0j\n",
      "0j\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(-8.7005780110121829e-27+3.1960865794579044e-42j)"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DeltaES12(2,2,term)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:40:52.000025Z",
     "start_time": "2017-06-18T14:40:51.917209Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACgAAAATCAYAAADiQ08DAAAABHNCSVQICAgIfAhkiAAAAZtJREFU\nSInt1sFLFVEUBvBfQQSJWLStePDQ2gnWImjj27Ru0cp/Idr0F9SqoJCgjasK6g9oWS1qIUKEqKtM\nRXptCneWKdmiWswZna7vIs/nCIEHLh/zne+c+83MnXuHw+gqbuEPxkriaCK4jkeYxPcQP+9hwjN4\njC/YRBsPcSqjvxQ4nWs4F6bWMN+jwSZWoscL3MObuP6I0x1qzuECjuSatjAYgtEeDb6K+psJPx78\nxB77bsWovRtsRu0nO5dRP35gHX0VvhU196vitHi/ohX4Gr+T3BqmcAKXK/xI4ExVXJfB84GLmfxS\n4FCFO1CDA4HfMvmSP1nhRhSv/p+bqstgt9GneJrlLrIVdRksn9BAJl/yq4HD4WUmFdZlcCFwKJMf\nDCxfZ7n+ZlNhXQbfBl7tMEc/rmAD74Lr+IHoUNxtNBU7/7GEX1ZsMQ3cSHJ3FGvumWIvLA3+xIfd\nJryGpzFeKhbscoV7kOjboWlkzFePuru2j7oF20fdcfzC+93Mwe1okBvtLgzCWTzB1zDx2c6fhYv2\n6eg7jP8y/gJymmNnUFT1hgAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$$1.0 i$$"
      ],
      "text/plain": [
       "1.0⋅ⅈ"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.N(sp.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {
    "Collapsed": "false",
    "ExecuteTime": {
     "end_time": "2017-06-18T14:54:11.014370Z",
     "start_time": "2017-06-18T14:54:11.004843Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reduced const (-1.8369701987210297e-16-1j)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(5.1065555797333622e-38-1.8758516658300697e-53j)"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AlphaReducedS12(0, (2 * pi * c) / LambdaTrap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "Collapsed": "false",
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "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.9"
  },
  "nav_menu": {},
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": true,
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "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": 4
}