{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Basic Calculation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `crystal17.basic` plugin is the simplest calculation plugin.\n", "It accepts as input:\n", "\n", "- a pre-written `main.d12` file and,\n", "- (optionally) a `main.gui` file with geometry,\n", " to accompany a `main.d12` file containing the `EXTERNAL` keyword." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initial Setup" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To run a computation, first ensure AiiDA is running:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m ✓ \u001b[0mprofile: On profile test_profile\u001b[0m\r\n", "\u001b[32m ✓ \u001b[0mrepository: /var/folders/dm/b2qnkb_n3r72slmpxlfmcjvm00lbnd/T/tmpt_morsq7/test_repo\u001b[0m\r\n", "\u001b[32m ✓ \u001b[0mpostgres: Connected as aiida@localhost:51390\u001b[0m\r\n", "\u001b[32m ✓ \u001b[0mrabbitmq: Connected to amqp://127.0.0.1?heartbeat=600\u001b[0m\r\n", "\u001b[32m ✓ \u001b[0mdaemon: Daemon is running as PID 96578 since 2019-08-12 14:08:06\u001b[0m\r\n" ] } ], "source": [ "!verdi status" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ":::{seealso}\n", "AiiDA documentation: {ref}`aiida:intro:get_started`\n", ":::" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If `aiida-crystal17` is installed,\n", "the `crystal17.basic` computation should be available:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "tags": [ "nbreg_compare_output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-\b/\b|\b\\\b-\b/\b|\b\u001b[31m\u001b[1mInputs\u001b[0m\r\n", "\u001b[1m code: required Code The Code to use for this job.\u001b[0m\r\n", "\u001b[1m input_file: required SinglefileData the input .d12 file content.\u001b[0m\r\n", " input_external: optional SinglefileData optional input fort.34 (gui) file content (for use with EXTERNAL keyword).\u001b[0m\r\n", " metadata: optional \u001b[0m\r\n", "\u001b[31m\u001b[1mOutputs\u001b[0m\r\n", "\u001b[1m remote_folder: required RemoteData Input files necessary to run the process will be stored in this folder node ...\u001b[0m\r\n", "\u001b[1m results: required Dict the data extracted from the main output file\u001b[0m\r\n", "\u001b[1m retrieved: required FolderData Files that are retrieved by the daemon will be stored in this node. By defa ...\u001b[0m\r\n", " structure: optional StructureData the structure output from the calculation\u001b[0m\r\n", " symmetry: optional SymmetryData the symmetry data from the calculation\u001b[0m\r\n", "\u001b[31m\u001b[1mExit codes\u001b[0m\r\n", " 1: The process has failed with an unspecified error.\u001b[0m\r\n", " 2: The process failed with legacy failure mode.\u001b[0m\r\n", " 10: The process returned an invalid output.\u001b[0m\r\n", " 11: The process did not register a required output.\u001b[0m\r\n", " 200: The retrieved folder data node could not be accessed.\u001b[0m\r\n", " 210: The main (stdout) output file was not found\u001b[0m\r\n", " 211: The temporary retrieved folder was not found\u001b[0m\r\n", " 300: An error was flagged trying to parse the crystal exec stdout file\u001b[0m\r\n", " 301: An error occurred parsing the 'opta'/'optc' geometry files\u001b[0m\r\n", " 302: The crystal exec stdout file denoted that the run was a testgeom\u001b[0m\r\n", " 350: The input file could not be read by crystal\u001b[0m\r\n", " 351: Crystal could not find the required wavefunction file\u001b[0m\r\n", " 400: The calculation stopped prematurely because it ran out of walltime.\u001b[0m\r\n", " 401: The calculation stopped prematurely because it ran out of memory.\u001b[0m\r\n", " 402: The calculation stopped prematurely because it ran out of virtual memory.\u001b[0m\r\n", " 411: Scf convergence did not finalise (usually due to reaching step limit)\u001b[0m\r\n", " 412: Geometry convergence did not finalise (usually due to reaching step limit)\u001b[0m\r\n", " 413: An error encountered usually during geometry optimisation\u001b[0m\r\n", " 414: An error was encountered during an scf computation\u001b[0m\r\n", " 415: An unknown error was encountered, causing the mpi to abort\u001b[0m\r\n", " 499: The main crystal output file flagged an unhandled error\u001b[0m\r\n", " 510: Inconsistency in the input and output symmetry\u001b[0m\r\n", " 520: Primitive symmops were not found in the output file\u001b[0m\r\n" ] } ], "source": [ "!verdi plugin list aiida.calculations crystal17.basic" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To use the python interface, first ensure a profile is loaded in the python kernel, and import the required modules:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "init_cell": true }, "outputs": [ { "data": { "text/plain": [ "'test_crystal17'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from aiida import load_profile\n", "profile = load_profile()\n", "profile.name" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "init_cell": true }, "outputs": [], "source": [ "import os\n", "from aiida_crystal17.common import display_json\n", "from aiida_crystal17.tests import open_resource_binary\n", "from aiida.orm import Code\n", "from aiida.engine import run_get_node\n", "from aiida.plugins import DataFactory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Input Creation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ":::{seealso}\n", "AiiDA documentation: {ref}`aiida:how-to:run-codes`\n", "\n", "[CRYSTAL17 Manual](http://www.crystal.unito.it/Manuals/crystal17.pdf)\n", ":::" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An {py:class}`~aiida.orm.nodes.data.code.Code` node should be set up in advance,\n", "to use the `crystal17.basic` calculation plugin,\n", "and call the ``runcry17`` executable\n", "(or ``mock_runcry17`` used here for test purposes)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[['PK', 1],\n", " ['UUID', '9bbbc497-a8d5-4265-a3f9-6eda89c14a1c'],\n", " ['Label', 'crystal17.basic-mock_crystal17@localhost'],\n", " ['Description', ''],\n", " ['Default plugin', 'crystal17.basic'],\n", " ['Type', 'remote'],\n", " ['Remote machine', 'localhost'],\n", " ['Remote absolute path',\n", " '//anaconda/envs/aiida_crystal17/bin/mock_crystal17'],\n", " ['Prepend text', 'No prepend text'],\n", " ['Append text', 'No append text']]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from aiida_crystal17.tests.utils import get_or_create_local_computer, get_or_create_code\n", "computer = get_or_create_local_computer('work_directory', 'localhost')\n", "code = get_or_create_code('crystal17.basic', computer, 'mock_crystal17')\n", "code.get_full_text_info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An {py:class}`~aiida.orm.nodes.data.singlefile.SinglefileData` node is then set containing the main input file." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MgO bulk\n", "CRYSTAL\n", "0 0 0\n", " 225\n", "4.21\n", "2\n", " 12 0. 0. 0.\n", " 8 0.5 0.5 0.5\n", "END\n", "12 3\n", "1 0 3 2. 0.\n", "1 1 3 8. 0.\n", "1 1 3 2. 0.\n", "8 2\n", "1 0 3 2. 0.\n", "1 1 3 6. 0.\n", "99 0\n", "END\n", "SHRINK\n", "8 8\n", "END\n" ] } ], "source": [ "SinglefileData = DataFactory('singlefile')\n", "with open_resource_binary('crystal', 'mgo_sto3g_scf', 'INPUT') as handle:\n", " infile = SinglefileData(file=handle)\n", "\n", "with infile.open() as handle:\n", " print(handle.read())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setting Up and Running the Calculation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ":::{seealso}\n", "AiiDA documentation: {ref}`aiida:topics:processes`\n", ":::" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A builder can be obtained from the `Code` node,\n", "which will define all the required input nodes and settings:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "```json\n", "{\n", " \"metadata\": {\n", " \"options\": {\n", " \"withmpi\": false,\n", " \"resources\": {\n", " \"num_machines\": 1,\n", " \"num_mpiprocs_per_machine\": 1\n", " }\n", " }\n", " },\n", " \"code\": [\n", " \"Remote code 'crystal17.basic-mock_crystal17@localhost' on localhost,\",\n", " \"pk: 1, uuid: 9bbbc497-a8d5-4265-a3f9-6eda89c14a1c\"\n", " ],\n", " \"input_file\": [\n", " \"uuid: a2aa4ddf-d438-426e-9b1b-f6b7ba3ea7b6 (unstored)\"\n", " ]\n", "}\n", "```" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "builder = code.get_builder()\n", "builder.metadata.options.withmpi = False\n", "builder.metadata.options.resources = {\n", " \"num_machines\": 1,\n", " \"num_mpiprocs_per_machine\": 1}\n", "builder.input_file = infile\n", "display_json(builder)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In order to run the computation,\n", "the builder can be parsed to one of the AiiDA ``run`` (blocking execution) or ``submit`` (non-blocking execution) functions:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "result, calcnode = run_get_node(builder)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The process can be monitored on the command line:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-\b/\b|\b\\\b-\b/\b|\b\\\b\u001b[22m PK Created Process label Process State Process status\r\n", "---- --------- ------------------- --------------- ----------------\r\n", " 3 16s ago CryBasicCalculation ⏹ Finished [0]\u001b[0m\r\n", "\u001b[22m\r\n", "Total results: 1\r\n", "\u001b[0m\r\n", "\u001b[34m\u001b[1mInfo: \u001b[0m\u001b[22mlast time an entry changed state: 2s ago (at 13:08:30 on 2019-08-12)\u001b[0m\r\n" ] } ], "source": [ "!verdi process list -a -l 1 -D desc" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the calculation is complete, a ``CalcJobNode`` will be created,\n", "to store the settings and outcome of the computation.\n", "Crucially, if the computation has completed successfully,\n", "the `exit_status` will be **0**.\n", "\n", "This can be assessed on the command line or with the python API." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-\b/\b|\b\\\b-\b/\b|\b\u001b[22mProperty Value\r\n", "------------- ------------------------------------\r\n", "type CalcJobNode\r\n", "pk 3\r\n", "uuid 22f461b9-1fa6-46ce-980b-5be137a985db\r\n", "label\r\n", "description\r\n", "ctime 2019-08-12 13:08:16.459048+00:00\r\n", "mtime 2019-08-12 13:08:30.163635+00:00\r\n", "process state Finished\r\n", "exit status 0\r\n", "computer [1] localhost\r\n", "\r\n", "Inputs PK Type\r\n", "---------- ---- --------------\r\n", "code 1 Code\r\n", "input_file 2 SinglefileData\r\n", "\r\n", "Outputs PK Type\r\n", "------------- ---- -------------\r\n", "remote_folder 4 RemoteData\r\n", "results 6 Dict\r\n", "retrieved 5 FolderData\r\n", "structure 7 StructureData\r\n", "symmetry 8 SymmetryData\u001b[0m\r\n" ] } ], "source": [ "!verdi process show {calcnode.pk}" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "tags": [ "nbreg_compare_output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "ProcessState.FINISHED\n", "0\n" ] } ], "source": [ "print(calcnode.is_finished_ok)\n", "print(calcnode.process_state)\n", "print(calcnode.exit_status)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the calculation fails, there are three things that should be checked:\n", "\n", "1. The calculation's exit_message\n", "2. The calculation's log messages and scheduler output\n", "3. The `results` output node (if available)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exit Message: None\n", "*** 3: None\n", "*** (empty scheduler output file)\n", "*** (empty scheduler errors file)\n", "*** 0 LOG MESSAGES\n" ] } ], "source": [ "print(\"Exit Message:\", calcnode.exit_message)\n", "from aiida.cmdline.utils.common import get_calcjob_report\n", "print(get_calcjob_report(calcnode))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-\b/\b|\b\\\b-\b/\b|\b\u001b[22m*** 3: None\r\n", "*** (empty scheduler output file)\r\n", "*** (empty scheduler errors file)\r\n", "*** 0 LOG MESSAGES\u001b[0m\r\n" ] } ], "source": [ "!verdi process report {calcnode.pk}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis of Outputs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The {py:class}`aiida.tools.visualization.graph.Graph` can be used to visualise the calculations provenance graph:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ipub": { "figure": { "caption": "`crystal17.basic` calculation provenance graph." } } }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "%3\n", "\n", "\n", "\n", "N3\n", "\n", "CryBasicCalculation (3)\n", "State: finished\n", "Exit Code: 0\n", "\n", "\n", "\n", "N8\n", "\n", "SymmetryData (8)\n", "symmops: 48\n", "\n", "\n", "\n", "N3->N8\n", "\n", "\n", "CREATE\n", "symmetry\n", "\n", "\n", "\n", "N7\n", "\n", "StructureData (7)\n", "MgO\n", "\n", "\n", "\n", "N3->N7\n", "\n", "\n", "CREATE\n", "structure\n", "\n", "\n", "\n", "N6\n", "\n", "Dict (6)\n", "\n", "\n", "\n", "N3->N6\n", "\n", "\n", "CREATE\n", "results\n", "\n", "\n", "\n", "N5\n", "\n", "FolderData (5)\n", "\n", "\n", "\n", "N3->N5\n", "\n", "\n", "CREATE\n", "retrieved\n", "\n", "\n", "\n", "N4\n", "\n", "RemoteData (4)\n", "@localhost\n", "\n", "\n", "\n", "N3->N4\n", "\n", "\n", "CREATE\n", "remote_folder\n", "\n", "\n", "\n", "N2\n", "\n", "SinglefileData (2)\n", "INPUT\n", "\n", "\n", "\n", "N2->N3\n", "\n", "\n", "INPUT_CALC\n", "input_file\n", "\n", "\n", "\n", "N1\n", "\n", "Code (1)\n", "mock_crystal17@localhost\n", "\n", "\n", "\n", "N1->N3\n", "\n", "\n", "INPUT_CALC\n", "code\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from aiida.tools.visualization import Graph\n", "graph = Graph(graph_attr={'size': \"6,8!\", \"rankdir\": \"LR\"})\n", "graph.add_node(calcnode)\n", "graph.add_incoming(calcnode, annotate_links=\"both\")\n", "graph.add_outgoing(calcnode, annotate_links=\"both\")\n", "graph.graphviz" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `retrieved` `FolderData` output node contains the CRYSTAL17 main output file." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['_scheduler-stderr.txt', '_scheduler-stdout.txt', 'main.out']" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "calcnode.outputs.retrieved.list_object_names()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `results` `Dict` output node contains key values extracted from the CRYSTAL17 main output file." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "```json\n", "{\n", " \"units\": {\n", " \"angle\": \"degrees\",\n", " \"energy\": \"eV\",\n", " \"length\": \"angstrom\",\n", " \"conversion\": \"CODATA2014\"\n", " },\n", " \"energy\": -7380.2216051903,\n", " \"errors\": [],\n", " \"header\": {\n", " \"crystal_version\": 17,\n", " \"crystal_subversion\": \"1.0.1\"\n", " },\n", " \"volume\": 18.65461525,\n", " \"warnings\": [],\n", " \"calculation\": {\n", " \"n_ao\": 14,\n", " \"spin\": false,\n", " \"type\": \"restricted closed shell\",\n", " \"n_atoms\": 2,\n", " \"n_shells\": 5,\n", " \"n_symops\": 48,\n", " \"n_core_el\": 12,\n", " \"n_electrons\": 20,\n", " \"n_kpoints_ibz\": 29,\n", " \"n_kpoints_gilat\": 29\n", " },\n", " \"energy_units\": \"eV\",\n", " \"parser_class\": \"CryMainParser\",\n", " \"parser_errors\": [],\n", " \"parser_version\": \"0.11.0\",\n", " \"scf_iterations\": 7,\n", " \"number_of_atoms\": 2,\n", " \"parser_warnings\": [\n", " \"no initial structure available, creating new kinds for atoms\"\n", " ],\n", " \"parser_exceptions\": [],\n", " \"number_of_assymetric\": 2,\n", " \"execution_time_seconds\": 3\n", "}\n", "```" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display_json(calcnode.outputs.results.attributes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `structure` `StructureData` output node contains the final structure,\n", "obtained from the CRYSTAL17 main output file." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ipub": { "figure": { "caption": "Structure visualisation, using ASE and Matplotlib." } } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "from ase.visualize.plot import plot_atoms\n", "atoms = calcnode.outputs.structure.get_ase()\n", "fig, ax = plt.subplots()\n", "plot_atoms(atoms.repeat((4,4,4)),\n", " ax, radii=0.8, show_unit_cell=True,\n", " rotation=('45x,0y,0z'));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `symmetry` `SymmetryData` output node contains the symmetry of the final structure,\n", "obtained from the CRYSTAL17 main output file." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'basis': 'fractional', 'num_symops': 48, 'hall_number': None}\n" ] }, { "data": { "text/plain": [ "[[1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [1.0, 0.0, 0.0, -1.0, -1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, 1.0, 1.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, 0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, 0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, 1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, 0.0, 0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, 1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, 0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [-1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, 0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, -1.0, 0.0, -1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n", " [0.0, -1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n", " [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, -1.0, -1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 0.0, 0.0, 1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0],\n", " [-1.0, -1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n", " [1.0, 0.0, 0.0, -1.0, -1.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]]" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(calcnode.outputs.symmetry.attributes)\n", "calcnode.outputs.symmetry.data.operations" ] } ], "metadata": { "celltoolbar": "Slideshow", "hide_input": false, "jupytext": { "formats": "ipynb,myst:myst" }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.7" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "256px" }, "toc_section_display": true, "toc_window_display": true } }, "nbformat": 4, "nbformat_minor": 2 }