{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Import supporting package" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import xarray as xr\n", "import numpy as np\n", "import copy\n", "\n", "from uncertainties import ufloat\n", "from uncertainties import unumpy as unp\n", "from uncertainties import umath\n", "import random\n", "import matplotlib.pyplot as plt\n", "plt.rcParams['font.size'] = 12\n", "\n", "from DataContainer.ReadData import read_hdf5_file\n", "from Analyser.ImagingAnalyser import ImageAnalyser\n", "from Analyser.FitAnalyser import FitAnalyser\n", "from Analyser.FitAnalyser import NewFitModel, DensityProfileBEC2dModel\n", "from ToolFunction.ToolFunction import *\n", "\n", "from scipy.optimize import curve_fit\n", "\n", "from ToolFunction.HomeMadeXarrayFunction import errorbar, dataarray_plot_errorbar\n", "xr.plot.dataarray_plot.errorbar = errorbar\n", "xr.plot.accessor.DataArrayPlotAccessor.errorbar = dataarray_plot_errorbar\n", "\n", "imageAnalyser = ImageAnalyser()\n", "\n", "# %matplotlib notebook" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Start a client for parallel computing" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "
\n", "
\n", "

Client

\n", "

Client-f69f7e77-14be-11ee-a66c-80e82ce2fa8e

\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", " Dashboard: http://127.0.0.1:8787/status\n", "
\n", "\n", " \n", "\n", " \n", "
\n", "

Cluster Info

\n", "
\n", "
\n", "
\n", "
\n", "

LocalCluster

\n", "

cbd5084a

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", " \n", "
\n", " Dashboard: http://127.0.0.1:8787/status\n", " \n", " Workers: 8\n", "
\n", " Total threads: 128\n", " \n", " Total memory: 149.01 GiB\n", "
Status: runningUsing processes: True
\n", "\n", "
\n", " \n", "

Scheduler Info

\n", " \n", "\n", "
\n", "
\n", "
\n", "
\n", "

Scheduler

\n", "

Scheduler-0b555d69-83fd-43e1-9215-9c67aeb6d78c

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Comm: tcp://127.0.0.1:61752\n", " \n", " Workers: 8\n", "
\n", " Dashboard: http://127.0.0.1:8787/status\n", " \n", " Total threads: 128\n", "
\n", " Started: Just now\n", " \n", " Total memory: 149.01 GiB\n", "
\n", "
\n", "
\n", "\n", "
\n", " \n", "

Workers

\n", " \n", "\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 0

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61792\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61794/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61755\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-vwm7x29k\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 1

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61793\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61798/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61756\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-dsm02jmm\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 2

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61810\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61811/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61757\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-kb6dkrm1\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 3

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61775\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61790/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61758\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-vtzwx9iy\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 4

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61804\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61806/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61759\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-a97vh11n\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 5

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61796\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61801/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61760\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-2jc_h5j9\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 6

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61797\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61800/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61761\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-mvwb15rr\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 7

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:61805\n", " \n", " Total threads: 16\n", "
\n", " Dashboard: http://127.0.0.1:61808/status\n", " \n", " Memory: 18.63 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:61762\n", "
\n", " Local directory: C:\\Users\\data\\AppData\\Local\\Temp\\dask-worker-space\\worker-co4d63m7\n", "
\n", "
\n", "
\n", "
\n", " \n", "\n", "
\n", "
\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "\n", "
\n", "
" ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from dask.distributed import Client\n", "client = Client(n_workers=8, threads_per_worker=16, processes=True, memory_limit='20GB')\n", "client" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Start a client for Mongo DB" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import pymongo\n", "import xarray_mongodb\n", "\n", "from DataContainer.MongoDB import MongoDB\n", "\n", "mongoClient = pymongo.MongoClient('mongodb://control:DyLab2021@127.0.0.1:27017/?authMechanism=DEFAULT')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Set global path for experiment" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "groupList = [\n", " \"images/MOT_3D_Camera/in_situ_absorption\",\n", " \"images/ODT_1_Axis_Camera/in_situ_absorption\",\n", " \"images/ODT_2_Axis_Camera/in_situ_absorption\",\n", "]\n", "\n", "dskey = {\n", " \"images/MOT_3D_Camera/in_situ_absorption\": \"camera_0\",\n", " \"images/ODT_1_Axis_Camera/in_situ_absorption\": \"camera_1\",\n", " \"images/ODT_2_Axis_Camera/in_situ_absorption\": \"camera_2\",\n", "}\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "img_dir = 'C:/Users/control/DyLab/Experiments/DyBEC/'\n", "SequenceName = \"Repetition_scan\"\n", "folderPath = img_dir + SequenceName + \"/\" + get_date()\n", "\n", "mongoDB = mongoClient[SequenceName]\n", "\n", "DB = MongoDB(mongoClient, mongoDB, date=get_date())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Repetition Scans" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## scan MOT freq - Z Comp 0" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0001\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in range(len(groupList))\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_1\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (310, 825)\n", "imageAnalyser.span = (550, 1200)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = Ncount.mean(dim='runs')\n", "Ncount_std = Ncount.std(dim='runs')\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "plt.xlabel('MOT AOM Freq (MHz)')\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "DB.create_global(shotNum, dataSet)\n", "DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## scan Push freq" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0002\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in range(len(groupList))\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_1\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (310, 825)\n", "imageAnalyser.span = (525, 1255)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "plt.xlabel('Push AOM Freq (MHz)')\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "DB.create_global(shotNum, dataSet)\n", "DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## scan Z comp current" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0005\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in range(len(groupList))\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_1\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (305, 875)\n", "imageAnalyser.span = (400, 400)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "plt.xlabel('comp Z current (A)')\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "DB.create_global(shotNum, dataSet)\n", "DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## scan cMOT final Amp" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "shotNum = \"0006\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in range(len(groupList))\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_1\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (305, 875)\n", "imageAnalyser.span = (400, 400)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "plt.xlabel('cMOT final Amp (%)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 25000])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "DB.create_global(shotNum, dataSet)\n", "DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0011\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in range(len(groupList))\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_1\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (305, 875)\n", "imageAnalyser.span = (400, 400)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "plt.xlabel('comp Z current (A)')\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "DB.create_global(shotNum, dataSet)\n", "DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Evaporative Cooling" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "img_dir = '//DyLabNAS/Data/'\n", "SequenceName = \"Evaporative_Cooling\"\n", "#folderPath = img_dir + SequenceName + \"/\" + get_date()\n", "folderPath = img_dir + SequenceName + \"/2023/06/20\"\n", "\n", "mongoDB = mongoClient[SequenceName]\n", "\n", "DB = MongoDB(mongoClient, mongoDB, date=get_date())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Calibration of the magnetic fields" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.119 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0004\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -6000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 2.9576, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 6000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(2.9445, 2.9601, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 3500])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.189 A, 0.25 Vpp" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0008\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], maxFileNum = 100, excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -6000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 4.25, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 6000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(4.2375, 4.266, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 3500])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.189 A, 0.5 Vpp" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0009\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], maxFileNum = 100, excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -6000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 4.25, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 6000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(4.23, 4.275, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 3500])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.189 A, 1 Vpp" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0010\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], maxFileNum = 100, excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -6000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 4.25, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 6000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(4.23, 4.275, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 3500])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.189 A, 3 Vpp" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0011\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], maxFileNum = 80, excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -6000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 4.25, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 6000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(4.22, 4.275, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.ylim([0, 3500])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Scan Z offset field during evaporation" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The detected scaning axes and values are: \n", "\n", "{'compZ_current_sg': array([0.18 , 0.182, 0.184, 0.186, 0.188, 0.19 , 0.192, 0.194, 0.196,\n", " 0.198, 0.2 , 0.202, 0.204, 0.206, 0.208, 0.21 , 0.212, 0.214,\n", " 0.216, 0.218, 0.22 ]), 'runs': array([0., 1., 2.])}\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "shotNum = \"0015\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (890, 880)\n", "imageAnalyser.span = (150, 150)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='-ob')\n", "plt.xlabel('comp Z current (A)')\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()\n", "\n", "# DB.create_global(shotNum, dataSet)\n", "# DB.add_data(shotNum, dataSet_cropOD, engine='xarray')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure()\n", "\n", "data = dataSet_cropOD.sel(compZ_current_sg = 0.198, runs=0)\n", "data = data.assign_coords(x=data.x * 2.352 * 5.86)\n", "data = data.assign_coords(y=data.y * 2.352 * 5.86)\n", "\n", "data.plot.pcolormesh(cmap='jet', vmin=0, vmax=2)\n", "\n", "plt.title('')\n", "plt.xlabel('x ($\\mu m$)')\n", "plt.ylabel('y ($\\mu m$)')\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "f:\\Jianshun\\analyseScript\\Analyser\\FitAnalyser.py:86: RuntimeWarning: invalid value encountered in power\n", " res = (1- ((x-centerx)/(sigmax))**2 - ((y-centery)/(sigmay))**2)**(3 / 2)\n" ] } ], "source": [ "data = dataSet_cropOD.sel(compZ_current_sg = 0.198, runs=0)\n", "\n", "fitModel = DensityProfileBEC2dModel()\n", "fitAnalyser_1 = FitAnalyser(fitModel, fitDim=2)\n", "\n", "params = fitAnalyser_1.guess(data, dask=\"parallelized\")\n", "\n", "fitResult_1 = fitAnalyser_1.fit(data, params).load()\n", "\n", "# x = np.linspace(2.7725, 2.822, 500)\n", "# y = np.linspace(2.7725, 2.822, 500)\n", "# fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=x, y=y, dask=\"parallelized\").load()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\data\\AppData\\Roaming\\Python\\Python39\\site-packages\\numpy\\lib\\function_base.py:2246: RuntimeWarning: invalid value encountered in _get_fit_full_result_single (vectorized)\n", " outputs = ufunc(*inputs)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:              ()\n",
       "Coordinates:\n",
       "    compZ_current_sg     float64 0.198\n",
       "    runs                 float64 0.0\n",
       "Data variables:\n",
       "    BEC_amplitude        object 792.7896024042066+/-nan\n",
       "    thermal_amplitude    object 0.0+/-nan\n",
       "    BEC_centerx          object 72.03322637975705+/-nan\n",
       "    BEC_centery          object 74.15709273093088+/-nan\n",
       "    thermal_centerx      object 73.1219837873983+/-nan\n",
       "    thermal_centery      object 75.0675362391377+/-nan\n",
       "    BEC_sigmax           object 25.92336716503899+/-nan\n",
       "    BEC_sigmay           object 10.643305951751195+/-nan\n",
       "    thermal_sigmax       object 17.18976684635309+/-nan\n",
       "    thermal_sigmay       object 14.449859669689275+/-nan\n",
       "    thermalAspectRatio   object 0.8406082408706373+/-nan\n",
       "    condensate_fraction  object 1.0+/-nan\n",
       "Attributes:\n",
       "    IMAGE_SUBCLASS:       IMAGE_GRAYSCALE\n",
       "    IMAGE_VERSION:        1.2\n",
       "    IMAGE_WHITE_IS_ZERO:  0\n",
       "    x_start:              815\n",
       "    x_end:                965\n",
       "    y_end:                955\n",
       "    y_start:              805\n",
       "    x_center:             890\n",
       "    y_center:             880\n",
       "    x_span:               150\n",
       "    y_span:               150
" ], "text/plain": [ "\n", "Dimensions: ()\n", "Coordinates:\n", " compZ_current_sg float64 0.198\n", " runs float64 0.0\n", "Data variables:\n", " BEC_amplitude object 792.7896024042066+/-nan\n", " thermal_amplitude object 0.0+/-nan\n", " BEC_centerx object 72.03322637975705+/-nan\n", " BEC_centery object 74.15709273093088+/-nan\n", " thermal_centerx object 73.1219837873983+/-nan\n", " thermal_centery object 75.0675362391377+/-nan\n", " BEC_sigmax object 25.92336716503899+/-nan\n", " BEC_sigmay object 10.643305951751195+/-nan\n", " thermal_sigmax object 17.18976684635309+/-nan\n", " thermal_sigmay object 14.449859669689275+/-nan\n", " thermalAspectRatio object 0.8406082408706373+/-nan\n", " condensate_fraction object 1.0+/-nan\n", "Attributes:\n", " IMAGE_SUBCLASS: IMAGE_GRAYSCALE\n", " IMAGE_VERSION: 1.2\n", " IMAGE_WHITE_IS_ZERO: 0\n", " x_start: 815\n", " x_end: 965\n", " y_end: 955\n", " y_start: 805\n", " x_center: 890\n", " y_center: 880\n", " x_span: 150\n", " y_span: 150" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fitAnalyser_1.get_fit_full_result(fitResult_1)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.1654007155341837" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "792.7896024042066 * 147 /1e5" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Calibration of the magnetic fields - after connecting the Z coils to the HiPPS" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.119 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0035\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -5000, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 2.8, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 5000, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(2.7725, 2.822, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.140 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0044\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -2500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 3.177, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 2500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(3.158, 3.198, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.200 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0048\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -4500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 4.275, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 4500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(4.260, 4.289, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.259 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0056\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -4500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 5.3, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 4500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(5.34, 5.364, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.329 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0059\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -4500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 6.636, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 4500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(6.62, 6.655, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.419 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0063\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -1500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 8.286, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.1, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 1500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(8.27, 8.305, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "img_dir = 'C:/Users/control/DyLab/Experiments/DyBEC/'\n", "SequenceName = \"Evaporative_Cooling\"\n", "folderPath = img_dir + SequenceName + \"/\" + get_date()\n", "\n", "mongoDB = mongoClient[SequenceName]\n", "\n", "DB = MongoDB(mongoClient, mongoDB, date=get_date())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Z Offset field = 0.489 A" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib notebook\n", "shotNum = \"0002\"\n", "filePath = folderPath + \"/\" + shotNum + \"/*.h5\"\n", "\n", "dataSetDict = {\n", " dskey[groupList[i]]: read_hdf5_file(filePath, groupList[i], excludeAxis = ['sweep_start_freq', 'sweep_stop_freq'])\n", " for i in [0]\n", "}\n", "\n", "dataSet = dataSetDict[\"camera_0\"]\n", "\n", "print_scanAxis(dataSet)\n", "\n", "scanAxis = get_scanAxis(dataSet)\n", "\n", "dataSet = auto_rechunk(dataSet)\n", "\n", "dataSet = imageAnalyser.get_absorption_images(dataSet)\n", "\n", "imageAnalyser.center = (160, 880)\n", "imageAnalyser.span = (250, 250)\n", "imageAnalyser.fraction = (0.1, 0.1)\n", "\n", "dataSet_cropOD = imageAnalyser.crop_image(dataSet.OD)\n", "dataSet_cropOD = imageAnalyser.substract_offset(dataSet_cropOD).load()\n", "\n", "Ncount = imageAnalyser.get_Ncount(dataSet_cropOD)\n", "Ncount_mean = calculate_mean(Ncount)\n", "Ncount_std = calculate_std(Ncount)\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "\n", "plt.ylabel('NCount')\n", "plt.tight_layout()\n", "#plt.ylim([0, 3500])\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "Ncount_mean_1 = Ncount_mean\n", "Ncount_std_1 = Ncount_std\n", "\n", "fitAnalyser_1 = FitAnalyser(\"Gaussian With Offset\", fitDim=1)\n", "# params = fitAnalyser.guess(Ncount_mean_1, x=scanAxis[0], guess_kwargs=dict(negative=True), dask=\"parallelized\")\n", "params = fitAnalyser_1.fitModel.make_params()\n", "params.add(name=\"amplitude\", value= -2500, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"center\", value= 9.575, max=np.inf, min=-np.inf, vary=True)\n", "params.add(name=\"sigma\", value= 0.2, max=np.inf, min= 0, vary=True)\n", "params.add(name=\"offset\", value= 2500, max=np.inf, min=-np.inf, vary=True)\n", "\n", "fitResult_1 = fitAnalyser_1.fit(Ncount_mean_1, params, x=scanAxis[0]).load()\n", "freqdata = np.linspace(9.555, 9.595, 500)\n", "fitCurve_1 = fitAnalyser_1.eval(fitResult_1, x=freqdata, dask=\"parallelized\").load()\n", "fitCurve_1 = fitCurve_1.assign_coords({'x':np.array(freqdata)})\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "\n", "Ncount_mean.plot.errorbar(ax=ax, yerr = Ncount_std, fmt='ob')\n", "fitCurve_1.plot.errorbar(ax=ax, fmt='--g')\n", "plt.xlabel('Center Frequency (MHz)')\n", "plt.ylabel('NCount')\n", "#plt.xlim([2.7828, 2.81625])\n", "plt.tight_layout()\n", "plt.grid(visible=1)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f_1 = fitAnalyser_1.get_fit_value(fitResult_1).center\n", "df_1 = fitAnalyser_1.get_fit_std(fitResult_1).center\n", "\n", "print('f = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(f_1)* 1e3,df_1* 1e3]))\n", "\n", "s_1 = fitAnalyser_1.get_fit_value(fitResult_1).sigma\n", "ds_1 = fitAnalyser_1.get_fit_std(fitResult_1).sigma\n", "\n", "fwhm_1 = 2.3548200*s_1 * 1e3\n", "dfwhm_1 = 2.3548200*ds_1 * 1e3\n", "\n", "print('fwhm = %.5f \\u00B1 %.5f kHz'% tuple([np.abs(fwhm_1),dfwhm_1]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = [2798.24971, 3178.49790, 4275.39905, 5352.17283, 6637.80418, 8288.35264, 9573.59333]\n", "df = [0.36873, 0.29413, 0.20667, 0.20818, 0.21978, 0.20285, 0.18495]\n", "z_offset_current = [0.119, 0.140, 0.2, 0.259, 0.329, 0.419, 0.489]\n", "\n", "f_fit = f\n", "df_fit = df\n", "z_offset_current_fit = z_offset_current\n", "\n", "\n", "x = np.array(z_offset_current_fit)\n", "y = np.array(f_fit)\n", "\n", "# Degree of the fitting polynomial\n", "deg = 1\n", "# Parameters from the fit of the polynomial\n", "p = np.polyfit(x, y, deg)\n", "m = p[0] # Gradient\n", "c = p[1] # y-intercept\n", "\n", "#print(f'The fitted straight line has equation y = {m:.1f}x {c:=+6.1f}')\n", "\n", "# Model the data using the parameters of the fitted straight line\n", "y_model = np.polyval(p, x)\n", "\n", "# Create the linear (1 degree polynomial) model\n", "model = np.poly1d(p)\n", "# Fit the model\n", "y_model = model(x)\n", "\n", "# Mean\n", "y_bar = np.mean(y)\n", "# Coefficient of determination, R²\n", "R2 = np.sum((y_model - y_bar)**2) / np.sum((y - y_bar)**2)\n", "\n", "#print(f'R² = {R2:.2f}')\n", "\n", "fitted_SlopeInkHz = m\n", "fitted_offsetInkHz = c\n", "muB = 9.274e-24\n", "hbar = 6.626e-34 / (2 * np.pi)\n", "gJ = 1.24\n", "Slope = (((2 * np.pi * fitted_SlopeInkHz * 1e3)*hbar) / (muB*gJ)) * 1e4\n", "Offset = (((2 * np.pi * fitted_offsetInkHz * 1e3)*hbar) / (muB*gJ)) * 1e4\n", "\n", "def calib_fit(x, B):\n", " alpha = ((2 * np.pi * fitted_SlopeInkHz * 1e3)*hbar) / (muB*gJ)\n", " beta = ((2 * np.pi * fitted_offsetInkHz * 1e3)*hbar) / (muB*gJ)\n", " delta_nu = ((muB * gJ) / hbar) * np.sqrt((B**2-beta**2) + ((alpha * x) + beta)**2)\n", " return delta_nu / (2 * np.pi * 1e3)\n", "\n", "\n", "popt, pcov = curve_fit(calib_fit, z_offset_current, f, np.array([0.1*1e-4]))\n", "Boffset = popt[0] * 1e4\n", "dBoffset = pcov[0][0]**0.5 * 1e4\n", "\n", "fig = plt.figure()\n", "ax = fig.gca()\n", "plt.clf\n", "#plt.scatter(z_offset_current, f, c='gray', marker='o', edgecolors='k', s=30)\n", "plt.errorbar(z_offset_current, f, yerr=df, fmt='o')\n", "xvals = np.linspace(0, 0.5, 500)\n", "plt.plot(np.array(xvals), p[1] + p[0] * np.array(xvals), label=f'Line Fit')\n", "plt.plot(xvals, calib_fit(xvals, *popt), label=f'Curve Fit')\n", "plt.text(0.25, 2200, f'Line Slope = {Slope:.3f} G/A', fontsize=12)\n", "plt.text(0.25, 1500, f'Line Offset = {Offset:=.3f} G', fontsize=12)\n", "plt.text(0.25, 800, f'Bo= {Boffset:=.3f} +/- {dBoffset:=.3f} G', fontsize=12)\n", "plt.xlabel('Z Offset Coil Current (A)', fontsize=12)\n", "plt.ylabel('Resonance Frequency (kHz)', fontsize=12)\n", "plt.xticks(fontsize=12)\n", "plt.yticks(fontsize=12)\n", "plt.legend(fontsize=12)\n", "#plt.xlim(-0.01, 0.04)\n", "#plt.ylim(0, 2000)\n", "plt.grid(visible=1)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ "l = list(np.arange(9.555, 9.595, 0.002))\n", "# l = np.logspace(np.log10(250e-6), np.log10(500e-3), num=15)\n", "\n", "l = [round(item, 7) for item in l]\n", "#random.shuffle(l)\n", "\n", "print(l)\n", "print(len(l))\n", "np.mean(l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pixel = 5.86e-6\n", "M = 0.6827\n", "F = (1/(0.3725*8.4743e-14)) * (pixel / M)**2\n", "NCount = 85000\n", "AtomNumber = NCount * F / 1e8\n", "print(AtomNumber)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "muB = 9.274e-24\n", "hbar = 6.626e-34 / (2 * np.pi)\n", "gJ = 1.24\n", "Delta = 2 * np.pi * 9573.59333 * 1e3\n", "\n", "Bz = (Delta*hbar) / (muB*gJ)\n", "print(Bz * 1e4)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## ODT 1 Calibration" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "v_high = 2.7\n", "\"\"\"High Power\"\"\"\n", "P_arm1_high = 5.776 * v_high - 0.683\n", "\n", "v_mid = 0.2076\n", "\"\"\"Intermediate Power\"\"\"\n", "P_arm1_mid = 5.815 * v_mid - 0.03651\n", "\n", "v_low = 0.0587\n", "\"\"\"Low Power\"\"\"\n", "P_arm1_low = 5271 * v_low - 27.5\n", "\n", "print(round(P_arm1_high, 3))\n", "print(round(P_arm1_mid, 3))\n", "print(round(P_arm1_low, 3))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## ODT 2 Power Calibration" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "v = 0.7607\n", "P_arm2 = 2.302 * v - 0.06452\n", "print(round(P_arm2, 3))" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.12" }, "vscode": { "interpreter": { "hash": "c05913ad4f24fdc6b2418069394dc5835b1981849b107c9ba6df693aafd66650" } } }, "nbformat": 4, "nbformat_minor": 2 }