From 3d0305f1f2393f72c988f8323c74e926e47a26a2 Mon Sep 17 00:00:00 2001 From: Sylvain Tricot Date: Sun, 15 Jun 2025 16:32:42 +0200 Subject: [PATCH] Add Activity01 --- Activity01/Activity01.ipynb | 613 ++++++++++++++++++++++++++++++++++ Activity01/copper.cif | 51 +++ Activity01/copper_3planes.cif | 47 +++ 3 files changed, 711 insertions(+) create mode 100644 Activity01/Activity01.ipynb create mode 100644 Activity01/copper.cif create mode 100644 Activity01/copper_3planes.cif diff --git a/Activity01/Activity01.ipynb b/Activity01/Activity01.ipynb new file mode 100644 index 0000000..50a9d1c --- /dev/null +++ b/Activity01/Activity01.ipynb @@ -0,0 +1,613 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7e31b322-df55-44ed-9f29-6f6efa71eafe", + "metadata": {}, + "source": [ + "# Activity 1: Getting started\n", + "\n", + "MsSpec is a Fortran code with two components: Phagen (Written by R. Natoli) and Spec (written by D. Sébilleau). Phagen computes the phase shifts of the electronic wave propagating in the matter on a spherical harmonics basis. Spec uses those phase shifts to compute the multiple scattering process and simulate the intensity of different electronic spectroscopies.\n", + "\n", + "In the most recent version of MsSpec, the program is interfaced with python (https://msspec.cnrs.fr/), allowing for much more flexibility and interplay with other simulation techniques.\n", + "\n", + "## Building atomic systems\n", + "\n", + "MsSpec works in the *cluster* approach. Building such a cluster for a calculation is a fundamental step.\n", + "We use the [python Atomic Simulation Environment (ASE)](https://wiki.fysik.dtu.dk/ase/) for this.\n", + "\n", + "ASE is a set of tools and Python modules for setting up, manipulating, running, visualizing and analyzing atomistic simulations.\n", + "Building atomic systems, structures... is pretty straightforward:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "07a04c8c-a268-481a-8f1b-14878ed771b5", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1dc57d2ee20b4192b4bd4866b23d1fd1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b8abba5c2984e43a644c4d448a4ea26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(NGLWidget(), VBox(children=(Dropdown(description='Show', options=('All', 'O', 'H'), value='All'…" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# To build a molecule with ASE\n", + "from ase.build import molecule\n", + "# To view\n", + "from ase.visualize import view\n", + "\n", + "# Only for jupyter\n", + "import nglview\n", + "from functools import partial\n", + "view = partial(view, viewer='ngl')\n", + "\n", + "# Create a water molecule\n", + "water = molecule('H2O')\n", + "# Display it\n", + "view(water)" + ] + }, + { + "cell_type": "markdown", + "id": "94b690a2-52f0-43e4-953d-6e7519ac4e9c", + "metadata": {}, + "source": [ + "## Barebone script for MsSpec\n", + "\n", + "MsSpec can simulate different electronic spectroscopies like PED, AED, LEED, EXAFS, APECS and more will be included in the forthcoming version. However, it is really well-suited for PhotoElectron Diffraction simulation, and the python interface is only fully available for it at the moment. Since PED covers all the MsSpec features and concepts, we will focus on this technique.\n", + "\n", + "There are typically 3 steps to follow to get a result with MsSpec:\n", + "\n", + "1. Create a *cluster*\n", + "2. Create an ASE *calculator*\n", + "3. Run the simulation\n", + "\n", + "### PED polar scan for Cu(001)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6ddd72a9-8f32-484f-9a3e-9ab3a85945a4", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'NoneType' object has no attribute 'upper'\n", + "'integrals' is ignored since the 'spinpol' global parameter is set to False. Enable spin polarization in the constructor of your Calculator if you want to use this option.\n", + "The sample temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n", + "The sample Debye temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " _________________________________________________________________\n", + "\n", + " PHAGEN\n", + " _________________________________________________________________\n", + "\n", + " -----------------------------------------------------------------\n", + " parameters for this xpd calculation:\n", + " -----------------------------------------------------------------\n", + " edge= l3\n", + " potype= hedin norman= stdcrm absorber= 1\n", + " coor= angs emin= 23.25 Ry emax= 23.25 Ry\n", + " delta= 0.300 Ry gamma= 0.00 Ry eftri= 0.000 Ry\n", + " cip= 0.00 Ry lmaxt= 19 charelx: ex\n", + " ionization state : neutral\n", + " relativistic corrections of type: nr\n", + " final state potential generated internally\n", + "\n", + "\n", + " Computes the T-matrix and radial matrix elements \n", + "\n", + "\n", + " coordinates in angstroms Radii\n", + " -----------------------------------------------------------------\n", + " Cu 29 7.2000 7.2000 2.7000 0.0000 0.0000\n", + " Cu 29 3.6000 7.2000 2.7000 0.0000 0.0000\n", + " Cu 29 3.6000 7.2000 6.3000 0.0000 0.0000\n", + " Cu 29 5.4000 5.4000 2.7000 0.0000 0.0000\n", + " Cu 29 7.2000 3.6000 2.7000 0.0000 0.0000\n", + " Cu 29 7.2000 5.4000 0.9000 0.0000 0.0000\n", + " Cu 29 5.4000 5.4000 6.3000 0.0000 0.0000\n", + " Cu 29 7.2000 3.6000 6.3000 0.0000 0.0000\n", + " Cu 29 7.2000 5.4000 4.5000 0.0000 0.0000\n", + " Cu 29 5.4000 7.2000 0.9000 0.0000 0.0000\n", + " Cu 29 5.4000 9.0000 2.7000 0.0000 0.0000\n", + " Cu 29 7.2000 9.0000 0.9000 0.0000 0.0000\n", + " Cu 29 5.4000 7.2000 4.5000 0.0000 0.0000\n", + " Cu 29 5.4000 9.0000 6.3000 0.0000 0.0000\n", + " Cu 29 7.2000 7.2000 6.3000 0.0000 0.0000\n", + " Cu 29 7.2000 9.0000 4.5000 0.0000 0.0000\n", + " Cu 29 7.2000 10.8000 2.7000 0.0000 0.0000\n", + " Cu 29 7.2000 10.8000 6.3000 0.0000 0.0000\n", + " Cu 29 9.0000 5.4000 2.7000 0.0000 0.0000\n", + " Cu 29 9.0000 5.4000 6.3000 0.0000 0.0000\n", + " Cu 29 9.0000 7.2000 0.9000 0.0000 0.0000\n", + " Cu 29 9.0000 9.0000 2.7000 0.0000 0.0000\n", + " Cu 29 10.8000 7.2000 2.7000 0.0000 0.0000\n", + " Cu 29 9.0000 7.2000 4.5000 0.0000 0.0000\n", + " Cu 29 9.0000 9.0000 6.3000 0.0000 0.0000\n", + " Cu 29 10.8000 7.2000 6.3000 0.0000 0.0000\n", + " -----------------------------------------------------------------\n", + "\n", + "\n", + " ** enter calphas **\n", + " ---\n", + " total energy for atom in ground state \n", + " total energy for atom with a hole in l3 edge\n", + " calculated ionization energy for edge l3 = 946.40898981930718 eV\n", + " energy distance between edges l2 and l3 = 20.447898479699866 eV\n", + " ---\n", + " calculated ionization potential (ryd) = 69.588894358327252 \n", + " ---\n", + " \n", + " \n", + " symmetrizing coordinates... \n", + "\n", + "\n", + " symmetrized atomic coordinates of cluster \n", + "\n", + " position\n", + " atom no. x y z eq\n", + "\n", + " 1 osph 0 0.0000 0.0000 0.0000 0\n", + " 2 Cu 29 0.0000 0.0000 -2.3549 0\n", + " 3 Cu 29 -6.8030 0.0000 -2.3549 0\n", + " 4 Cu 29 -6.8030 0.0000 4.4481 0\n", + " 5 Cu 29 -3.4015 -3.4015 -2.3549 0\n", + " 6 Cu 29 0.0000 -6.8030 -2.3549 0\n", + " 7 Cu 29 0.0000 -3.4015 -5.7564 0\n", + " 8 Cu 29 -3.4015 -3.4015 4.4481 0\n", + " 9 Cu 29 0.0000 -6.8030 4.4481 0\n", + " 10 Cu 29 0.0000 -3.4015 1.0466 0\n", + " 11 Cu 29 -3.4015 0.0000 -5.7564 0\n", + " 12 Cu 29 -3.4015 3.4015 -2.3549 0\n", + " 13 Cu 29 0.0000 3.4015 -5.7564 0\n", + " 14 Cu 29 -3.4015 0.0000 1.0466 0\n", + " 15 Cu 29 -3.4015 3.4015 4.4481 0\n", + " 16 Cu 29 0.0000 0.0000 4.4481 0\n", + " 17 Cu 29 0.0000 3.4015 1.0466 0\n", + " 18 Cu 29 0.0000 6.8030 -2.3549 0\n", + " 19 Cu 29 0.0000 6.8030 4.4481 0\n", + " 20 Cu 29 3.4015 -3.4015 -2.3549 0\n", + " 21 Cu 29 3.4015 -3.4015 4.4481 0\n", + " 22 Cu 29 3.4015 0.0000 -5.7564 0\n", + " 23 Cu 29 3.4015 3.4015 -2.3549 0\n", + " 24 Cu 29 6.8030 0.0000 -2.3549 0\n", + " 25 Cu 29 3.4015 0.0000 1.0466 0\n", + " 26 Cu 29 3.4015 3.4015 4.4481 0\n", + " 27 Cu 29 6.8030 0.0000 4.4481 0\n", + "\n", + " computing muffin tin potential and phase shifts\n", + " generating core state wavefunction \n", + " generating final potential (complex hedin-lundqvist exchange) \n", + " MT radii for Hydrogen atoms determined by stdcrm unless other options are specified\n", + "\n", + " -----------------------------------------------------------------\n", + " i rs(i) i=1,natoms \n", + " 1 10.61 2 2.39 3 2.48 4 2.48 5 2.33 6 2.48 7 2.42 8 2.33\n", + " 9 2.48 10 2.34 11 2.42 12 2.43 13 2.41 14 2.34 15 2.33 16 2.33\n", + " 17 2.41 18 2.48 19 2.48 20 2.43 21 2.33 22 2.41 23 2.43 24 2.48\n", + " 25 2.41 26 2.48 27 2.48\n", + " N.B.: Order of atoms as reshuffled by symmetry routines \n", + " -----------------------------------------------------------------\n", + "\n", + " input value for coulomb interst. potential = -0.69999999999999996 \n", + " and interstitial rs = 3.0000000000000000 \n", + " lower bound for coulomb interst. potential = -0.42096854155426744 \n", + " and for interst. rs = 2.2601548755994800 \n", + "\n", + " lmax assignment based on l_max = r_mt * k_e + 2\n", + " where e is the running energy\n", + " optimal lmax chosen according to the running energy e for each atom\n", + "\n", + "\n", + " number of centers= 26\n", + "\n", + " starting potentials and/or charge densities written to file 13\n", + " symmetry information generated internally\n", + " symmetry information written to file 14\n", + "\n", + "\n", + " core initial state of type: 2p3/2\n", + "\n", + " fermi level = -0.18577\n", + "\n", + "\n", + " generating t_l (for030) and atomic cross section (for050)\n", + " corewf: fnisx = 0.99897282652190389 \n", + " writing atomic orbital energies\n", + " orbital energy (Ryd eV) 1s -665.31473820425299 -9051.6067087119445 \n", + " orbital energy (Ryd eV) 2s -83.344250979299673 -1133.8984964214017 \n", + " orbital energy (Ryd eV) 2p1/2 -72.640262391310984 -988.27073658171264 \n", + " orbital energy (Ryd eV) 2p3/2 -71.111924241975288 -967.47769675961820 \n", + " orbital energy (Ryd eV) 3s -10.313080620773222 -140.30945712466604 \n", + " orbital energy (Ryd eV) 3p1/2 -6.8622342038346620 -93.360693201889049 \n", + " orbital energy (Ryd eV) 3p3/2 -6.6575123914750813 -90.575453038451158 \n", + " orbital energy (Ryd eV) 3d3/2 -0.97575422779613052 -13.275135822501518 \n", + " orbital energy (Ryd eV) 3d5/2 -0.94859035000087122 -12.905571277531651 \n", + " orbital energy (Ryd eV) 4s -0.48955130473863673 -6.6603452768703502 \n", + "\n", + " using overlapped potential to search for core states of photoabsorber\n", + "\n", + " calculating non relativistic core states\n", + " ------------------------------\n", + " energy of core state = -647.40974057864071 for orbital =1s \n", + " n. of zeros found: 0 expected: 0\n", + " ------------------------------\n", + " energy of core state = -79.554273906250828 for orbital =2s \n", + " n. of zeros found: 1 expected: 1\n", + " ------------------------------\n", + " energy of core state = -70.720428814458870 for orbital =2p1/2\n", + " n. of zeros found: 0 expected: 0\n", + " ------------------------------\n", + " energy of core state = -70.720428814476662 for orbital =2p3/2\n", + " n. of zeros found: 0 expected: 0\n", + " ------------------------------\n", + " energy of core state = -8.8984913351029302 for orbital =3s \n", + " n. of zeros found: 2 expected: 2\n", + " ------------------------------\n", + " energy of core state = -6.0089160418603047 for orbital =3p1/2\n", + " n. of zeros found: 1 expected: 1\n", + " ------------------------------\n", + " energy of core state = -6.0089159791922135 for orbital =3p3/2\n", + " n. of zeros found: 1 expected: 1\n", + "\n", + " calculating relativistic core states\n", + " energy of core state = -656.39378974400631 for orb =1s \n", + " n. of zeros found: 0 expected: 0\n", + " energy of core state = -81.632060147320317 for orb =2s \n", + " n. of zeros found: 1 expected: 1\n", + " energy of core state = -72.635764622230667 for orb =2p1/2\n", + " n. of zeros found: 0 expected: 0\n", + " energy of core state = -71.074395040994631 for orb =2p3/2\n", + " n. of zeros found: 0 expected: 0\n", + " energy of core state = -9.2498851019868340 for orb =3s \n", + " n. of zeros found: 2 expected: 2\n", + " energy of core state = -6.2923189144601208 for orb =3p1/2\n", + " n. of zeros found: 1 expected: 1\n", + " energy of core state = -6.0867535547385900 for orb =3p3/2\n", + " n. of zeros found: 1 expected: 1\n", + " -------------------------------\n", + " density of the valence charge (au^{-3} 5.7214295960466316E-002\n", + " rs_v corresponding to valence density (au) 1.6099125416630322 \n", + " valence plasmon energy (in eV) 20.414212418262935 \n", + "\n", + " gamma = 0.000000 rsint = 3.578556\n", + "\n", + " check in subroutine cont\n", + " order of neighb. -- symb. -- dist. from absorber\n", + " \n", + " 22 Cu 4.8104573684277954 \n", + " 11 Cu 4.8104573684277971 \n", + " 12 Cu 4.8104573684277971 \n", + " 16 Cu 4.8104573684277971 \n", + " 19 Cu 4.8104573684277971 \n", + " 21 Cu 4.8104573684277971 \n", + " 24 Cu 4.8104573684277971 \n", + " 9 Cu 4.8104573684277989 \n", + " 13 Cu 4.8104573684277989 \n", + " 4 Cu 4.8104573684277998 \n", + " 10 Cu 4.8104573684277998 \n", + " 6 Cu 4.8104573684277998 \n", + " 17 Cu 6.8030140516481801 \n", + " 23 Cu 6.8030140516481801 \n", + " 5 Cu 6.8030140516481818 \n", + " 2 Cu 6.8030140516481818 \n", + " 15 Cu 6.8030140516481818 \n", + " 20 Cu 8.3319565697610241 \n", + " 14 Cu 8.3319565697610258 \n", + " 25 Cu 8.3319565697610241 \n", + " 7 Cu 8.3319565697610258 \n", + " 18 Cu 9.6209147368555961 \n", + " 26 Cu 9.6209147368555961 \n", + " 3 Cu 9.6209147368555978 \n", + " 8 Cu 9.6209147368555978 \n", + " -----------------------------------------------------------------\n", + " 1 Cu 0.000000\n", + " 4 Cu 4.810457\n", + " 6 Cu 4.810457\n", + " 9 Cu 4.810457\n", + " 10 Cu 4.810457\n", + " 11 Cu 4.810457\n", + " 12 Cu 4.810457\n", + " 13 Cu 4.810457\n", + " 16 Cu 4.810457\n", + " 19 Cu 4.810457\n", + " 21 Cu 4.810457\n", + " 22 Cu 4.810457\n", + " 24 Cu 4.810457\n", + " 2 Cu 6.803014\n", + " 5 Cu 6.803014\n", + " 15 Cu 6.803014\n", + " 17 Cu 6.803014\n", + " 23 Cu 6.803014\n", + " 7 Cu 8.331957\n", + " 14 Cu 8.331957\n", + " 20 Cu 8.331957\n", + " 25 Cu 8.331957\n", + " 3 Cu 9.620915\n", + " 8 Cu 9.620915\n", + " 18 Cu 9.620915\n", + " 26 Cu 9.620915\n", + " 1 Cu 0.000000\n", + " 24 Cu 4.810457\n", + " 23 Cu 6.803014\n", + " 25 Cu 8.331957\n", + " 26 Cu 9.620915\n", + " \n", + " irho = 2 entering vxc to calculate energy dependent exchange\n", + " energy dependent vcon = (-0.19406005312524771,0.14609730856378345) at energy 23.254999999999999 \n", + " check ionization potential: 69.588894358327252 \n", + " \n", + " \n", + " value of the mean free path:\n", + " -----------------------------------------------------------------\n", + " average mean free path in the cluster : mfp = 11.19104 angstrom at energy 23.25500\n", + "\n", + " -----------------------------------------------------------------\n", + " \n", + " calculating atomic t-matrix elements atm(n)\n", + " check orthogonality between core and continuum state\n", + " scalar product between core and continuum state = (-0.56419733810139194,0.62474878945367607)\n", + " --- sqrt(xe/pi) = (1.2415322757386615,-1.93379098468138516E-003)\n", + "\n", + "\n", + " ** phagen terminated normally ** \n", + "\n", + "\n" + ] + } + ], + "source": [ + "from ase.io import read\n", + "from msspec.calculator import MSSPEC\n", + "\n", + "\n", + "cluster = read('copper.cif')\n", + "# view the cluster\n", + "cluster.edit()\n", + "\n", + "# The \"emitter\" atom is located in the middle of the 3rd plane\n", + "cluster.emitter = 10\n", + "\n", + "# Create a \"calculator\"\n", + "calc = MSSPEC(spectroscopy='PED', algorithm='inversion', txt='msspec.log')\n", + "calc.set_atoms(cluster)\n", + "\n", + "data = calc.get_theta_scan(level='2p3/2')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "385f2556-852c-415c-8350-6fe1cfc897c0", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the result with the interactive GUI\n", + "data.view()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ef1be6d9-091e-4be1-90b6-d57e58a3950a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot using matplotlib directly\n", + "data[0].views[0].plot();" + ] + }, + { + "cell_type": "markdown", + "id": "85c7dcac-9f0e-4a56-8077-c96f89865dcb", + "metadata": {}, + "source": [ + "## Shaping a cluster\n", + "\n", + "Based on the previous *.cif file, create a new cluster without the deepest plane and run the same calculation for the same emitter\n", + "\n", + "> **Note**:\n", + "> As the cluster will contain fewer atoms, the emitter index will be different\n", + "\n", + "What do you conclude ?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ca106e8e-cc03-4bd3-a67a-9f2a7b0025ec", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true, + "source_hidden": true + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'NoneType' object has no attribute 'upper'\n", + "'integrals' is ignored since the 'spinpol' global parameter is set to False. Enable spin polarization in the constructor of your Calculator if you want to use this option.\n", + "The sample temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n", + "The sample Debye temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Unfold to see the soluce\n", + "# Edit the previous cluster\n", + "# cluster = read('./UK_School/copper_3planes.cif')\n", + "# cluster.edit()\n", + "# Emitter index is now n°8\n", + "\n", + "cluster = read('./UK_School/copper_3planes.cif')\n", + "cluster.emitter = 8\n", + "\n", + "calc = MSSPEC(spectroscopy='PED', algorithm='inversion', txt='msspec.log')\n", + "calc.set_atoms(cluster)\n", + "\n", + "data = calc.get_theta_scan(level='2p3/2')\n", + "data[0].views[0].plot();" + ] + }, + { + "cell_type": "markdown", + "id": "bc21cc1b-384f-4df0-861a-eddb5d8a7b49", + "metadata": {}, + "source": [ + "The number of atoms used for the calculation greatly impact the calculation time and memory. Most of the time, a cluster is shaped as an hemisphere to minimize the number of atoms to take into account" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f7ecc1d0-097d-4199-822a-c564e9e94337", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "461829b650494b99acf1efd720761abf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(NGLWidget(), VBox(children=(Dropdown(description='Show', options=('All', 'Cu'), value='All'), D…" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from msspec.utils import hemispherical_cluster, get_atom_index\n", + "from ase.build import bulk\n", + "\n", + "copper = bulk('Cu', cubic=True)\n", + "cluster = hemispherical_cluster(copper, planes=3, emitter_plane=2)\n", + "cluster.emitter = get_atom_index(cluster, 0,0,0)\n", + "\n", + "view(cluster)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1f83a3b5-1248-482d-9686-488acbc70021", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'NoneType' object has no attribute 'upper'\n", + "'integrals' is ignored since the 'spinpol' global parameter is set to False. Enable spin polarization in the constructor of your Calculator if you want to use this option.\n", + "The sample temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n", + "The sample Debye temperature was set, but will be ignored since 'use_debye_model' parameter is False.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calc = MSSPEC(spectroscopy='PED', algorithm='inversion', txt='msspec.log')\n", + "calc.set_atoms(cluster)\n", + "\n", + "data = calc.get_theta_scan(level='2p3/2');\n", + "data[0].views[0].plot();" + ] + } + ], + "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.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Activity01/copper.cif b/Activity01/copper.cif new file mode 100644 index 0000000..0490639 --- /dev/null +++ b/Activity01/copper.cif @@ -0,0 +1,51 @@ +data_image0 +_chemical_formula_structural Cu26 +_chemical_formula_sum "Cu26" +_cell_length_a 14.4 +_cell_length_b 14.4 +_cell_length_c 7.2 +_cell_angle_alpha 90.0 +_cell_angle_beta 90.0 +_cell_angle_gamma 90.0 + +_space_group_name_H-M_alt "P 1" +_space_group_IT_number 1 + +loop_ + _space_group_symop_operation_xyz + 'x, y, z' + +loop_ + _atom_site_type_symbol + _atom_site_label + _atom_site_symmetry_multiplicity + _atom_site_fract_x + _atom_site_fract_y + _atom_site_fract_z + _atom_site_occupancy + Cu Cu1 1.0 0.25 0.5 0.37500000000000017 1.0000 + Cu Cu2 1.0 0.25 0.5 0.8750000000000001 1.0000 + Cu Cu3 1.0 0.3750000000000001 0.37500000000000017 0.37500000000000017 1.0000 + Cu Cu4 1.0 0.5 0.24999999999999992 0.37500000000000017 1.0000 + Cu Cu5 1.0 0.5 0.37500000000000017 0.12499999999999996 1.0000 + Cu Cu6 1.0 0.3750000000000001 0.37500000000000017 0.8750000000000001 1.0000 + Cu Cu7 1.0 0.5 0.24999999999999992 0.8750000000000001 1.0000 + Cu Cu8 1.0 0.5 0.37500000000000017 0.625 1.0000 + Cu Cu9 1.0 0.3750000000000001 0.5 0.12499999999999996 1.0000 + Cu Cu10 1.0 0.3750000000000001 0.6249999999999999 0.37500000000000017 1.0000 + Cu Cu11 1.0 0.5 0.5 0.37500000000000017 1.0000 + Cu Cu12 1.0 0.5 0.6249999999999999 0.12499999999999996 1.0000 + Cu Cu13 1.0 0.3750000000000001 0.5 0.625 1.0000 + Cu Cu14 1.0 0.3750000000000001 0.6249999999999999 0.8750000000000001 1.0000 + Cu Cu15 1.0 0.5 0.5 0.8750000000000001 1.0000 + Cu Cu16 1.0 0.5 0.6249999999999999 0.625 1.0000 + Cu Cu17 1.0 0.5 0.7500000000000003 0.37500000000000017 1.0000 + Cu Cu18 1.0 0.5 0.7500000000000003 0.8750000000000001 1.0000 + Cu Cu19 1.0 0.6249999999999999 0.37500000000000017 0.37500000000000017 1.0000 + Cu Cu20 1.0 0.6249999999999999 0.37500000000000017 0.8750000000000001 1.0000 + Cu Cu21 1.0 0.6249999999999999 0.5 0.12499999999999996 1.0000 + Cu Cu22 1.0 0.6249999999999999 0.6249999999999999 0.37500000000000017 1.0000 + Cu Cu23 1.0 0.7500000000000003 0.5 0.37500000000000017 1.0000 + Cu Cu24 1.0 0.6249999999999999 0.5 0.625 1.0000 + Cu Cu25 1.0 0.6249999999999999 0.6249999999999999 0.8750000000000001 1.0000 + Cu Cu26 1.0 0.7500000000000003 0.5 0.8750000000000001 1.0000 diff --git a/Activity01/copper_3planes.cif b/Activity01/copper_3planes.cif new file mode 100644 index 0000000..6dfa7ae --- /dev/null +++ b/Activity01/copper_3planes.cif @@ -0,0 +1,47 @@ +data_image0 +_chemical_formula_structural Cu22 +_chemical_formula_sum "Cu22" +_cell_length_a 14.4 +_cell_length_b 14.4 +_cell_length_c 7.2 +_cell_angle_alpha 90.0 +_cell_angle_beta 90.0 +_cell_angle_gamma 90.0 + +_space_group_name_H-M_alt "P 1" +_space_group_IT_number 1 + +loop_ + _space_group_symop_operation_xyz + 'x, y, z' + +loop_ + _atom_site_type_symbol + _atom_site_label + _atom_site_symmetry_multiplicity + _atom_site_fract_x + _atom_site_fract_y + _atom_site_fract_z + _atom_site_occupancy + Cu Cu1 1.0 0.25 0.5 0.37500000000000017 1.0000 + Cu Cu2 1.0 0.25 0.5 0.8750000000000001 1.0000 + Cu Cu3 1.0 0.37500000000000017 0.37500000000000017 0.37500000000000017 1.0000 + Cu Cu4 1.0 0.5 0.24999999999999992 0.37500000000000017 1.0000 + Cu Cu5 1.0 0.37500000000000017 0.37500000000000017 0.8750000000000001 1.0000 + Cu Cu6 1.0 0.5 0.24999999999999992 0.8750000000000001 1.0000 + Cu Cu7 1.0 0.5 0.37500000000000017 0.625 1.0000 + Cu Cu8 1.0 0.37500000000000017 0.6249999999999999 0.37500000000000017 1.0000 + Cu Cu9 1.0 0.5 0.5 0.37500000000000017 1.0000 + Cu Cu10 1.0 0.37500000000000017 0.5 0.625 1.0000 + Cu Cu11 1.0 0.37500000000000017 0.6249999999999999 0.8750000000000001 1.0000 + Cu Cu12 1.0 0.5 0.5 0.8750000000000001 1.0000 + Cu Cu13 1.0 0.5 0.6249999999999999 0.625 1.0000 + Cu Cu14 1.0 0.5 0.7500000000000003 0.37500000000000017 1.0000 + Cu Cu15 1.0 0.5 0.7500000000000003 0.8750000000000001 1.0000 + Cu Cu16 1.0 0.6249999999999999 0.37500000000000017 0.37500000000000017 1.0000 + Cu Cu17 1.0 0.6249999999999999 0.37500000000000017 0.8750000000000001 1.0000 + Cu Cu18 1.0 0.6249999999999999 0.6249999999999999 0.37500000000000017 1.0000 + Cu Cu19 1.0 0.7500000000000003 0.5 0.37500000000000017 1.0000 + Cu Cu20 1.0 0.6249999999999999 0.5 0.625 1.0000 + Cu Cu21 1.0 0.6249999999999999 0.6249999999999999 0.8750000000000001 1.0000 + Cu Cu22 1.0 0.7500000000000003 0.5 0.8750000000000001 1.0000