diff --git a/examples/AIMMDB_Tiled_Tutorial.ipynb b/examples/AIMMDB_Tiled_Tutorial.ipynb new file mode 100644 index 0000000..a0abd73 --- /dev/null +++ b/examples/AIMMDB_Tiled_Tutorial.ipynb @@ -0,0 +1,1695 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "3XEk4VVi483l" + }, + "source": [ + "## Table of Contents\n", + "* 1 - [Access data from a web browser](#section-1)\n", + "* 2 - [Access data using Tiled's Python client](#section-2)\n", + " * 2.1 - [Setup kernel and required dependencies](#section-21)\n", + " * 2.2 - [Read and download data](#section-22)\n", + " * 2.3 - [Visualization and data analysis](#section-23)\n", + " * 2.4 - [Log into an Authenticated Tiled Server](#section-24)\n", + "\n", + "Note that the output of this notebook was generated using [Google Colab](https://colab.research.google.com/).\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t2YtaEtj6w35" + }, + "source": [ + "## 1 - Access data from a web browser\n", + "\n", + "Click the first tab on https://aimm.lbl.gov/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C0aLBAhQ7qr2" + }, + "source": [ + "## 2 - Access data using Tiled's Python client\n", + "### 2.1 - Setup kernel and required dependencies\n", + "**Tiled** is a data access service for data-aware portals and data science tools. Tiled has a Python client and integrates naturally with Python data science libraries, but nothing about the service is Python-specific; it also works from a web browser or any Internet-connected program.\n", + "\n", + "You can find a detailed **Tiled** document here: https://blueskyproject.io/tiled/tutorials/installation.html" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "611FyYOCruGJ", + "outputId": "8a484589-7e67-4455-b005-411ae02a32af" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting tiled[client]\n", + " Downloading tiled-0.1.0a112-py3-none-any.whl (1.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: appdirs in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (1.4.4)\n", + "Collecting awkward>=2.4.3 (from tiled[client])\n", + " Downloading awkward-2.5.2-py3-none-any.whl (742 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m742.2/742.2 kB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting blosc (from tiled[client])\n", + " Downloading blosc-1.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.5/2.5 MB\u001b[0m \u001b[31m15.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: click!=8.1.0 in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (8.1.7)\n", + "Requirement already satisfied: dask[array] in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (2023.8.1)\n", + "Requirement already satisfied: entrypoints in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (0.4)\n", + "Collecting httpx!=0.23.1,>=0.20.0 (from tiled[client])\n", + " Downloading httpx-0.26.0-py3-none-any.whl (75 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.9/75.9 kB\u001b[0m \u001b[31m929.6 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: jsonschema in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (4.19.2)\n", + "Collecting lz4 (from tiled[client])\n", + " Downloading lz4-4.3.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m14.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: msgpack>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (1.0.7)\n", + "Collecting ndindex (from tiled[client])\n", + " Downloading ndindex-1.7-py3-none-any.whl (85 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m85.7/85.7 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (1.23.5)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (1.5.3)\n", + "Requirement already satisfied: pyarrow in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (10.0.1)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (6.0.1)\n", + "Collecting sparse (from tiled[client])\n", + " Downloading sparse-0.15.1-py2.py3-none-any.whl (116 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: typer in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (0.9.0)\n", + "Requirement already satisfied: xarray in /usr/local/lib/python3.10/dist-packages (from tiled[client]) (2023.7.0)\n", + "Collecting zstandard (from tiled[client])\n", + " Downloading zstandard-0.22.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (5.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.4/5.4 MB\u001b[0m \u001b[31m27.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting awkward-cpp==28 (from awkward>=2.4.3->tiled[client])\n", + " Downloading awkward_cpp-28-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (706 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m706.4/706.4 kB\u001b[0m \u001b[31m17.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: importlib-metadata>=4.13.0 in /usr/local/lib/python3.10/dist-packages (from awkward>=2.4.3->tiled[client]) (7.0.1)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from awkward>=2.4.3->tiled[client]) (23.2)\n", + "Requirement already satisfied: typing-extensions>=4.1.0 in /usr/local/lib/python3.10/dist-packages (from awkward>=2.4.3->tiled[client]) (4.5.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx!=0.23.1,>=0.20.0->tiled[client]) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx!=0.23.1,>=0.20.0->tiled[client]) (2023.11.17)\n", + "Collecting httpcore==1.* (from httpx!=0.23.1,>=0.20.0->tiled[client])\n", + " Downloading httpcore-1.0.2-py3-none-any.whl (76 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.9/76.9 kB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx!=0.23.1,>=0.20.0->tiled[client]) (3.6)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx!=0.23.1,>=0.20.0->tiled[client]) (1.3.0)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx!=0.23.1,>=0.20.0->tiled[client])\n", + " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: cloudpickle>=1.5.0 in /usr/local/lib/python3.10/dist-packages (from dask[array]->tiled[client]) (2.2.1)\n", + "Requirement already satisfied: fsspec>=2021.09.0 in /usr/local/lib/python3.10/dist-packages (from dask[array]->tiled[client]) (2023.6.0)\n", + "Requirement already satisfied: partd>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from dask[array]->tiled[client]) (1.4.1)\n", + "Requirement already satisfied: toolz>=0.10.0 in /usr/local/lib/python3.10/dist-packages (from dask[array]->tiled[client]) (0.12.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas->tiled[client]) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->tiled[client]) (2023.3.post1)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema->tiled[client]) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema->tiled[client]) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema->tiled[client]) (0.32.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema->tiled[client]) (0.16.2)\n", + "Requirement already satisfied: scipy>=0.19 in /usr/local/lib/python3.10/dist-packages (from sparse->tiled[client]) (1.11.4)\n", + "Requirement already satisfied: numba>=0.49 in /usr/local/lib/python3.10/dist-packages (from sparse->tiled[client]) (0.58.1)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.10/dist-packages (from importlib-metadata>=4.13.0->awkward>=2.4.3->tiled[client]) (3.17.0)\n", + "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.49->sparse->tiled[client]) (0.41.1)\n", + "Requirement already satisfied: locket in /usr/local/lib/python3.10/dist-packages (from partd>=1.2.0->dask[array]->tiled[client]) (1.0.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.1->pandas->tiled[client]) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx!=0.23.1,>=0.20.0->tiled[client]) (1.2.0)\n", + "Installing collected packages: zstandard, tiled, ndindex, lz4, h11, blosc, awkward-cpp, sparse, httpcore, awkward, httpx\n", + "Successfully installed awkward-2.5.2 awkward-cpp-28 blosc-1.11.1 h11-0.14.0 httpcore-1.0.2 httpx-0.26.0 lz4-4.3.3 ndindex-1.7 sparse-0.15.1 tiled-0.1.0a112 zstandard-0.22.0\n" + ] + } + ], + "source": [ + "# Install Tiled from PyPI using pip\n", + "!pip install \"tiled[client]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jLZMR8gjODEP" + }, + "source": [ + "### 2.2 - Read and download data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BdoABDMurx5L" + }, + "outputs": [], + "source": [ + "# connect with client\n", + "from tiled.client import from_uri\n", + "\n", + "client = from_uri(\"https://aimm.lbl.gov\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KSfWXEsWr9Qz", + "outputId": "503a80c1-46fe-4e09-9f7a-2f79c798b422" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "liNBeFEV_Dow" + }, + "source": [ + "`client` holds a nested structure of data. Conceptually, it corresponds well to a directory of files or hierarchical structure like an HDF5 file or XML file.\n", + "\n", + "Tiled provides a utility for visualizing a nested structure. Each (sub)tree displays the names of a couple of its entries—up to however many fit on one line.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pAjnGK5m_C66", + "outputId": "4064d3d3-885d-4cbf-bd3e-f3a05a1859f3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "├── newville\n", + "│ ├── 25AKcQNYmJG\n", + "│ ├── 2C8GsD3CCB3\n", + "│ ├── 2DKJLMZPi8s\n", + "│ ├── 2jRSGYmbd56\n", + "│ ├── 386Vs5S24DC\n", + "│ ├── 3ChbS59SHVR\n", + "│ ├── 3e7RZRJAWJB\n", + "│ ├── 3h2NCNmJY57\n", + "│ ├── 3jyVzUb6SMg\n", + "│ ├── 3pGgpiqJpd4\n", + "│ ├── 47E9w6mjVoH\n", + "│ ├── 4BAGPyvPJjn\n", + "│ ├── 4p7baCNseu2\n", + "│ ├── 4TtCKV3J7Wn\n", + "│ ├── 4VaxabvkAAB\n", + "│ ├── 5sG6ha6cnqg\n", + "│ ├── 5syrCXRVqXk\n", + "│ ├── 5wB34QCoW5q\n", + "│ ├── 68ThTdcGneG\n", + "\n" + ] + } + ], + "source": [ + "from tiled.utils import tree\n", + "tree(client)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9dG8jxIb_ZkQ" + }, + "source": [ + "`Containers` act like (nested) mappings in Python. All the (read-only) methods that work on Python dictionaries work on Containers. We can lookup a specific value by its key." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "79f0pNXpz1vx", + "outputId": "4bb64947-8608-4f95-c37d-73361d790d2e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qLkXvf79_gY9" + }, + "source": [ + "list all the keys." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0A5p_E2Stj6Y", + "outputId": "d809d623-82e1-4306-f16f-7e8ca53319a0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['newville', 'nmc_sim_structure', 'nmc_sim', 'nmc_sim_vasp']" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(client)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZlfARXNHsAsm", + "outputId": "d6482c04-1f61-4b1a-f4f9-190dffbb05f3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client['newville']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jnH6teuwsCuz", + "outputId": "299b3ce3-13b9-45c8-83b4-c1d8019ae4d2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client['newville']['2DKJLMZPi8s']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9KIsSXwGNnyu" + }, + "source": [ + "To read data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "7INhruoMvVJX", + "outputId": "c7293d8b-6b0c-4c2a-ed6b-ab5e2d292d48" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " energy\n", + " i0\n", + " itrans\n", + " irefer\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 11634.890\n", + " 522870.31\n", + " 93227.473667\n", + " 38013.990388\n", + " \n", + " \n", + " 1\n", + " 11644.908\n", + " 520022.31\n", + " 93078.545736\n", + " 38184.020421\n", + " \n", + " \n", + " 2\n", + " 11654.944\n", + " 517087.31\n", + " 92891.462192\n", + " 38341.986093\n", + " \n", + " \n", + " 3\n", + " 11664.998\n", + " 514413.31\n", + " 92754.484191\n", + " 38505.995152\n", + " \n", + " \n", + " 4\n", + " 11675.070\n", + " 511248.31\n", + " 92509.505530\n", + " 38641.000495\n", + " \n", + " \n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " \n", + " \n", + " 408\n", + " 12860.495\n", + " 1304307.90\n", + " 212641.539366\n", + " 115721.545351\n", + " \n", + " \n", + " 409\n", + " 12866.269\n", + " 1305841.80\n", + " 213373.930600\n", + " 116433.334046\n", + " \n", + " \n", + " 410\n", + " 12872.408\n", + " 1309225.10\n", + " 214432.009149\n", + " 117344.741918\n", + " \n", + " \n", + " 411\n", + " 12878.555\n", + " 1311274.00\n", + " 215239.521752\n", + " 118120.626724\n", + " \n", + " \n", + " 412\n", + " 12885.069\n", + " 1312508.50\n", + " 215960.489212\n", + " 118851.993943\n", + " \n", + " \n", + "\n", + "413 rows × 4 columns\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n" + ], + "text/plain": [ + " energy i0 itrans irefer\n", + "0 11634.890 522870.31 93227.473667 38013.990388\n", + "1 11644.908 520022.31 93078.545736 38184.020421\n", + "2 11654.944 517087.31 92891.462192 38341.986093\n", + "3 11664.998 514413.31 92754.484191 38505.995152\n", + "4 11675.070 511248.31 92509.505530 38641.000495\n", + ".. ... ... ... ...\n", + "408 12860.495 1304307.90 212641.539366 115721.545351\n", + "409 12866.269 1305841.80 213373.930600 116433.334046\n", + "410 12872.408 1309225.10 214432.009149 117344.741918\n", + "411 12878.555 1311274.00 215239.521752 118120.626724\n", + "412 12885.069 1312508.50 215960.489212 118851.993943\n", + "\n", + "[413 rows x 4 columns]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client['newville']['2DKJLMZPi8s'].read()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tj_plDvVNvTs" + }, + "source": [ + "To read slices of data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "LD0ycDlcNu0-", + "outputId": "aef08994-7751-4274-eb48-3a40d8b99197" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " energy\n", + " i0\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 11634.890\n", + " 522870.31\n", + " \n", + " \n", + " 1\n", + " 11644.908\n", + " 520022.31\n", + " \n", + " \n", + " 2\n", + " 11654.944\n", + " 517087.31\n", + " \n", + " \n", + " 3\n", + " 11664.998\n", + " 514413.31\n", + " \n", + " \n", + " 4\n", + " 11675.070\n", + " 511248.31\n", + " \n", + " \n", + " ...\n", + " ...\n", + " ...\n", + " \n", + " \n", + " 408\n", + " 12860.495\n", + " 1304307.90\n", + " \n", + " \n", + " 409\n", + " 12866.269\n", + " 1305841.80\n", + " \n", + " \n", + " 410\n", + " 12872.408\n", + " 1309225.10\n", + " \n", + " \n", + " 411\n", + " 12878.555\n", + " 1311274.00\n", + " \n", + " \n", + " 412\n", + " 12885.069\n", + " 1312508.50\n", + " \n", + " \n", + "\n", + "413 rows × 2 columns\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n" + ], + "text/plain": [ + " energy i0\n", + "0 11634.890 522870.31\n", + "1 11644.908 520022.31\n", + "2 11654.944 517087.31\n", + "3 11664.998 514413.31\n", + "4 11675.070 511248.31\n", + ".. ... ...\n", + "408 12860.495 1304307.90\n", + "409 12866.269 1305841.80\n", + "410 12872.408 1309225.10\n", + "411 12878.555 1311274.00\n", + "412 12885.069 1312508.50\n", + "\n", + "[413 rows x 2 columns]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client['newville']['2DKJLMZPi8s'].read(['energy', 'i0'])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SbitOnXkOYds" + }, + "source": [ + "The Tiled server can encode its structures in various formats for exporting data. These are just a couple of the supported formats:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sCnQ-wLpOG6w" + }, + "outputs": [], + "source": [ + "# Table\n", + "client['newville']['2DKJLMZPi8s'].export(\"table.xlsx\") # Excel\n", + "client['newville']['2DKJLMZPi8s'].export(\"table.csv\") # CSV\n", + "\n", + "# Array\n", + "client['newville']['2DKJLMZPi8s'].export(\"numbers.csv\") # CSV\n", + "# client['newville']['2DKJLMZPi8s'].export(\"image.png\") # PNG image\n", + "# client['newville']['2DKJLMZPi8s'].export(\"image.tiff\") # TIFF image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xSxpVbrAO6Ph" + }, + "source": [ + "If running this notebook on Google Colab, click the folder sign on the left panel and you will see the exported files, right click to download to your local machine." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "165CoOVROG8n" + }, + "outputs": [], + "source": [ + "# Export just some of the columns...\n", + "# client['newville']['2DKJLMZPi8s'].export(\"table.csv\", columns=[\"energy\", \"i0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1QgVv9u6Q5Wb" + }, + "source": [ + "### 2.3 - Visualization and data analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "Nt_cqdqFwcZu", + "outputId": "592e2718-e627-4a88-fc85-7ff67fee9738" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "energy_data = client['newville']['2DKJLMZPi8s'].read(['energy'])\n", + "i0_data = client['newville']['2DKJLMZPi8s'].read(['i0'])\n", + "\n", + "plt.plot(energy_data, i0_data)\n", + "plt.xlabel('Energy')\n", + "plt.ylabel('i0')\n", + "plt.title('Energy vs i0 Plot')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "RgiE5P5vRQ_h", + "outputId": "ee93822c-4d32-4f67-ce4e-a08b1e1ed15b" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(energy_data, bins=50, color='blue', alpha=0.7)\n", + "plt.title('Energy Histogram')\n", + "plt.xlabel('Values')\n", + "plt.ylabel('Frequency')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CuIak7-zRvzZ" + }, + "source": [ + "\n", + "## 2.4 Log into an Authenticated Tiled Server\n", + "So that you can access private dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qk7sUInyto1u", + "outputId": "7cb97f0a-c459-44b4-e2b7-c6a89dd60855" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "You have 15 minutes visit this URL\n", + "\n", + " https://orcid.org/oauth/authorize?client_id=APP-0ROS9DU5F717F7XN&response_type=code&scope=openid&redirect_uri=https%3A%2F%2Faimm.lbl.gov%2Fapi%2Fv1%2Fauth%2Fprovider%2Forcid%2Fdevice_code\n", + "\n", + "and enter the code:\n", + "\n", + " 6F62-8B7D\n", + "\n", + "\n", + "Waiting.......\n", + "You have logged in with ORCID as 0000-0001-8312-1470\n" + ] + } + ], + "source": [ + "client.login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NrQCq4uLuC6e", + "outputId": "6c5827c9-8a78-40fc-9fa8-eefa5228a5b5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "client" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rOwzNdh9uNRj", + "outputId": "8a619ebc-322f-4f46-f46d-ed24e1099b75" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['aimm_core',\n", + " 'heald',\n", + " 'iss',\n", + " 'iss-raw',\n", + " 'newville',\n", + " 'nmc',\n", + " 'nmc_electrochem',\n", + " 'nmc_sim_structure',\n", + " 'nmc_sim',\n", + " 'nmc_sim_vasp']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(client)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tjdHaFS8uRG5" + }, + "outputs": [], + "source": [ + "wanli_dataset = client['aimm_core']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "BlEIzj8IuV1o", + "outputId": "4180f230-4aef-48df-a578-631cb876de76" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " energy\n", + " mu\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 839.988000\n", + " 0.078059\n", + " \n", + " \n", + " 1\n", + " 840.013022\n", + " 0.071357\n", + " \n", + " \n", + " 2\n", + " 840.038044\n", + " 0.064934\n", + " \n", + " \n", + " 3\n", + " 840.063065\n", + " 0.058785\n", + " \n", + " \n", + " 4\n", + " 840.088087\n", + " 0.052903\n", + " \n", + " \n", + " ...\n", + " ...\n", + " ...\n", + " \n", + " \n", + " 1995\n", + " 889.906440\n", + " 3.211171\n", + " \n", + " \n", + " 1996\n", + " 889.931462\n", + " 3.231664\n", + " \n", + " \n", + " 1997\n", + " 889.956484\n", + " 3.252252\n", + " \n", + " \n", + " 1998\n", + " 889.981506\n", + " 3.272934\n", + " \n", + " \n", + " 1999\n", + " 890.006527\n", + " 3.293711\n", + " \n", + " \n", + "\n", + "2000 rows × 2 columns\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n" + ], + "text/plain": [ + " energy mu\n", + "0 839.988000 0.078059\n", + "1 840.013022 0.071357\n", + "2 840.038044 0.064934\n", + "3 840.063065 0.058785\n", + "4 840.088087 0.052903\n", + "... ... ...\n", + "1995 889.906440 3.211171\n", + "1996 889.931462 3.231664\n", + "1997 889.956484 3.252252\n", + "1998 889.981506 3.272934\n", + "1999 890.006527 3.293711\n", + "\n", + "[2000 rows x 2 columns]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wanli_dataset['4yk5nB7RvRN'].read()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qd6XJtkSSbQ4" + }, + "source": [ + "Now log out via:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1PX79QRNul_s" + }, + "outputs": [], + "source": [ + "client.logout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "plULB7QOScjJ" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}
413 rows × 4 columns
413 rows × 2 columns
2000 rows × 2 columns